nodejs · MoLow · May 19, 2026 · May 19, 2026
diff --git a/lib/internal/test_runner/reporter/rerun.js b/lib/internal/test_runner/reporter/rerun.js
@@ -62,6 +62,7 @@ function reportReruns(previousRuns, globalOptions) {
           name: data.name,
           children,
           passed_on_attempt: data.details.passed_on_attempt ?? data.details.attempt,
+          duration_ms: data.details.duration_ms,
         };
       }
     }

diff --git a/lib/internal/test_runner/reporter/utils.js b/lib/internal/test_runner/reporter/utils.js
@@ -73,7 +73,10 @@ function formatTestReport(type, data, showErrorDetails = true, prefix = '', inde
   let symbol = reporterUnicodeSymbolMap[type] ?? ' ';
   const { skip, todo, expectFailure } = data;
   const duration_ms = data.details?.duration_ms ? ` ${colors.gray}(${data.details.duration_ms}ms)${colors.white}` : '';
-  let title = `${data.name}${duration_ms}`;
+  const replayed = data.details?.passed_on_attempt !== undefined ?
+    ` ${colors.gray}(passed on attempt ${data.details.passed_on_attempt})${colors.white}` :
+    '';
+  let title = `${data.name}${duration_ms}${replayed}`;
 
   if (skip !== undefined) {
     title += ` # ${typeof skip === 'string' && skip.length ? skip : 'SKIP'}`;

diff --git a/lib/internal/test_runner/test.js b/lib/internal/test_runner/test.js
@@ -10,10 +10,12 @@ const {
   ArrayPrototypeSplice,
   ArrayPrototypeUnshift,
   ArrayPrototypeUnshiftApply,
+  BigInt,
   Error,
   FunctionPrototype,
   MathFloor,
   MathMax,
+  MathRound,
   Number,
   NumberPrototypeToFixed,
   ObjectFreeze,
@@ -803,14 +805,25 @@ class Test extends AsyncResource {
       const previousAttempt = this.root.harness.previousRuns[this.attempt - 1]?.[testIdentifier];
       if (previousAttempt != null) {
         this.passedAttempt = previousAttempt.passed_on_attempt;
+        if (previousAttempt.duration_ms !== undefined) {
+          this.replayedDurationNs = BigInt(MathRound(previousAttempt.duration_ms * 1_000_000));
+        }
         this.fn = () => {
+          // Restore the original duration on the synthetic replay. Suites are
+          // skipped here because Suite.run() unconditionally reassigns
+          // startTime later; only non-suite tests benefit from setting it.
+          if (this.reportedType !== 'suite') {
+            this.startTime = hrtime();
+            this.endTime = this.startTime + (this.replayedDurationNs ?? 0n);
+          }
           for (let i = 0; i < (previousAttempt.children?.length ?? 0); i++) {
             const child = previousAttempt.children[i];
             const t = this.createSubtest(Test, child.name, { __proto__: null }, noop, {
               __proto__: null,
               loc: [child.line, child.column, child.file],
             }, noop);
-            t.endTime = t.startTime = hrtime();
+            t.startTime = hrtime();
+            t.endTime = t.startTime + (t.replayedDurationNs ?? 0n);
             // For suites, Suite.run() starts the subtests via SafePromiseAll.
             // Starting them here as well would run them twice, re-invoking the
             // synthetic children-creator against a now-incremented disambiguator

diff --git a/test/fixtures/test-runner/rerun-duration.js b/test/fixtures/test-runner/rerun-duration.js
@@ -0,0 +1,13 @@
+'use strict';
+// A passing test with a measurable duration alongside a failing test. The
+// failing test forces the rerun feature to retry on a second invocation,
+// causing the passing test to be replayed via the synthetic noop stub.
+const { test } = require('node:test');
+
+test('passing slow test', async () => {
+  await new Promise((resolve) => setTimeout(resolve, 25));
+});
+
+test('always failing', () => {
+  throw new Error('boom');
+});
diff --git a/test/parallel/test-runner-test-rerun-failures.js b/test/parallel/test-runner-test-rerun-failures.js
@@ -89,6 +89,7 @@ const getStateFile = async () => {
   res.forEach((entry) => {
     for (const item in entry) {
       delete entry[item].children;
+      delete entry[item].duration_ms;
     }
   });
   return res;
@@ -152,6 +153,27 @@ test('test should pass on third rerun with `--test`', async () => {
   assert.deepStrictEqual(await getStateFile(), expectedStateFile);
 });
 
+test('rerun preserves the original duration on the replayed pass', async () => {
+  const durationFixture = fixtures.path('test-runner', 'rerun-duration.js');
+  const args = ['--test-rerun-failures', stateFile, durationFixture];
+
+  const first = await common.spawnPromisified(process.execPath, args);
+  assert.doesNotMatch(first.stdout, /passed on attempt/,
+                      'no replay marker should appear on the initial run');
+
+  const second = await common.spawnPromisified(process.execPath, args);
+  assert.match(second.stdout, /passing slow test[^\n]*\(passed on attempt 0\)/,
+               'spec reporter should mark the replayed test on the retry');
+  assert.doesNotMatch(second.stdout, /always failing[^\n]*\(passed on attempt/,
+                      'the failing test must not show the replay marker');
+
+  const raw = JSON.parse(await readFile(stateFile, 'utf8'));
+  const passKey = Object.keys(raw[0]).find((k) => raw[0][k].name === 'passing slow test');
+  assert.ok(passKey, 'expected the passing test to be recorded on attempt 0');
+  assert.ok(raw[0][passKey].duration_ms > 0, 'expected a measurable duration on attempt 0');
+  assert.strictEqual(raw[1][passKey].duration_ms, raw[0][passKey].duration_ms);
+});
+
 test('using `run` api', async () => {
   let stream = run({ files: [fixture], rerunFailuresFilePath: stateFile });
   stream.on('test:pass', common.mustCall(19));