@wdio/nightwatch-devtools 1.3.0 → 1.5.0

package/dist/index.js

@@ -17,7 +17,72 @@ import {
 // src/index.ts
 import { fileURLToPath } from "url";
 
-// ../core/src/action-mapping.ts
+// ../shared/src/files.ts
+var SPEC_FILE_RE = /\.(?:test|spec)\.[cm]?[jt]sx?$/i;
+
+// ../shared/src/routes.ts
+var WS_PATHS = {
+  /** Adapter session upgrade endpoint. One socket per running adapter. */
+  worker: "/worker",
+  /** App/UI client upgrade endpoint. Multiple browser tabs may connect. */
+  client: "/client"
+};
+var WS_SCOPE = {
+  /** Backend → worker: a dashboard client has subscribed. Wakes up the
+   *  adapter's `await UI ready` gate before tests start. */
+  clientConnected: "clientConnected",
+  /** Backend → worker: the last dashboard tab closed. Triggers the
+   *  interactive shutdown flow (close WS, exit, pkill the dashboard). */
+  clientDisconnected: "clientDisconnected",
+  /** Worker → backend → clients (or app-local): wipe the visualization data
+   *  for a specific test/suite uid (or the whole tree). */
+  clearExecutionData: "clearExecutionData",
+  /** Worker → backend: clear-by-test-uid request (drives clearExecutionData). */
+  clearCommands: "clearCommands",
+  /** Backend → clients: signal that the active run was stopped by the UI. */
+  testStopped: "testStopped",
+  /** Worker → backend → clients: swap an earlier captured command for an
+   *  updated entry (used when a retry coalesces commands). */
+  replaceCommand: "replaceCommand",
+  /** Worker → backend: register the config file path so reruns can spawn
+   *  with the same config. */
+  config: "config"
+};
+
+// ../shared/src/runner.ts
+var REUSE_ENV = {
+  REUSE: "DEVTOOLS_APP_REUSE",
+  HOST: "DEVTOOLS_APP_HOST",
+  PORT: "DEVTOOLS_APP_PORT",
+  RERUN_LABEL: "DEVTOOLS_RERUN_LABEL",
+  RERUN_ENTRY_TYPE: "DEVTOOLS_RERUN_ENTRY_TYPE"
+};
+
+// ../shared/src/timing.ts
+var TIMING_BASE = {
+  /** ms to let the dashboard render between rapid state updates. */
+  UI_RENDER_DELAY: 150,
+  /** ms to wait after a test starts before flushing initial state. */
+  TEST_START_DELAY: 100,
+  /** ms gap between consecutive suite-finalize broadcasts. */
+  SUITE_COMPLETE_DELAY: 200,
+  /** ms allowed for the browser-close handshake before forcing teardown. */
+  BROWSER_CLOSE_WAIT: 2e3,
+  /** ms before first worker WS connection attempt — lets backend bind. */
+  INITIAL_CONNECTION_WAIT: 500,
+  /** ms between browser-window-alive polls. */
+  BROWSER_POLL_INTERVAL: 1e3
+};
+var DEFAULTS_BASE = {
+  /** Synthetic capability ID — present on every CommandLog / TestStats. */
+  CID: "0-0",
+  /** TestStats.retries default — adapters that surface retry counts override. */
+  RETRIES: 0,
+  /** _duration placeholder for not-yet-finalized stats. */
+  DURATION: 0
+};
+
+// ../shared/src/trace-actions.ts
 var ACTION_MAP = {
   // WDIO browser-level
   url: { class: "Page", method: "navigate" },
@@ -48,6 +113,25 @@ var ACTION_MAP = {
   switchToFrame: { class: "Frame", method: "goto" },
   touchAction: { class: "Element", method: "tap" }
 };
+
+// ../shared/src/types.ts
+var TEST_STATE = {
+  PENDING: "pending",
+  RUNNING: "running",
+  PASSED: "passed",
+  FAILED: "failed",
+  SKIPPED: "skipped"
+};
+var SCREENCAST_DEFAULTS = {
+  enabled: false,
+  captureFormat: "jpeg",
+  quality: 70,
+  maxWidth: 1280,
+  maxHeight: 720,
+  pollIntervalMs: 200
+};
+
+// ../core/src/action-mapping.ts
 function mapCommandToAction(command) {
   return ACTION_MAP[command] ?? null;
 }
@@ -1206,21 +1290,8 @@ function serializeWebSnapshot(nodes, context, options = {}) {
     }
     const indent = "  ".repeat(node.depth + 1);
     const isInteractive = INTERACTIVE_ROLES.has(node.role);
-    if (node.role === "statictext" && node.name) {
-      let echoedByParent = false;
-      for (let j = i - 1; j >= 0; j--) {
-        if (nodes[j].depth < node.depth) {
-          const parentRole = nodes[j].role;
-          const parentName = nodes[j].name;
-          if (INTERACTIVE_ROLES.has(parentRole) && parentName && parentName.includes(node.name)) {
-            echoedByParent = true;
-          }
-          break;
-        }
-      }
-      if (echoedByParent) {
-        continue;
-      }
+    if (isStatictextEchoedByParent(nodes, i)) {
+      continue;
     }
     const roleLabel = node.role === "heading" && node.level ? `heading[${node.level}]` : node.role;
     if (isInteractive) {
@@ -1245,6 +1316,22 @@ function serializeWebSnapshot(nodes, context, options = {}) {
   }
   return lines.join("\n");
 }
+function isStatictextEchoedByParent(nodes, index) {
+  const node = nodes[index];
+  if (node.role !== "statictext" || !node.name) {
+    return false;
+  }
+  for (let j = index - 1; j >= 0; j--) {
+    if (nodes[j].depth < node.depth) {
+      const parent = nodes[j];
+      if (INTERACTIVE_ROLES.has(parent.role) && parent.name && parent.name.includes(node.name)) {
+        return true;
+      }
+      break;
+    }
+  }
+  return false;
+}
 function simplifyTag(tagName) {
   const dot = tagName.lastIndexOf(".");
   if (dot !== -1) {
@@ -1412,7 +1499,8 @@ function collectMobileNodes(element, platform, depth, nodes, walkOpts) {
         depth,
         isInteractive: false,
         isExplicitInteractive: false,
-        isInViewport: false
+        isInViewport: false,
+        tagName: element.tagName
       });
       return;
     }
@@ -1445,7 +1533,8 @@ function collectMobileNodes(element, platform, depth, nodes, walkOpts) {
     depth,
     isInteractive: interactive,
     isExplicitInteractive: explicit,
-    isInViewport: inViewport
+    isInViewport: inViewport,
+    tagName: element.tagName
   });
   for (const child of element.children || []) {
     collectMobileNodes(child, platform, depth + 1, nodes, walkOpts);
@@ -2060,15 +2149,46 @@ function buildContextOptions(trace, contextId, wallTime) {
     }
   };
 }
-function buildActionEvents(commands, pageId, 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;
@@ -2098,7 +2218,8 @@ function buildActionEvents(commands, pageId, wallTime) {
       pageId,
       params,
       title: formatActionTitle(action, cmd.args, params),
-      apiName: `${action.class.toLowerCase()}.${action.method}`
+      apiName: `${action.class.toLowerCase()}.${action.method}`,
+      parentId: groupCallId
     });
     const afterEvent = {
       type: "after",
@@ -2112,6 +2233,14 @@ function buildActionEvents(commands, pageId, wallTime) {
     events.push(afterEvent);
     prevEndMs = endMs;
   }
+  if (lastTestUid && groupCallId) {
+    callCounter++;
+    events.push({
+      type: "after",
+      callId: groupCallId,
+      endTime: prevEndMs
+    });
+  }
   return events;
 }
 function buildNetworkNdjson(requests, wallTime, pageId) {
@@ -2268,7 +2397,7 @@ function buildTraceBundle(trace, opts = {}) {
       wallTime,
       viewport
     ),
-    ...buildActionEvents(trace.commands, pageId, wallTime)
+    ...buildActionEvents(trace.commands, pageId, wallTime, opts.testMetadata)
   );
   events.sort(compareEvents);
   const ctxBName = ctxOptions.title;
@@ -2326,7 +2455,8 @@ async function writeTraceZip(capturer, opts) {
   await fs.mkdir(opts.outputDir, { recursive: true });
   const exportOpts = {
     sessionId: opts.sessionId,
-    wallTimeOverride: capturer.startWallTime
+    wallTimeOverride: capturer.startWallTime,
+    testMetadata: opts.testMetadata
   };
   if (opts.format === "ndjson-directory") {
     const dir = path.join(opts.outputDir, `trace-${opts.sessionId}`);
@@ -2424,6 +2554,15 @@ function runFfmpeg(ffmpeg, manifestPath, outputPath) {
       "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",
@@ -2487,7 +2626,8 @@ async function finalizeScreencast({
       videoPath,
       videoFile: fileName,
       frameCount: frames.length,
-      duration: recorder.duration
+      duration: recorder.duration,
+      startTime: frames[0]?.timestamp
     });
   } catch (err) {
     log12("warn", `Screencast encode failed: ${errorMessage(err)}`);
@@ -2644,88 +2784,6 @@ var RetryTracker = class {
   }
 };
 
-// ../shared/src/files.ts
-var SPEC_FILE_RE = /\.(?:test|spec)\.[cm]?[jt]sx?$/i;
-
-// ../shared/src/routes.ts
-var WS_PATHS = {
-  /** Adapter session upgrade endpoint. One socket per running adapter. */
-  worker: "/worker",
-  /** App/UI client upgrade endpoint. Multiple browser tabs may connect. */
-  client: "/client"
-};
-var WS_SCOPE = {
-  /** Backend → worker: a dashboard client has subscribed. Wakes up the
-   *  adapter's `await UI ready` gate before tests start. */
-  clientConnected: "clientConnected",
-  /** Backend → worker: the last dashboard tab closed. Triggers the
-   *  interactive shutdown flow (close WS, exit, pkill the dashboard). */
-  clientDisconnected: "clientDisconnected",
-  /** Worker → backend → clients (or app-local): wipe the visualization data
-   *  for a specific test/suite uid (or the whole tree). */
-  clearExecutionData: "clearExecutionData",
-  /** Worker → backend: clear-by-test-uid request (drives clearExecutionData). */
-  clearCommands: "clearCommands",
-  /** Backend → clients: signal that the active run was stopped by the UI. */
-  testStopped: "testStopped",
-  /** Worker → backend → clients: swap an earlier captured command for an
-   *  updated entry (used when a retry coalesces commands). */
-  replaceCommand: "replaceCommand",
-  /** Worker → backend: register the config file path so reruns can spawn
-   *  with the same config. */
-  config: "config"
-};
-
-// ../shared/src/runner.ts
-var REUSE_ENV = {
-  REUSE: "DEVTOOLS_APP_REUSE",
-  HOST: "DEVTOOLS_APP_HOST",
-  PORT: "DEVTOOLS_APP_PORT",
-  RERUN_LABEL: "DEVTOOLS_RERUN_LABEL",
-  RERUN_ENTRY_TYPE: "DEVTOOLS_RERUN_ENTRY_TYPE"
-};
-
-// ../shared/src/timing.ts
-var TIMING_BASE = {
-  /** ms to let the dashboard render between rapid state updates. */
-  UI_RENDER_DELAY: 150,
-  /** ms to wait after a test starts before flushing initial state. */
-  TEST_START_DELAY: 100,
-  /** ms gap between consecutive suite-finalize broadcasts. */
-  SUITE_COMPLETE_DELAY: 200,
-  /** ms allowed for the browser-close handshake before forcing teardown. */
-  BROWSER_CLOSE_WAIT: 2e3,
-  /** ms before first worker WS connection attempt — lets backend bind. */
-  INITIAL_CONNECTION_WAIT: 500,
-  /** ms between browser-window-alive polls. */
-  BROWSER_POLL_INTERVAL: 1e3
-};
-var DEFAULTS_BASE = {
-  /** Synthetic capability ID — present on every CommandLog / TestStats. */
-  CID: "0-0",
-  /** TestStats.retries default — adapters that surface retry counts override. */
-  RETRIES: 0,
-  /** _duration placeholder for not-yet-finalized stats. */
-  DURATION: 0
-};
-
-// ../shared/src/types.ts
-var TEST_STATE = {
-  PENDING: "pending",
-  RUNNING: "running",
-  PASSED: "passed",
-  FAILED: "failed",
-  SKIPPED: "skipped"
-};
-var SCREENCAST_DEFAULTS = {
-  enabled: false,
-  captureFormat: "jpeg",
-  quality: 70,
-  maxWidth: 1280,
-  maxHeight: 720,
-  pollIntervalMs: 200
-};
-
 // ../core/src/screencast.ts
 var ScreencastRecorderBase = class {
   buffer = [];
@@ -2951,9 +3009,12 @@ var SessionCapturerBase = class {
   metadata;
   // ── Construction ────────────────────────────────────────────────────────
   constructor(opts = {}) {
-    const { hostname, port } = opts;
+    const { hostname, port, reconnect } = opts;
     if (hostname && port) {
-      this.ws = new WebSocket(`ws://${hostname}:${port}${WS_PATHS.worker}`);
+      const query = reconnect ? "?reconnect=1" : "";
+      this.ws = new WebSocket(
+        `ws://${hostname}:${port}${WS_PATHS.worker}${query}`
+      );
       this.ws.on("open", () => {
         this.#hasConnected = true;
         this.onWsOpen();
@@ -3285,6 +3346,100 @@ 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 {
@@ -3824,6 +3979,13 @@ async function openDevtoolsBrowser(ctx, url) {
             "--no-first-run",
             "--no-default-browser-check"
           ]
+        },
+        // Dashboard uses the Puppeteer-based 'devtools' protocol; drop the
+        // "controlled by automated test software" infobar by ignoring
+        // Puppeteer's --enable-automation default. (Runtime-valid capability
+        // not present in the type.)
+        "wdio:devtoolsOptions": {
+          ignoreDefaultArgs: ["--enable-automation"]
         }
       }
     });
@@ -4515,18 +4677,22 @@ function applyResponseReceived(p, response) {
   p.mimeType = response.mimeType;
   p.type = getRequestType(p.url, response.mimeType);
 }
+function eventTimeMs(params, entry) {
+  return typeof params.timestamp === "number" ? Math.round(params.timestamp * 1e3) : entry.timestamp;
+}
 function startPendingRequest(params, entry, pending) {
   const { requestId, request: req, timestamp } = params;
   if (!req || typeof timestamp !== "number") {
     return;
   }
+  const startTime = eventTimeMs(params, entry);
   pending.set(requestId, {
     id: `${entry.timestamp}-${requestId}`,
     url: req.url,
     method: req.method,
     requestHeaders: req.headers ?? {},
-    timestamp: Math.round(timestamp * 1e3),
-    startTime: entry.timestamp
+    timestamp: startTime,
+    startTime
   });
 }
 function handlePerfLogEvent(method, params, entry, pending, completed) {
@@ -4545,8 +4711,8 @@ function handlePerfLogEvent(method, params, entry, pending, completed) {
     const p = pending.get(params.requestId);
     if (p && p.status !== void 0) {
       p.size = params.encodedDataLength;
-      p.endTime = entry.timestamp;
-      p.time = entry.timestamp - p.startTime;
+      p.endTime = eventTimeMs(params, entry);
+      p.time = Math.max(0, p.endTime - p.startTime);
       completed.push({ ...p });
       pending.delete(params.requestId);
     }
@@ -4556,8 +4722,8 @@ function handlePerfLogEvent(method, params, entry, pending, completed) {
     const p = pending.get(params.requestId);
     if (p) {
       p.error = params.errorText;
-      p.endTime = entry.timestamp;
-      p.time = entry.timestamp - p.startTime;
+      p.endTime = eventTimeMs(params, entry);
+      p.time = Math.max(0, p.endTime - p.startTime);
       completed.push({ ...p });
       pending.delete(params.requestId);
     }
@@ -5754,7 +5920,7 @@ async function tryAttachBidi(ctx, browser) {
     log10.warn("bidi:true set but browser.driver unavailable \u2014 skipping");
     return;
   }
-  const { attachBidiHandlers, buildBidiSinks } = await import("./bidi-OH4ZFDN5.js");
+  const { attachBidiHandlers, buildBidiSinks } = await import("./bidi-FIHBBGT4.js");
   const ok = await attachBidiHandlers(
     driver,
     buildBidiSinks(ctx.sessionCapturer)
@@ -5790,7 +5956,13 @@ async function ensureSessionInitialized(ctx, browser, finalizeCurrentScreencast2
     (resolve2) => setTimeout(resolve2, TIMING.INITIAL_CONNECTION_WAIT)
   );
   ctx.sessionCapturer = new SessionCapturer(
-    ctx.mode === "trace" ? {} : { port: ctx.port, hostname: ctx.hostname },
+    ctx.mode === "trace" ? {} : {
+      port: ctx.port,
+      hostname: ctx.hostname,
+      // A session change reopens the WS mid-run — tell the backend to keep
+      // the accumulated run state so earlier tests' commands survive.
+      reconnect: Boolean(isSessionChange)
+    },
     browser
   );
   ctx.sessionCapturer.traceMode = ctx.mode;
@@ -5851,6 +6023,10 @@ var NightwatchDevToolsPlugin = class {
   #skipCount = 0;
   #configPath;
   #srcFolders = [];
+  /** Index ranges into the session capturer's flat arrays, one per spec file. */
+  #specRanges = [];
+  /** Set of spec files already flushed to disk. */
+  #flushedSpecs = /* @__PURE__ */ new Set();
   #getRerunLabel() {
     return process.env[REUSE_ENV.RERUN_ENTRY_TYPE] === "test" ? process.env[REUSE_ENV.RERUN_LABEL]?.trim() : void 0;
   }
@@ -5872,7 +6048,8 @@ var NightwatchDevToolsPlugin = class {
       screencast,
       bidi: options.bidi ?? false,
       mode,
-      traceFormat: options.traceFormat ?? "zip"
+      traceFormat: options.traceFormat ?? "zip",
+      traceGranularity: options.traceGranularity ?? "session"
     };
     this.#screencastOptions = { ...SCREENCAST_DEFAULTS, ...screencast };
     this.#bidiEnabled = options.bidi === true;
@@ -6130,6 +6307,25 @@ var NightwatchDevToolsPlugin = class {
       this.sessionCapturer.captureSource(fullPath).catch(() => {
       });
     }
+    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)}`
+          )
+        );
+      }
+    }
     await this.#closePreviousRunningTest(currentSuite, testFile, currentTest);
     const processedTests = this.testManager.getProcessedTests(testFile);
     const currentTestName = this.#pickCurrentTestName(
@@ -6187,6 +6383,42 @@ 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);
+    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
+          });
+        }
+      }
+    }
+    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;
+  }
   async #writeTraceZipIfNeeded() {
     if (this.options.mode !== "trace" || !this.sessionCapturer) {
       return;
@@ -6199,6 +6431,28 @@ var NightwatchDevToolsPlugin = class {
       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({
@@ -6206,7 +6460,8 @@ var NightwatchDevToolsPlugin = class {
         }),
         sessionId,
         actionSnapshots: snapshots.length ? snapshots : void 0,
-        format: this.options.traceFormat
+        format: this.options.traceFormat,
+        testMetadata
       });
       log11.info(`Trace saved to ${tracePath}`);
     } catch (err) {