as-test 1.2.0 → 1.4.0

package/bin/commands/init-core.js

@@ -7,6 +7,12 @@ import { getCliVersion } from "../util.js";
 import { buildWebRunnerSource } from "./web-runner-source.js";
 const TARGETS = ["wasi", "bindings", "web"];
 const EXAMPLE_MODES = ["minimal", "full", "none"];
+const FEATURE_KEYS = ["coverage", "tryAs"];
+const FEATURE_LABELS = {
+  coverage: "coverage (runtime coverage points + report)",
+  tryAs:
+    "try-as (try/catch/finally + toThrow assertions + throwable rewriting)",
+};
 export async function init(rawArgs) {
   const options = parseInitArgs(rawArgs);
   const rl = options.yes
@@ -23,6 +29,10 @@ export async function init(rawArgs) {
           target: options.target ?? "wasi",
           example: options.example ?? "minimal",
           fuzzExample: options.fuzzExample ?? false,
+          features: resolveFeatures(options.features, {
+            coverage: false,
+            tryAs: false,
+          }),
           installDependenciesNow: options.install ?? false,
         }
       : await runInteractiveOnboarding(options, rl);
@@ -35,6 +45,7 @@ export async function init(rawArgs) {
       answers.target,
       answers.example,
       answers.fuzzExample,
+      answers.features,
       answers.installDependenciesNow,
     );
     if (!options.yes) {
@@ -49,6 +60,7 @@ export async function init(rawArgs) {
       answers.target,
       answers.example,
       answers.fuzzExample,
+      answers.features,
       options.force,
     );
     printSummary(summary);
@@ -67,6 +79,7 @@ export async function init(rawArgs) {
 }
 function parseInitArgs(rawArgs) {
   const options = {
+    features: {},
     yes: false,
     force: false,
     dir: ".",
@@ -95,6 +108,30 @@ function parseInitArgs(rawArgs) {
       options.fuzzExample = false;
       continue;
     }
+    if (arg == "--enable" || arg == "--disable") {
+      const next = rawArgs[i + 1];
+      if (!next || next.startsWith("-")) {
+        throw new Error(`${arg} requires a value: coverage|try-as`);
+      }
+      for (const name of splitInitFeatureList(next)) {
+        applyInitFeatureToggle(options.features, name, arg == "--enable");
+      }
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--enable=") || arg.startsWith("--disable=")) {
+      const eq = arg.indexOf("=");
+      const flag = arg.slice(0, eq);
+      const value = arg.slice(eq + 1);
+      const names = splitInitFeatureList(value);
+      if (!names.length) {
+        throw new Error(`${flag} requires a value: coverage|try-as`);
+      }
+      for (const name of names) {
+        applyInitFeatureToggle(options.features, name, flag == "--enable");
+      }
+      continue;
+    }
     if (arg == "--target") {
       const next = rawArgs[i + 1];
       if (next && !next.startsWith("-")) {
@@ -158,11 +195,37 @@ function parseInitArgs(rawArgs) {
   }
   if (positional.length > 0) {
     throw new Error(
-      `Unknown init argument(s): ${positional.join(", ")}. Usage: init [dir] [--target wasi|bindings|web] [--example minimal|full|none] [--fuzz-example|--no-fuzz-example] [--install] [--yes] [--force] [--dir <path>]`,
+      `Unknown init argument(s): ${positional.join(", ")}. Usage: init [dir] [--target wasi|bindings|web] [--example minimal|full|none] [--fuzz-example|--no-fuzz-example] [--enable coverage|try-as] [--disable coverage|try-as] [--install] [--yes] [--force] [--dir <path>]`,
     );
   }
   return options;
 }
+function splitInitFeatureList(value) {
+  return value
+    .split(",")
+    .map((part) => part.trim())
+    .filter((part) => part.length > 0);
+}
+function applyInitFeatureToggle(out, rawFeature, enabled) {
+  const key = rawFeature.trim().toLowerCase();
+  if (key == "coverage") {
+    out.coverage = enabled;
+    return;
+  }
+  if (key == "try-as" || key == "try_as" || key == "tryas") {
+    out.tryAs = enabled;
+    return;
+  }
+  throw new Error(
+    `unknown feature "${rawFeature}". Supported features: coverage, try-as`,
+  );
+}
+function resolveFeatures(overrides, defaults) {
+  return {
+    coverage: overrides.coverage ?? defaults.coverage,
+    tryAs: overrides.tryAs ?? defaults.tryAs,
+  };
+}
 async function runInteractiveOnboarding(options, face) {
   printOnboardingIntro();
   const acknowledged = await askYesNo(
@@ -231,6 +294,25 @@ async function runInteractiveOnboarding(options, face) {
   if (options.target || onboardingMode == "quick") {
     printPromptAndSelectionLine("Build target", target);
   }
+  const featureDefaults = { coverage: false, tryAs: false };
+  const explicitFeatures =
+    options.features.coverage !== undefined ||
+    options.features.tryAs !== undefined;
+  const features =
+    explicitFeatures || onboardingMode == "quick"
+      ? resolveFeatures(options.features, featureDefaults)
+      : await askMultiToggle(
+          "Features (↑/↓ to move, space to toggle, enter to confirm)",
+          FEATURE_KEYS.map((key) => ({
+            value: key,
+            label: FEATURE_LABELS[key],
+          })),
+          face,
+          resolveFeatures(options.features, featureDefaults),
+        );
+  if (explicitFeatures || onboardingMode == "quick") {
+    printPromptAndSelectionLine("Features", formatFeatureSelection(features));
+  }
   const example =
     options.example ??
     (onboardingMode == "quick"
@@ -275,9 +357,16 @@ async function runInteractiveOnboarding(options, face) {
     target,
     example,
     fuzzExample,
+    features,
     installDependenciesNow,
   };
 }
+function formatFeatureSelection(features) {
+  const labels = [];
+  if (features.coverage) labels.push("coverage");
+  if (features.tryAs) labels.push("try-as");
+  return labels.length ? labels.join(", ") : "none";
+}
 function printOnboardingHeader() {
   // console.log(
   //   chalk.bold.cyan(
@@ -375,7 +464,7 @@ function isTarget(value) {
 function isExampleMode(value) {
   return EXAMPLE_MODES.includes(value);
 }
-function printPlan(root, target, example, fuzzExample, install) {
+function printPlan(root, target, example, fuzzExample, features, install) {
   const displayRoot = () => {
     const rel = path.relative(process.cwd(), root).split(path.sep).join("/");
     if (!rel || rel == ".") return "./";
@@ -483,6 +572,9 @@ function printPlan(root, target, example, fuzzExample, install) {
   console.log(
     "│" + chalk.dim(`  - Fuzzer example: ${fuzzExample ? "yes" : "no"}`),
   );
+  console.log(
+    "│" + chalk.dim(`  - Features: ${formatFeatureSelection(features)}`),
+  );
   console.log("│" + chalk.dim(`  - Directory: ${displayRoot()}`));
   console.log(
     "│" + chalk.dim(`  - Install dependencies: ${install ? "yes" : "no"}`),
@@ -494,7 +586,7 @@ function printPlan(root, target, example, fuzzExample, install) {
   }
   console.log("│");
 }
-function applyInit(root, target, example, fuzzExample, force) {
+function applyInit(root, target, example, fuzzExample, features, force) {
   const summary = {
     created: [],
     updated: [],
@@ -518,13 +610,16 @@ function applyInit(root, target, example, fuzzExample, force) {
     summary,
     "assembly/tsconfig.json",
   );
+  const featuresArray = [];
+  if (features.tryAs) featuresArray.push("try-as");
   const configPath = path.join(root, "as-test.config.json");
   const config = {
     $schema: "node_modules/as-test/as-test.config.schema.json",
     input: ["assembly/__tests__/*.spec.ts"],
     output: ".as-test/",
     config: "none",
-    coverage: false,
+    coverage: features.coverage,
+    features: featuresArray,
     env: {},
     ...(fuzzExample
       ? {
@@ -650,15 +745,15 @@ function applyInit(root, target, example, fuzzExample, force) {
   if (!devDependencies["as-test"]) {
     devDependencies["as-test"] = "^" + getCliVersion();
   }
-  if (!hasDependency(pkg, "json-as")) {
-    devDependencies["json-as"] = "^1.3.5";
-  }
   if (!hasDependency(pkg, "assemblyscript")) {
     devDependencies["assemblyscript"] = "^0.28.9";
   }
   if (target == "wasi" && !devDependencies["@assemblyscript/wasi-shim"]) {
     devDependencies["@assemblyscript/wasi-shim"] = "^0.1.0";
   }
+  if (features.tryAs && !hasDependency(pkg, "try-as")) {
+    devDependencies["try-as"] = "^1.1.0";
+  }
   if (target == "bindings" && !pkg.type) {
     pkg.type = "module";
   }
@@ -814,6 +909,21 @@ async function askMenuChoice(label, choices, face, fallback) {
   }
   return askMenuChoiceWithArrows(label, choices, face, fallbackValue);
 }
+async function askMultiToggle(label, choices, face, initial) {
+  if (!face) return { ...initial };
+  if (canUseArrowMenu(face)) {
+    return askMultiToggleWithArrows(label, choices, face, initial);
+  }
+  const result = { ...initial };
+  for (const choice of choices) {
+    result[choice.value] = await askYesNo(
+      `${label} — enable ${choice.label}?`,
+      face,
+      initial[choice.value],
+    );
+  }
+  return result;
+}
 async function askYesNo(label, face, fallback) {
   if (!face) return fallback;
   if (canUseArrowMenu(face)) {
@@ -887,7 +997,7 @@ async function askMenuChoiceWithArrows(label, choices, face, fallback) {
     }
     const totalLineCount = Math.max(lines.length, renderedLineCount);
     for (let i = 0; i < totalLineCount; i++) {
-      process.stdout.write("\x1b[2K");
+      process.stdout.write("\r\x1b[2K");
       if (i < lines.length) {
         process.stdout.write(lines[i]);
       }
@@ -987,6 +1097,141 @@ async function askMenuChoiceWithArrows(label, choices, face, fallback) {
     writeLines(menuLines());
   });
 }
+async function askMultiToggleWithArrows(label, choices, face, initial) {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  const selected = { ...initial };
+  let cursorIndex = 0;
+  let renderedLineCount = 0;
+  const previousRawMode = Boolean(stdin.isRaw);
+  const lineWidth = Math.max(20, (stdout.columns ?? 80) - 2);
+  const clamp = (value, max) => {
+    if (value.length <= max) return value;
+    if (max <= 1) return value.slice(0, max);
+    return `${value.slice(0, max - 1)}…`;
+  };
+  const titleLine = () =>
+    chalk.bold.blue(`◆  ${clamp(label, Math.max(8, lineWidth - 3))}`);
+  const menuLines = () => {
+    const lines = [titleLine()];
+    for (let i = 0; i < choices.length; i++) {
+      const choice = choices[i];
+      const isOn = Boolean(selected[choice.value]);
+      const cursor = i == cursorIndex ? chalk.blue("›") : " ";
+      const marker = isOn ? chalk.blue("●") : chalk.dim("○");
+      const text = clamp(choice.label, Math.max(8, lineWidth - 6));
+      const painted = i == cursorIndex ? chalk.bold(text) : text;
+      lines.push(`│  ${cursor} ${marker} ${painted}`);
+    }
+    lines.push("│");
+    return lines;
+  };
+  const collapsedLines = () => {
+    const enabled = choices
+      .filter((choice) => selected[choice.value])
+      .map((choice) => choice.value);
+    const summary = enabled.length ? enabled.join(", ") : "none";
+    return [`│  ${chalk.gray(clamp(summary, Math.max(8, lineWidth - 4)))}`];
+  };
+  const writeLines = (lines) => {
+    if (renderedLineCount > 0) {
+      process.stdout.write(`\x1b[${renderedLineCount}A`);
+    }
+    const totalLineCount = Math.max(lines.length, renderedLineCount);
+    for (let i = 0; i < totalLineCount; i++) {
+      process.stdout.write("\r\x1b[2K");
+      if (i < lines.length) {
+        process.stdout.write(lines[i]);
+      }
+      process.stdout.write("\n");
+    }
+    renderedLineCount = lines.length;
+  };
+  const collapseInPlace = () => {
+    const lines = collapsedLines();
+    if (renderedLineCount > 0) {
+      process.stdout.write(`\x1b[${renderedLineCount}A`);
+    }
+    const totalLineCount = Math.max(renderedLineCount, lines.length);
+    for (let i = 0; i < totalLineCount; i++) {
+      process.stdout.write("\r\x1b[2K");
+      if (i < lines.length) {
+        process.stdout.write(lines[i]);
+      }
+      process.stdout.write("\n");
+    }
+    const extraLines = totalLineCount - lines.length;
+    if (extraLines > 0) {
+      process.stdout.write(`\x1b[${extraLines}A`);
+    }
+    renderedLineCount = 0;
+  };
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => {
+      stdin.off("data", onData);
+      if (stdin.isTTY) {
+        stdin.setRawMode(previousRawMode);
+      }
+      const isClosed = Boolean(face.closed);
+      if (!isClosed) {
+        try {
+          face.resume();
+        } catch {
+          // noop: readline may already be closed during shutdown/cancel paths.
+        }
+      }
+    };
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      collapseInPlace();
+      cleanup();
+      resolve(selected);
+    };
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+    const onData = (chunk) => {
+      const input = typeof chunk == "string" ? chunk : chunk.toString("utf8");
+      if (!input.length) return;
+      if (input == "\u0003") {
+        fail(new Error(chalk.bold.red("◆  Cancelled")));
+        return;
+      }
+      if (input == "\x1b[A" || input == "\x1bOA") {
+        cursorIndex = (cursorIndex - 1 + choices.length) % choices.length;
+        writeLines(menuLines());
+        return;
+      }
+      if (input == "\x1b[B" || input == "\x1bOB") {
+        cursorIndex = (cursorIndex + 1) % choices.length;
+        writeLines(menuLines());
+        return;
+      }
+      if (input == " ") {
+        const key = choices[cursorIndex].value;
+        selected[key] = !selected[key];
+        writeLines(menuLines());
+        return;
+      }
+      if (input == "\r" || input == "\n") {
+        finish();
+        return;
+      }
+    };
+    face.pause();
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.on("data", onData);
+    writeLines(menuLines());
+  });
+}
 function installDependencies(root) {
   const install = resolveInstallCommand(root);
   console.log(

package/bin/commands/run-core.js

@@ -9,6 +9,7 @@ import {
   getExec,
   loadConfig,
   resolveArtifactPath,
+  resolveSnapshotPath,
   resolveSpecRelativePath,
   tokenizeCommand,
 } from "../util.js";
@@ -33,12 +34,7 @@ class SnapshotStore {
     this.failed = 0;
     this.warnedMissing = new Set();
     this.specBasename = path.basename(specFile);
-    const dir = path.join(process.cwd(), snapshotDir);
-    const relative = resolveSpecRelativePath(specFile, inputPatterns).replace(
-      /\.ts$/i,
-      ".snap",
-    );
-    this.filePath = path.join(dir, relative);
+    this.filePath = resolveSnapshotPath(specFile, snapshotDir, inputPatterns);
     const sourcePath = existsSync(this.filePath) ? this.filePath : null;
     const loaded = sourcePath
       ? readSnapshotFile(sourcePath, specFile)
@@ -543,7 +539,7 @@ function collectReadableLogs(suites) {
     const suiteAny = suite;
     const logs = Array.isArray(suiteAny.logs) ? suiteAny.logs : [];
     for (const log of logs) {
-      const value = String(log.value ?? log.message ?? "");
+      const value = String(log.text ?? log.value ?? log.message ?? "");
       if (value.length) out.push(value);
     }
     const childSuites = Array.isArray(suiteAny.suites) ? suiteAny.suites : [];
@@ -551,6 +547,133 @@ function collectReadableLogs(suites) {
   }
   return out;
 }
+// Walk a suite tree, accumulating each suite's `log()` output keyed by the
+// describe/test description path it was emitted under.
+function walkSuiteLogs(suites, pathParts, out) {
+  for (const suite of suites) {
+    const suiteAny = suite;
+    const description = String(suiteAny.description ?? "");
+    const nextPath = description.length
+      ? [...pathParts, description]
+      : pathParts;
+    const logs = Array.isArray(suiteAny.logs) ? suiteAny.logs : [];
+    const lines = logs.map((log) =>
+      String(log.text ?? log.value ?? log.message ?? ""),
+    );
+    if (lines.length) out.push({ path: nextPath, lines });
+    const childSuites = Array.isArray(suiteAny.suites) ? suiteAny.suites : [];
+    walkSuiteLogs(childSuites, nextPath, out);
+  }
+}
+// Group every captured log across all file reports into a per-spec tree (one
+// entry per `log()` call). Feeds the process-wide collector that backs the
+// aggregated `latest.log` and the `--show-logs` dump.
+function collectGroupedLogs(reports) {
+  let count = 0;
+  const groups = [];
+  for (const report of reports) {
+    const reportAny = report;
+    const suites = Array.isArray(reportAny.suites) ? reportAny.suites : [];
+    const entries = [];
+    walkSuiteLogs(suites, [], entries);
+    if (!entries.length) continue;
+    for (const entry of entries) count += entry.lines.length;
+    groups.push({ file: String(reportAny.file ?? "unknown"), entries });
+  }
+  return { count, groups };
+}
+// Process-lived collector backing the aggregated `latest.log`. Keyed by spec
+// file, then by mode label, holding that mode's flat list of `log()` lines.
+// Persisting across run() calls lets a multi-mode run accumulate every mode
+// before the file is rendered, so identical output can be de-duplicated.
+const collectedLogsBySpec = new Map();
+// Clear the collector. Useful for watch mode, where each cycle should start
+// fresh rather than accumulate stale specs.
+export function resetCollectedLogs() {
+  collectedLogsBySpec.clear();
+}
+function recordModeLogs(modeLabel, groups) {
+  for (const group of groups) {
+    const lines = [];
+    for (const entry of group.entries) lines.push(...entry.lines);
+    if (!lines.length) continue;
+    let byMode = collectedLogsBySpec.get(group.file);
+    if (!byMode) {
+      byMode = new Map();
+      collectedLogsBySpec.set(group.file, byMode);
+    }
+    byMode.set(modeLabel, lines);
+  }
+}
+// Render the collected logs as the `latest.log` body. Within a spec, modes that
+// produced byte-identical output are merged into one block tagged with every
+// mode that emitted it:
+//
+//   [LOG] log.spec.ts (node:bindings, node:wasi):
+//
+//   {"a":1}
+//   ...
+//
+// `count` is the number of de-duplicated `log()` calls (one entry per call —
+// stringify escapes newlines, so a call is a single line), not counting the
+// same call again per mode.
+function renderCollectedLogs() {
+  const blocks = [];
+  let count = 0;
+  const specs = [...collectedLogsBySpec.keys()].sort((a, b) =>
+    a.localeCompare(b),
+  );
+  for (const spec of specs) {
+    const byMode = collectedLogsBySpec.get(spec);
+    // Group modes by identical content so duplicate output collapses into one
+    // block; `calls` is that block's log() count, tallied once regardless of
+    // how many modes produced it.
+    const byContent = new Map();
+    for (const [mode, lines] of byMode) {
+      const content = lines.join("\n");
+      const existing = byContent.get(content);
+      if (existing) existing.modes.push(mode);
+      else byContent.set(content, { modes: [mode], calls: lines.length });
+    }
+    for (const [content, { modes, calls }] of byContent) {
+      const named = modes.filter((mode) => mode !== "default").sort();
+      const suffix = named.length ? ` (${named.join(", ")})` : "";
+      count += calls;
+      blocks.push(
+        `[LOG] ${formatSpecDisplayPath(spec)}${suffix}:\n\n${content}`,
+      );
+    }
+  }
+  return { text: blocks.length ? blocks.join("\n\n") + "\n" : "", count };
+}
+// Render the collector and (re)write the single aggregated `latest.log` at the
+// base (un-mode-qualified) logs dir, so every mode shares one file. Returns the
+// resulting LogSummary. Called by run() after recording its own logs, so the
+// last run() of a multi-mode pass leaves a file covering — and de-duplicating —
+// every mode.
+function flushLatestLog(baseLogsDir) {
+  const rendered = renderCollectedLogs();
+  if (rendered.count <= 0)
+    return { count: 0, file: null, groups: [], text: "" };
+  if (!baseLogsDir || baseLogsDir === "none") {
+    return {
+      count: rendered.count,
+      file: null,
+      groups: [],
+      text: rendered.text,
+    };
+  }
+  const logRoot = path.join(process.cwd(), baseLogsDir);
+  if (!existsSync(logRoot)) mkdirSync(logRoot, { recursive: true });
+  const latestLogPath = path.join(logRoot, "latest.log");
+  writeFileSync(latestLogPath, rendered.text);
+  return {
+    count: rendered.count,
+    file: path.relative(process.cwd(), latestLogPath) || latestLogPath,
+    groups: [],
+    text: rendered.text,
+  };
+}
 export async function run(
   flags = {},
   configPath = DEFAULT_CONFIG_PATH,
@@ -766,6 +889,7 @@ export async function run(
   } finally {
     await ownedWebSession?.close();
   }
+  const groupedLogs = collectGroupedLogs(reports);
   if (config.logs && config.logs != "none") {
     const logRoot = path.join(process.cwd(), config.logs);
     if (!existsSync(logRoot)) {
@@ -786,6 +910,14 @@ export async function run(
       );
     }
   }
+  // Record this run's logs (tagged with its mode) into the process-wide
+  // collector, then rewrite the single aggregated `latest.log` covering every
+  // mode seen so far. The collector persists across run() calls, so the last
+  // run() of a multi-mode pass produces the complete, de-duplicated file. The
+  // file lives at the base (un-mode-qualified) logs dir — `loadedConfig.logs`
+  // before `applyMode` appended the per-mode subdirectory.
+  recordModeLogs(options.modeName ?? "default", groupedLogs.groups);
+  const logSummary = flushLatestLog(loadedConfig.logs);
   const stats = collectRunStats(reports);
   if (options.fileSummaryTotal != undefined) {
     applyConfiguredFileTotalToStats(stats, options.fileSummaryTotal);
@@ -824,6 +956,8 @@ export async function run(
       showCoverage,
       showCoverageAll: Boolean(flags.showCoverageAll),
       verbose: Boolean(flags.verbose),
+      showLogs: Boolean(flags.showLogs),
+      logSummary,
       buildTime,
       snapshotSummary,
       coverageSummary,
@@ -849,6 +983,7 @@ export async function run(
     snapshotSummary,
     coverageSummary,
     reports,
+    logSummary,
   };
 }
 function applyConfiguredFileTotalToStats(stats, fileSummaryTotal) {
@@ -2593,10 +2728,27 @@ function readFileReport(stats, fileReport) {
   const buildCommand = String(fileReportAny.buildCommand ?? "");
   let fileVerdict = "none";
   for (const suite of suites) {
-    fileVerdict = mergeVerdict(
-      fileVerdict,
-      readSuite(stats, suite, file, modeName, runCommand, buildCommand),
+    const suiteVerdict = readSuite(
+      stats,
+      suite,
+      file,
+      modeName,
+      runCommand,
+      buildCommand,
     );
+    fileVerdict = mergeVerdict(fileVerdict, suiteVerdict);
+    // Record each failed top-level suite once. The failure summary recurses into
+    // it to find every failed assertion (so nested failures aren't pushed again,
+    // and a top-level it()/test() failure is captured too).
+    if (suiteVerdict == "fail") {
+      stats.failedEntries.push({
+        ...suite,
+        file,
+        modeName,
+        runCommand,
+        buildCommand,
+      });
+    }
   }
   if (fileVerdict == "fail") {
     stats.failedFiles++;
@@ -2608,7 +2760,6 @@ function readFileReport(stats, fileReport) {
 }
 function readSuite(stats, suite, file, modeName, runCommand, buildCommand) {
   const suiteAny = suite;
-  const kind = String(suiteAny.kind ?? "");
   let verdict = normalizeVerdict(suiteAny.verdict);
   const time = suiteAny.time;
   const start = Number(time?.start ?? 0);
@@ -2633,27 +2784,11 @@ function readSuite(stats, suite, file, modeName, runCommand, buildCommand) {
       stats.skippedTests++;
     }
   }
-  if (isTestCaseSuiteKind(kind)) {
-    if (!subSuites.length && !tests.length) {
-      if (verdict == "fail") {
-        stats.failedTests++;
-      } else if (verdict == "ok") {
-        stats.passedTests++;
-      } else if (verdict == "skip") {
-        stats.skippedTests++;
-      }
-    }
-    return verdict;
-  }
+  // Every grouping block — describe, test, it, only and their skip variants —
+  // is a suite; the expect() assertions counted above are the tests. (Failed
+  // entries for the summary are collected per top-level suite in readFileReport.)
   if (verdict == "fail") {
     stats.failedSuites++;
-    stats.failedEntries.push({
-      ...suiteAny,
-      file,
-      modeName,
-      runCommand,
-      buildCommand,
-    });
   } else if (verdict == "ok") {
     stats.passedSuites++;
   } else {
@@ -2661,17 +2796,6 @@ function readSuite(stats, suite, file, modeName, runCommand, buildCommand) {
   }
   return verdict;
 }
-function isTestCaseSuiteKind(kind) {
-  return (
-    kind == "test" ||
-    kind == "it" ||
-    kind == "only" ||
-    kind == "xtest" ||
-    kind == "xit" ||
-    kind == "xonly" ||
-    kind == "todo"
-  );
-}
 function normalizeVerdict(value) {
   const verdict = String(value ?? "none");
   if (verdict == "fail") return "fail";

package/bin/commands/run.js

@@ -1,4 +1,4 @@
-export { createRunReporter, run } from "./run-core.js";
+export { createRunReporter, resetCollectedLogs, run } from "./run-core.js";
 export async function executeRunCommand(
   rawArgs,
   flags,
@@ -19,6 +19,7 @@ export async function executeRunCommand(
     showCoverage: showCoverageMode != undefined,
     showCoverageAll: showCoverageMode == "all",
     verbose: flags.includes("--verbose"),
+    showLogs: flags.includes("--show-logs"),
     ...deps.resolveParallelJobs(rawArgs, "run"),
     coverage: featureToggles.coverage,
     browser: deps.resolveBrowserOverride(rawArgs, "run"),