as-test 1.5.2 → 1.6.0

package/bin/commands/run-core.js

@@ -20,6 +20,11 @@ import { PassThrough } from "stream";
 import { buildWebRunnerSource } from "./web-runner-source.js";
 import { PersistentWebSessionHost } from "./web-session.js";
 import { build } from "./build-core.js";
+import {
+  cacheStorage,
+  reportHasFailure,
+  sha256OfFile,
+} from "../build-cache.js";
 import { resolveSpecFiles, emitSelectorWarnings } from "../selectors.js";
 import { createReporter as createDefaultReporter } from "../reporters/default.js";
 import { createTapReporter } from "../reporters/tap.js";
@@ -808,6 +813,7 @@ export async function run(
       ? await PersistentWebSessionHost.start(false)
       : null;
   const webSession = options.webSession ?? ownedWebSession;
+  const cacheCtx = cacheStorage.getStore();
   try {
     for (let i = 0; i < inputFiles.length; i++) {
       const file = inputFiles[i];
@@ -815,6 +821,72 @@ export async function run(
         config.outDir,
         resolveArtifactPath(file, config.input),
       );
+      // Tier 2: replay a stored passing report instead of running. build() ran
+      // first this session and validated the build is fresh (else it cleared
+      // the stored report), so here we only re-check the run-specific inputs.
+      if (cacheCtx?.replay) {
+        const snapPath = resolveSnapshotPath(
+          file,
+          config.snapshotDir,
+          config.input,
+        );
+        const snapshotSha = existsSync(snapPath)
+          ? sha256OfFile(snapPath)
+          : null;
+        if (
+          cacheCtx.cache.canReplay(options.modeName, file, {
+            runtimeCmd: runtimeCommand,
+            snapshotSha,
+          })
+        ) {
+          const cached = cacheCtx.cache.getReport(options.modeName, file);
+          if (cached && !reportHasFailure(cached)) {
+            const cachedSuites = Array.isArray(cached.suites)
+              ? cached.suites
+              : [];
+            const selected = options.suiteSelectors?.length
+              ? filterSelectedSuites(
+                  cachedSuites,
+                  options.suiteSelectors,
+                  file,
+                  options.modeName ?? "default",
+                )
+              : cachedSuites;
+            replayCachedReport(reporter, file, selected);
+            const cachedSnap = cached.snapshotSummary ?? {
+              matched: 0,
+              created: 0,
+              updated: 0,
+              failed: 0,
+            };
+            snapshotSummary.matched += cachedSnap.matched ?? 0;
+            snapshotSummary.created += cachedSnap.created ?? 0;
+            snapshotSummary.updated += cachedSnap.updated ?? 0;
+            snapshotSummary.failed += cachedSnap.failed ?? 0;
+            reports.push({
+              file,
+              modeName: options.modeName ?? "default",
+              suites: selected,
+              coverage: cached.coverage ?? {
+                total: 0,
+                covered: 0,
+                uncovered: 0,
+                percent: 100,
+                points: [],
+              },
+              runCommand: cached.runCommand ?? "",
+              buildCommand:
+                options.buildCommandsByFile?.[file] ??
+                options.buildCommand ??
+                cached.buildCommand ??
+                "",
+              snapshotSummary: cachedSnap,
+              cached: true,
+            });
+            continue;
+          }
+        }
+      }
       if (!existsSync(outFile)) {
         const buildStartedAt = Date.now();
         await build(
@@ -929,7 +1001,7 @@ export async function run(
       snapshotSummary.created += snapshotStore.created;
       snapshotSummary.updated += snapshotStore.updated;
       snapshotSummary.failed += snapshotStore.failed;
-      reports.push({
+      const fileReport = {
         file,
         modeName: options.modeName ?? "default",
         suites: selectedSuites,
@@ -943,7 +1015,29 @@ export async function run(
           updated: snapshotStore.updated,
           failed: snapshotStore.failed,
         },
-      });
+        // When the cache is active, mark freshly-run reports `false` (replays
+        // are marked `true`) so the summary can show a cache hit/miss split.
+        // Left undefined when the cache is off so no Cache line is shown.
+        ...(cacheCtx?.cache ? { cached: false } : {}),
+      };
+      reports.push(fileReport);
+      // Persist this report so an unchanged future run can replay it (Tier 2).
+      // recordBuild ran during build() this session, so the entry exists.
+      if (cacheCtx?.cache) {
+        const snapPath = resolveSnapshotPath(
+          file,
+          config.snapshotDir,
+          config.input,
+        );
+        const snapshotSha = existsSync(snapPath)
+          ? sha256OfFile(snapPath)
+          : null;
+        cacheCtx.cache.recordReport(options.modeName, file, {
+          report: fileReport,
+          snapshotSha,
+          runtimeCmd: runtimeCommand,
+        });
+      }
     }
   } finally {
     await ownedWebSession?.close();
@@ -2160,6 +2254,22 @@ async function runProcess(
       });
       return synthesized;
     }
+    // A spec file with no test suites never calls `run()`, so it emits no
+    // lifecycle frames and exits cleanly. That is an empty test file, not a
+    // crash — mark it skipped instead of surfacing "missing report payload".
+    if (
+      code === 0 &&
+      reportStream.dataFrames === 0 &&
+      !runtimeEvents.sawFileStart &&
+      !runtimeEvents.sawFileEnd &&
+      runtimeEvents.suiteStarts === 0 &&
+      !hasMeaningfulRuntimeOutput(stderrBuffer)
+    ) {
+      reporter.onWarning?.({
+        message: `${formatSpecDisplayPath(specFile)} contains no tests; marked as skipped`,
+      });
+      return createEmptyFileSkipReport(specFile, modeName);
+    }
     const errorText = "missing report payload from test runtime";
     const diagnostics = buildRuntimeReportDiagnostics(
       code,
@@ -2650,6 +2760,24 @@ function buildRuntimeReportDiagnostics(
     `runtime events: fileStart=${runtimeEvents.sawFileStart ? "yes" : "no"}, fileEnd=${runtimeEvents.sawFileEnd ? "yes" : "no"}, fileVerdict=${runtimeEvents.fileVerdict}, suiteStarts=${runtimeEvents.suiteStarts}, suiteEnds=${runtimeEvents.suiteEnds}, assertionFails=${runtimeEvents.assertionFails}, warnings=${runtimeEvents.warnings}, logs=${runtimeEvents.logs}`,
   ].join("\n");
 }
+function createEmptyFileSkipReport(specFile, modeName) {
+  // No suites: a file with zero suites contributes no skipped-suite count, just
+  // a skipped file (an empty `suites` array yields a "none" file verdict, which
+  // collectRunStats tallies as a skipped file). The accompanying onWarning tells
+  // the user the file had no tests.
+  return {
+    file: specFile,
+    modeName: modeName ?? "default",
+    suites: [],
+    coverage: {
+      total: 0,
+      covered: 0,
+      uncovered: 0,
+      percent: 100,
+      points: [],
+    },
+  };
+}
 function createRuntimeFailureReport(
   specFile,
   modeName,
@@ -2745,6 +2873,58 @@ function shouldSuppressWasiWarningLine(line) {
   }
   return false;
 }
+// Drive the reporter from a stored (passing) file report so a replayed spec
+// still scrolls past the live display and is counted, exactly as a fresh run
+// would render it. Only passing/skipped reports are replayed, so there are no
+// assertion failures to re-emit.
+function replayCachedReport(reporter, file, suites) {
+  reporter.onFileStart?.({
+    file,
+    depth: 0,
+    suiteKind: "file",
+    description: file,
+  });
+  let verdict = "none";
+  for (const suite of suites) {
+    verdict = mergeReplayVerdict(
+      verdict,
+      emitReplaySuite(reporter, file, suite),
+    );
+  }
+  reporter.onFileEnd?.({
+    file,
+    depth: 0,
+    suiteKind: "file",
+    description: file,
+    verdict,
+    cached: true,
+  });
+}
+function emitReplaySuite(reporter, file, suite) {
+  const depth = Number(suite?.depth ?? 0);
+  const kind = String(suite?.kind ?? "");
+  const description = String(suite?.description ?? "");
+  reporter.onSuiteStart?.({ file, depth, suiteKind: kind, description });
+  let verdict = String(suite?.verdict ?? "none");
+  const subs = Array.isArray(suite?.suites) ? suite.suites : [];
+  for (const sub of subs) {
+    verdict = mergeReplayVerdict(verdict, emitReplaySuite(reporter, file, sub));
+  }
+  reporter.onSuiteEnd?.({
+    file,
+    depth,
+    suiteKind: kind,
+    description,
+    verdict: String(suite?.verdict ?? verdict),
+  });
+  return verdict;
+}
+function mergeReplayVerdict(a, b) {
+  if (a === "fail" || b === "fail") return "fail";
+  if (a === "ok" || b === "ok") return "ok";
+  if (a === "skip" || b === "skip") return "skip";
+  return "none";
+}
 function collectRunStats(reports) {
   const stats = {
     passedFiles: 0,

package/bin/commands/test.js

@@ -29,6 +29,8 @@ export async function executeTestCommand(
     browser: deps.resolveBrowserOverride(rawArgs, "test"),
     reporterPath: deps.resolveReporterOverride(rawArgs, "test"),
     watch: flags.includes("--watch") || flags.includes("-w"),
+    cache: flags.includes("--cache"),
+    noCache: flags.includes("--no-cache"),
   };
   const fuzzEnabled = flags.includes("--fuzz");
   const fuzzOverrides = deps.resolveFuzzOverrides(rawArgs, "test");

package/bin/index.js

@@ -6,6 +6,7 @@ import {
   flushModeWarnings,
   formatInvocation as formatBuildInvocation,
   getBuildInvocationPreview,
+  getBuildReuseInfo,
   warnOnUnknownModeReferences,
 } from "./commands/build.js";
 import { createRunReporter, resetCollectedLogs, run } from "./commands/run.js";
@@ -41,6 +42,8 @@ import { BuildWorkerPool } from "./build-worker-pool.js";
 import { PersistentWebSessionHost } from "./commands/web-session.js";
 import { buildRecorderStorage } from "./commands/build-core.js";
 import { DependencyGraph } from "./dependency-graph.js";
+import { BuildCache, cacheStorage, resolveCacheDir } from "./build-cache.js";
+import { resolveCacheSettings } from "./util.js";
 import { resolveSpecFiles, emitSelectorWarnings } from "./selectors.js";
 const _args = process.argv.slice(2);
 const flags = [];
@@ -477,6 +480,12 @@ function printCommandHelp(command) {
     process.stdout.write(
       "  --watch, -w              Re-run on source or spec changes\n",
     );
+    process.stdout.write(
+      "  --cache                  Skip recompiling/rerunning specs unchanged since the last run\n",
+    );
+    process.stdout.write(
+      "  --no-cache               Ignore the cache for this run (overrides config)\n",
+    );
     process.stdout.write("  --help, -h               Show this help\n");
     return;
   }
@@ -1239,31 +1248,57 @@ class ParallelQueueDisplay {
     this.showStartLines = showStartLines;
     this.active = new Map();
     this.renderedLines = 0;
+    // Files complete out of order under --parallel (a cache replay finishes
+    // instantly while a fresh build is still running). To keep output in the
+    // order specs were resolved, each token gets a start sequence (start() is
+    // called in resolved/index order) and completed outputs are emitted only as
+    // the contiguous prefix of that sequence fills in.
+    this.seqByToken = new Map();
+    this.nextSeq = 0;
+    this.nextFlushSeq = 0;
+    this.pending = new Map();
     this.enabled = showStartLines && canRewriteParallelQueue();
   }
   start(file) {
     const token = Symbol(file);
-    if (!this.showStartLines) return token;
-    const line = `${chalk.bgBlackBright.white(" .... ")} ${file}`;
+    this.seqByToken.set(token, this.nextSeq++);
     if (!this.enabled) return token;
+    const line = `${chalk.bgBlackBright.white(" .... ")} ${file}`;
     this.clear();
     this.active.set(token, line);
     this.render();
     return token;
   }
   complete(token, output) {
-    if (!this.showStartLines || !this.enabled) {
-      process.stdout.write(output);
-      return;
-    }
-    this.clear();
-    process.stdout.write(output);
+    const seq = this.seqByToken.get(token) ?? this.nextFlushSeq;
+    this.seqByToken.delete(token);
     this.active.delete(token);
-    this.render();
+    this.pending.set(seq, output);
+    this.flushOrdered();
+  }
+  // Emit the contiguous run of completed outputs starting at nextFlushSeq, so
+  // results print in resolved order regardless of completion order.
+  flushOrdered() {
+    if (!this.pending.has(this.nextFlushSeq)) return;
+    if (this.enabled) this.clear();
+    while (this.pending.has(this.nextFlushSeq)) {
+      process.stdout.write(this.pending.get(this.nextFlushSeq));
+      this.pending.delete(this.nextFlushSeq);
+      this.nextFlushSeq++;
+    }
+    if (this.enabled) this.render();
   }
   flush() {
-    if (!this.enabled) return;
-    this.clear();
+    // Drain anything still buffered (e.g. a gap left by an errored spec) in
+    // sequence order, then clear the live block.
+    if (this.pending.size) {
+      if (this.enabled) this.clear();
+      for (const seq of [...this.pending.keys()].sort((a, b) => a - b)) {
+        process.stdout.write(this.pending.get(seq));
+      }
+      this.pending.clear();
+    }
+    if (this.enabled) this.clear();
   }
   clear() {
     if (!this.renderedLines) return;
@@ -1329,6 +1364,29 @@ async function buildFileForMode(args) {
   // recorder so the dependency graph still gets populated under --parallel.
   const recorder = buildRecorderStorage.getStore();
   if (args.buildPool) {
+    // The non-pool branch delegates to build(), which owns the cache logic.
+    // The pool builds in child processes, so handle the cache here: skip when
+    // fresh, else collect the worker's reported reads and record them.
+    const cacheCtx = cacheStorage.getStore();
+    const reuse = cacheCtx
+      ? await getBuildReuseInfo(
+          args.configPath,
+          args.file,
+          args.modeName,
+          args.buildFeatureToggles,
+        )
+      : null;
+    if (
+      cacheCtx &&
+      reuse &&
+      cacheCtx.cache.isBuildFresh(args.modeName, args.file, {
+        signature: reuse.signature,
+        coverageEnabled: reuse.coverageEnabled,
+      })
+    ) {
+      return;
+    }
+    const reads = cacheCtx && reuse ? new Set() : null;
     const buildInvocation = await getBuildInvocationPreview(
       args.configPath,
       args.file,
@@ -1341,12 +1399,24 @@ async function buildFileForMode(args) {
       modeName: args.modeName,
       buildCommand: formatBuildInvocation(buildInvocation),
       featureToggles: args.buildFeatureToggles,
-      onReads: recorder
-        ? (reads) => {
-            for (const r of reads) recorder.record(r.mode, r.spec, r.file);
-          }
-        : undefined,
+      onReads:
+        recorder || reads
+          ? (entries) => {
+              for (const r of entries) {
+                recorder?.record(r.mode, r.spec, r.file);
+                reads?.add(r.file);
+              }
+            }
+          : undefined,
     });
+    if (cacheCtx && reuse && reads) {
+      cacheCtx.cache.recordBuild(args.modeName, args.file, {
+        signature: reuse.signature,
+        outFile: reuse.outFile,
+        deps: reads,
+        coverageEnabled: reuse.coverageEnabled,
+      });
+    }
   } else {
     await build(
       args.configPath,
@@ -1949,17 +2019,70 @@ async function runTestModes(
     );
     return;
   }
-  const failed = await runTestModesCore(
-    runFlags,
-    configPath,
-    selectors,
-    suiteSelectors,
-    fuzzerSelectors,
-    modes,
-    buildFeatureToggles,
-    fuzzEnabled,
-    fuzzOverrides,
+  // Opt-in incremental cache for the whole non-watch run (watch keeps its own
+  // in-memory dependency graph). Fuzzing is non-deterministic, so never cache.
+  const baseConfig = loadConfig(
+    configPath ?? path.join(process.cwd(), "./as-test.config.json"),
   );
+  const { mode: cacheMode, maxTimeMs } = resolveCacheSettings(
+    baseConfig.cache,
+    {
+      cache: runFlags.cache,
+      noCache: runFlags.noCache,
+    },
+  );
+  const cacheEnabled = cacheMode !== "off" && !fuzzEnabled;
+  if (!cacheEnabled) {
+    const failed = await runTestModesCore(
+      runFlags,
+      configPath,
+      selectors,
+      suiteSelectors,
+      fuzzerSelectors,
+      modes,
+      buildFeatureToggles,
+      fuzzEnabled,
+      fuzzOverrides,
+    );
+    process.exit(failed ? 1 : 0);
+  }
+  const cacheDir = resolveCacheDir(baseConfig.outDir);
+  const cache = BuildCache.load(cacheDir, getCliVersion(), { maxTimeMs });
+  // Replay (Tier 2) is unsafe while writing snapshots — those mutate .snap, so
+  // a replayed snapshot summary would be wrong. Build-skip still applies.
+  const replay =
+    cacheMode === "full" &&
+    !runFlags.createSnapshots &&
+    !runFlags.overwriteSnapshots;
+  // Only prune entries on a full run: a selector-scoped run (`ast test foo`)
+  // resolves a subset, so pruning to it would wipe every other spec's entry.
+  let liveKeys = null;
+  if (!selectors.length) {
+    const files = await resolveSelectedFiles(configPath, [], false);
+    liveKeys = new Set();
+    for (const modeName of modes) {
+      for (const file of files) liveKeys.add(cache.keyFor(modeName, file));
+    }
+  }
+  let failed = false;
+  try {
+    failed = await cacheStorage.run({ cache, replay }, () =>
+      runTestModesCore(
+        runFlags,
+        configPath,
+        selectors,
+        suiteSelectors,
+        fuzzerSelectors,
+        modes,
+        buildFeatureToggles,
+        fuzzEnabled,
+        fuzzOverrides,
+      ),
+    );
+  } finally {
+    if (liveKeys) cache.prune(liveKeys);
+    cache.save();
+  }
   process.exit(failed ? 1 : 0);
 }
 async function runWatchLoop(
@@ -1977,6 +2100,43 @@ async function runWatchLoop(
     configPath ?? path.join(process.cwd(), "./as-test.config.json");
   const absConfigPath = path.resolve(resolvedConfigPath);
   let config = loadConfig(resolvedConfigPath, false);
+  // Persistent incremental cache, honored under --watch too (the dependency
+  // graph above only governs which specs re-run; the cache skips recompiling /
+  // replays unchanged ones, which makes the initial watch run and "run all"
+  // fast). Resolved from flags+config; toggleable live with `c`.
+  const initialCache = resolveCacheSettings(config.cache, {
+    cache: runFlags.cache,
+    noCache: runFlags.noCache,
+  });
+  let cacheMode = fuzzEnabled ? "off" : initialCache.mode;
+  const cacheMaxTimeMs = initialCache.maxTimeMs;
+  // The mode `c` toggles back on to (the configured mode, or "full" if the
+  // cache started off).
+  const cacheToggleMode =
+    initialCache.mode === "off" ? "full" : initialCache.mode;
+  // Wraps a run in the cache context (fresh per run so `now`/maxTime are
+  // current), unless the cache is off. Entry-pruning is intentionally skipped
+  // under watch — scoped re-runs resolve only a subset of specs, so pruning to
+  // them would wipe the rest of the cache.
+  async function withCache(fn) {
+    if (cacheMode === "off") {
+      await fn();
+      return;
+    }
+    const cacheDir = resolveCacheDir(config.outDir);
+    const cache = BuildCache.load(cacheDir, getCliVersion(), {
+      maxTimeMs: cacheMaxTimeMs,
+    });
+    const replay =
+      cacheMode === "full" &&
+      !runFlags.createSnapshots &&
+      !runFlags.overwriteSnapshots;
+    try {
+      await cacheStorage.run({ cache, replay }, fn);
+    } finally {
+      cache.save();
+    }
+  }
   // Respect the user's parallelism flags. Worker-pool builds forward their
   // file-read records back through IPC (see BuildWorkerPool / build-worker
   // and buildFileForMode), so the dependency graph stays correct under
@@ -2026,12 +2186,14 @@ async function runWatchLoop(
         : "";
       return chalk.dim(
         `Auto-run paused${pending}. ` +
-          chalk.bold("w") +
-          " = resume, " +
-          chalk.bold("a") +
-          " = re-run all, " +
           chalk.bold("space") +
           " = retry failing, " +
+          chalk.bold("a") +
+          " = re-run all, " +
+          chalk.bold("w") +
+          " = resume, " +
+          chalk.bold("c") +
+          ` = cache (${cacheMode === "off" ? "off" : "on"}), ` +
           chalk.bold("ctrl+c") +
           " = stop.\n",
       );
@@ -2044,10 +2206,23 @@ async function runWatchLoop(
         " = re-run all, " +
         chalk.bold("w") +
         " = pause, " +
+        chalk.bold("c") +
+        ` = cache (${cacheMode === "off" ? "off" : "on"}), ` +
         chalk.bold("ctrl+c") +
         " = stop.\n",
     );
   }
+  // Rewrites the footer line in place (the cursor sits one line below it after
+  // every doRun / prior rewrite), so toggling w/c updates the hint without
+  // accumulating new lines in scrollback. Falls back to a plain write when not
+  // on a rewritable TTY.
+  function rewriteFooter() {
+    if (process.stdout.isTTY) {
+      process.stdout.write("\x1b[1A\r\x1b[2K" + watchFooter());
+    } else {
+      process.stdout.write(watchFooter());
+    }
+  }
   function writeWatchHeader(headline, detail) {
     // Preserve scrollback — never `console.clear()`. A blank line plus a
     // dim rule visually delimits each iteration so prior output stays
@@ -2185,21 +2360,23 @@ async function runWatchLoop(
       },
     };
     try {
-      await buildRecorderStorage.run(recorder, async () => {
-        await runTestModesCore(
-          watchRunFlags,
-          configPath,
-          runSelectors,
-          suiteSelectors,
-          fuzzerSelectors,
-          modes,
-          buildFeatureToggles,
-          fuzzEnabled,
-          fuzzOverrides,
-          (outcome) =>
-            recordSpecOutcome(outcome.file, outcome.mode, outcome.failed),
-        );
-      });
+      await withCache(() =>
+        buildRecorderStorage.run(recorder, async () => {
+          await runTestModesCore(
+            watchRunFlags,
+            configPath,
+            runSelectors,
+            suiteSelectors,
+            fuzzerSelectors,
+            modes,
+            buildFeatureToggles,
+            fuzzEnabled,
+            fuzzOverrides,
+            (outcome) =>
+              recordSpecOutcome(outcome.file, outcome.mode, outcome.failed),
+          );
+        }),
+      );
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       process.stderr.write(chalk.red("Error: ") + message + "\n");
@@ -2352,31 +2529,14 @@ async function runWatchLoop(
           }
           if (isRunning) break;
           if (byte === 0x77 || byte === 0x57) {
-            // `w` — toggle auto-run / manual mode.
+            // `w` — toggle auto-run / manual mode. Resuming with edits pending
+            // kicks off a run (which prints its own header); otherwise just
+            // refresh the footer in place.
             autoRun = !autoRun;
-            if (autoRun) {
-              const hadPending = changedWhilePaused.size > 0;
-              if (hadPending) {
-                process.stdout.write(
-                  "\n" +
-                    chalk.dim(
-                      "Auto-run resumed — re-running all (files changed while paused).\n",
-                    ),
-                );
-                scheduleManualRerun("manual-runall");
-              } else {
-                process.stdout.write(
-                  "\n" + chalk.dim("Auto-run resumed.\n") + watchFooter(),
-                );
-              }
+            if (autoRun && changedWhilePaused.size > 0) {
+              scheduleManualRerun("manual-runall");
             } else {
-              process.stdout.write(
-                "\n" +
-                  chalk.dim(
-                    "Auto-run paused — edits won't re-run. Press w to resume, or a / space to run now.\n",
-                  ) +
-                  watchFooter(),
-              );
+              rewriteFooter();
             }
             break;
           }
@@ -2388,6 +2548,15 @@ async function runWatchLoop(
             scheduleManualRerun("manual-runall");
             break;
           }
+          if (byte === 0x63 || byte === 0x43) {
+            // `c` — toggle the incremental cache for subsequent runs. No-op
+            // while fuzzing (the cache is unsafe there). Updates the footer in
+            // place to reflect the new state.
+            if (fuzzEnabled) break;
+            cacheMode = cacheMode === "off" ? cacheToggleMode : "off";
+            rewriteFooter();
+            break;
+          }
         }
       });
     } catch {
@@ -3575,6 +3744,22 @@ function formatMatrixFileResultLine(
   showPerModeTimes,
 ) {
   const verdict = resolveMatrixVerdict(results);
+  // A file whose every mode was replayed from cache is de-emphasized: dim-grey
+  // badge + filename, and "(cache)" in place of the timing.
+  const cached =
+    results.length > 0 &&
+    results.every(
+      (r) => r.reports.length > 0 && r.reports.every((rep) => rep.cached),
+    );
+  if (cached) {
+    const badge =
+      verdict == "fail"
+        ? chalk.bgRed.white(" FAIL ")
+        : verdict == "ok"
+          ? chalk.bgGreenBright.white(" PASS ")
+          : chalk.bgBlackBright.white(" SKIP ");
+    return `${badge} ${chalk.dim(file)} ${chalk.dim("(cache)")}`;
+  }
   const badge =
     verdict == "fail"
       ? chalk.bgRed.white(" FAIL ")