as-test 1.0.4 → 1.0.5

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Change Log
 
+## 2026-03-30 - v1.0.5
+
+### CLI
+
+- fix: preserve selectors passed after `--parallel` so commands like `ast test --parallel math` still target the requested suite.
+- fix: treat uncaught runtime stderr / missing report payloads as normal failed test results instead of transport-level crashes, with cleaner default reporter output.
+- perf: reuse build artifacts across modes when the resolved non-custom build invocation and build environment are identical, copying the first artifact instead of recompiling.
+
 ## 2026-03-27 - v1.0.4
 
 ### Build Command

package/README.md

@@ -66,6 +66,23 @@ By default, `as-test` looks for:
 
 Generated files go into `.as-test/`.
 
+Minimal `as-test.config.json`:
+
+```json
+{
+  "input": ["assembly/__tests__/*.spec.ts"],
+  "output": ".as-test/",
+  "buildOptions": {
+    "target": "wasi"
+  },
+  "runOptions": {
+    "runtime": {
+      "cmd": "node .as-test/runners/default.wasi.js <file>"
+    }
+  }
+}
+```
+
 ## Writing Tests
 
 Tests usually live in `assembly/__tests__/*.spec.ts`.

package/bin/commands/build-core.js

@@ -124,6 +124,39 @@ export async function getBuildInvocationPreview(configPath = DEFAULT_CONFIG_PATH
     const outFile = `${config.outDir}/${resolveArtifactFileName(file, config.buildOptions.target, modeName, duplicateSpecBasenames)}`;
     return getBuildCommand(config, getPkgRunner(), file, outFile, modeName, featureToggles);
 }
+export async function getBuildReuseInfo(configPath = DEFAULT_CONFIG_PATH, file, modeName, featureToggles = {}, overrides = {}) {
+    const loadedConfig = loadConfig(configPath, false);
+    const mode = applyMode(loadedConfig, modeName);
+    const config = Object.assign(Object.create(Object.getPrototypeOf(mode.config)), mode.config);
+    config.buildOptions = Object.assign(Object.create(Object.getPrototypeOf(mode.config.buildOptions)), mode.config.buildOptions);
+    if (overrides.target) {
+        config.buildOptions.target = overrides.target;
+    }
+    if (overrides.args?.length) {
+        config.buildOptions.args = [...config.buildOptions.args, ...overrides.args];
+    }
+    if (hasCustomBuildCommand(config)) {
+        return null;
+    }
+    const duplicateSpecBasenames = resolveDuplicateBasenames([file]);
+    const outFile = `${config.outDir}/${resolveArtifactFileName(file, config.buildOptions.target, modeName, duplicateSpecBasenames)}`;
+    const invocation = getBuildCommand(config, getPkgRunner(), file, outFile, modeName, featureToggles);
+    const coverageEnabled = resolveCoverageEnabled(config.coverage, featureToggles.coverage);
+    const buildEnv = {
+        ...mode.env,
+        ...config.buildOptions.env,
+        AS_TEST_COVERAGE_ENABLED: coverageEnabled ? "1" : "0",
+    };
+    return {
+        signature: JSON.stringify({
+            command: invocation.command,
+            args: stripOutputArgs(invocation.args),
+            apiArgs: invocation.apiArgs ? stripOutputArgs(invocation.apiArgs) : [],
+            env: sortRecord(buildEnv),
+        }),
+        outFile,
+    };
+}
 function hasCustomBuildCommand(config) {
     return !!config.buildOptions.cmd.trim().length;
 }
@@ -176,6 +209,23 @@ function getUserBuildArgs(config) {
     }
     return args;
 }
+function stripOutputArgs(args) {
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg == "-o" || arg == "--outFile") {
+            i++;
+            continue;
+        }
+        out.push(arg);
+    }
+    return out;
+}
+function sortRecord(record) {
+    return Object.fromEntries(Object.entries(record)
+        .filter((entry) => typeof entry[1] == "string")
+        .sort((a, b) => a[0].localeCompare(b[0])));
+}
 function expandBuildCommand(template, file, outFile, target, modeName) {
     const name = path
         .basename(file)

package/bin/commands/build.js

@@ -1,6 +1,6 @@
 import { closeSerialBuildWorkerPool, } from "./build-core.js";
 export { build } from "./build-core.js";
-export { formatInvocation, getBuildInvocationPreview } from "./build-core.js";
+export { formatInvocation, getBuildInvocationPreview, getBuildReuseInfo, } from "./build-core.js";
 export async function executeBuildCommand(rawArgs, configPath, selectedModes, deps) {
     const commandArgs = deps.resolveCommandArgs(rawArgs, "build");
     const listFlags = deps.resolveListFlags(rawArgs, "build");

package/bin/commands/run-core.js

@@ -1286,26 +1286,22 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
     let report = null;
     let parseError = null;
     let stderrBuffer = "";
+    let stderrPendingLine = "";
     let stdoutBuffer = "";
-    let suppressTraceWarningLine = false;
     let spawnError = null;
     child.on("error", (error) => {
         spawnError = error;
     });
     child.stderr.on("data", (chunk) => {
-        stderrBuffer += chunk.toString("utf8");
-        let newline = stderrBuffer.indexOf("\n");
+        stderrPendingLine += chunk.toString("utf8");
+        let newline = stderrPendingLine.indexOf("\n");
         while (newline >= 0) {
-            const line = stderrBuffer.slice(0, newline + 1);
-            stderrBuffer = stderrBuffer.slice(newline + 1);
-            if (shouldSuppressWasiWarningLine(line, suppressTraceWarningLine)) {
-                suppressTraceWarningLine = true;
+            const line = stderrPendingLine.slice(0, newline + 1);
+            stderrPendingLine = stderrPendingLine.slice(newline + 1);
+            if (!shouldSuppressWasiWarningLine(line)) {
+                stderrBuffer += line;
             }
-            else {
-                suppressTraceWarningLine = false;
-                process.stderr.write(line);
-            }
-            newline = stderrBuffer.indexOf("\n");
+            newline = stderrPendingLine.indexOf("\n");
         }
     });
     class TestChannel extends Channel {
@@ -1409,55 +1405,138 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
     const code = await new Promise((resolve) => {
         child.on("close", (exitCode) => resolve(exitCode ?? 1));
     });
-    if (stderrBuffer.length) {
-        if (!shouldSuppressWasiWarningLine(stderrBuffer, suppressTraceWarningLine)) {
-            process.stderr.write(stderrBuffer);
-        }
+    if (stderrPendingLine.length && !shouldSuppressWasiWarningLine(stderrPendingLine)) {
+        stderrBuffer += stderrPendingLine;
     }
     if (spawnError) {
+        const errorText = spawnError.stack ?? spawnError.message;
         persistCrashRecord(crashDir, {
             kind: "test",
             file: specFile,
             mode: modeName ?? "default",
-            error: spawnError.stack ?? spawnError.message,
+            error: errorText,
             stdout: stdoutBuffer,
             stderr: stderrBuffer,
         });
-        throw spawnError;
+        return createRuntimeFailureReport(specFile, modeName, "failed to start test runtime", errorText, stdoutBuffer, stderrBuffer);
     }
     if (parseError) {
+        const errorText = `could not parse report payload: ${parseError}`;
         persistCrashRecord(crashDir, {
             kind: "test",
             file: specFile,
             mode: modeName ?? "default",
-            error: `could not parse report payload: ${parseError}`,
+            error: errorText,
             stdout: stdoutBuffer,
             stderr: stderrBuffer,
         });
-        throw new Error(`could not parse report payload: ${parseError}`);
+        return createRuntimeFailureReport(specFile, modeName, "runtime returned an invalid report payload", errorText, stdoutBuffer, stderrBuffer);
     }
     if (!report) {
+        const errorText = "missing report payload from test runtime";
         persistCrashRecord(crashDir, {
             kind: "test",
             file: specFile,
             mode: modeName ?? "default",
-            error: "missing report payload from test runtime",
+            error: errorText,
             stdout: stdoutBuffer,
             stderr: stderrBuffer,
         });
-        throw new Error("missing report payload from test runtime");
+        return createRuntimeFailureReport(specFile, modeName, "test runtime exited without sending a report", errorText, stdoutBuffer, stderrBuffer);
     }
-    if (code !== 0) {
-        // Let report determine failure counts, but keep non-zero child exits visible.
-        process.stderr.write(chalk.dim(`child process exited with code ${code}\n`));
+    if (code !== 0 || hasMeaningfulRuntimeOutput(stderrBuffer)) {
+        const errorParts = [];
+        if (code !== 0) {
+            errorParts.push(`child process exited with code ${code}`);
+        }
+        const stderrText = normalizeRuntimeOutput(stderrBuffer);
+        if (stderrText.length) {
+            errorParts.push(stderrText);
+        }
+        const errorText = errorParts.join("\n\n");
+        persistCrashRecord(crashDir, {
+            kind: "test",
+            file: specFile,
+            mode: modeName ?? "default",
+            error: errorText || "runtime reported an unknown error",
+            stdout: stdoutBuffer,
+            stderr: stderrBuffer,
+        });
+        return appendRuntimeFailureReport(report, specFile, modeName, code !== 0
+            ? `test runtime failed with exit code ${code}`
+            : "test runtime wrote to stderr", errorText, stdoutBuffer, stderrBuffer);
     }
     return report;
 }
-function shouldSuppressWasiWarningLine(line, suppressTraceWarningLine) {
+function createRuntimeFailureReport(specFile, modeName, title, details, stdout, stderr) {
+    return appendRuntimeFailureReport({
+        suites: [],
+        coverage: {
+            total: 0,
+            covered: 0,
+            uncovered: 0,
+            percent: 100,
+            points: [],
+        },
+    }, specFile, modeName, title, details, stdout, stderr);
+}
+function appendRuntimeFailureReport(report, specFile, modeName, title, details, stdout, stderr) {
+    const suites = Array.isArray(report?.suites) ? report.suites : [];
+    suites.push({
+        file: specFile,
+        description: path.basename(specFile),
+        depth: 0,
+        kind: "runtime-error",
+        verdict: "fail",
+        time: {
+            start: 0,
+            end: 0,
+        },
+        suites: [],
+        logs: [],
+        tests: [
+            {
+                order: 0,
+                type: "runtime-error",
+                verdict: "fail",
+                left: null,
+                right: null,
+                instr: title,
+                message: formatRuntimeFailureMessage(details, stdout, stderr),
+                location: "",
+            },
+        ],
+        modeName: modeName ?? "default",
+    });
+    report.suites = suites;
+    return report;
+}
+function formatRuntimeFailureMessage(details, stdout, stderr) {
+    const parts = [];
+    const normalizedDetails = normalizeRuntimeOutput(details);
+    const normalizedStderr = normalizeRuntimeOutput(stderr);
+    const normalizedStdout = normalizeRuntimeOutput(stdout);
+    if (normalizedDetails.length)
+        parts.push(normalizedDetails);
+    if (normalizedStderr.length && normalizedStderr !== normalizedDetails) {
+        parts.push(`stderr:\n${normalizedStderr}`);
+    }
+    if (normalizedStdout.length) {
+        parts.push(`stdout:\n${normalizedStdout}`);
+    }
+    return parts.join("\n\n");
+}
+function normalizeRuntimeOutput(value) {
+    return value.replace(/\r\n/g, "\n").trim();
+}
+function hasMeaningfulRuntimeOutput(value) {
+    return normalizeRuntimeOutput(value).length > 0;
+}
+function shouldSuppressWasiWarningLine(line) {
     if (line.includes("ExperimentalWarning: WASI is an experimental feature")) {
         return true;
     }
-    if (suppressTraceWarningLine && line.includes("--trace-warnings")) {
+    if (line.includes("--trace-warnings")) {
         return true;
     }
     return false;
@@ -1506,6 +1585,7 @@ function readFileReport(stats, fileReport) {
 }
 function readSuite(stats, suite, file, modeName) {
     const suiteAny = suite;
+    const kind = String(suiteAny.kind ?? "");
     let verdict = normalizeVerdict(suiteAny.verdict);
     const time = suiteAny.time;
     const start = Number(time?.start ?? 0);
@@ -1533,6 +1613,20 @@ function readSuite(stats, suite, file, modeName) {
             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;
+    }
     if (verdict == "fail") {
         stats.failedSuites++;
         stats.failedEntries.push({
@@ -1549,6 +1643,15 @@ function readSuite(stats, suite, file, modeName) {
     }
     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")

package/bin/commands/run.js

@@ -13,6 +13,7 @@ export async function executeRunCommand(rawArgs, flags, configPath, selectedMode
         ...deps.resolveParallelJobs(rawArgs, "run"),
         coverage: featureToggles.coverage,
         browser: deps.resolveBrowserOverride(rawArgs, "run"),
+        reporterPath: deps.resolveReporterOverride(rawArgs, "run"),
     };
     const modeTargets = deps.resolveExecutionModes(configPath, selectedModes);
     if (listFlags.list || listFlags.listModes) {

package/bin/commands/test.js

@@ -16,6 +16,7 @@ export async function executeTestCommand(rawArgs, flags, configPath, selectedMod
         ...deps.resolveParallelJobs(rawArgs, "test"),
         coverage: featureToggles.coverage,
         browser: deps.resolveBrowserOverride(rawArgs, "test"),
+        reporterPath: deps.resolveReporterOverride(rawArgs, "test"),
     };
     const fuzzEnabled = flags.includes("--fuzz");
     const fuzzOverrides = deps.resolveFuzzOverrides(rawArgs, "test");

package/bin/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import chalk from "chalk";
-import { build, formatInvocation as formatBuildInvocation, getBuildInvocationPreview, } from "./commands/build.js";
+import { build, formatInvocation as formatBuildInvocation, getBuildInvocationPreview, getBuildReuseInfo, } from "./commands/build.js";
 import { createRunReporter, run } from "./commands/run.js";
 import { executeBuildCommand } from "./commands/build.js";
 import { executeRunCommand } from "./commands/run.js";
@@ -14,7 +14,7 @@ import * as path from "path";
 import { spawnSync } from "child_process";
 import { glob } from "glob";
 import { createInterface } from "readline";
-import { existsSync } from "fs";
+import { copyFileSync, existsSync, mkdirSync } from "fs";
 import { availableParallelism, cpus } from "os";
 import { BuildWorkerPool } from "./build-worker-pool.js";
 const _args = process.argv.slice(2);
@@ -66,6 +66,7 @@ else if (COMMANDS.includes(args[0])) {
                 resolveFeatureToggles,
                 resolveParallelJobs,
                 resolveBrowserOverride,
+                resolveReporterOverride,
                 resolveExecutionModes,
                 listExecutionPlan,
                 runRuntimeModes,
@@ -81,6 +82,7 @@ else if (COMMANDS.includes(args[0])) {
                 resolveFeatureToggles,
                 resolveParallelJobs,
                 resolveBrowserOverride,
+                resolveReporterOverride,
                 resolveFuzzOverrides,
                 resolveExecutionModes,
                 listExecutionPlan,
@@ -400,7 +402,6 @@ function resolveCommandArgs(rawArgs, command) {
         }
         if (arg == "--runs" ||
             arg == "--seed" ||
-            arg == "--parallel" ||
             arg == "--jobs" ||
             arg == "--build-jobs" ||
             arg == "--run-jobs" ||
@@ -410,6 +411,9 @@ function resolveCommandArgs(rawArgs, command) {
             i++;
             continue;
         }
+        if (arg == "--parallel") {
+            continue;
+        }
         if (arg.startsWith("--runs=") ||
             arg.startsWith("--seed=") ||
             arg.startsWith("--jobs=") ||
@@ -577,6 +581,32 @@ function resolveBrowserOverride(rawArgs, command) {
     }
     return undefined;
 }
+function resolveReporterOverride(rawArgs, command) {
+    let seenCommand = false;
+    for (let i = 0; i < rawArgs.length; i++) {
+        const arg = rawArgs[i];
+        if (!seenCommand) {
+            if (arg == command)
+                seenCommand = true;
+            continue;
+        }
+        if (arg == "--reporter") {
+            const next = rawArgs[i + 1];
+            if (next && !next.startsWith("-")) {
+                return next;
+            }
+            return undefined;
+        }
+        if (arg.startsWith("--reporter=")) {
+            const value = arg.slice("--reporter=".length);
+            return value.length ? value : undefined;
+        }
+        if (arg == "--tap") {
+            return "tap";
+        }
+    }
+    return undefined;
+}
 function resolveJobs(rawArgs, command) {
     let seenCommand = false;
     let parallel = false;
@@ -731,9 +761,9 @@ function createBufferedStream() {
         },
     };
 }
-async function createBufferedReporter(configPath, modeName) {
+async function createBufferedReporter(configPath, reporterPath, modeName) {
     const stream = createBufferedStream();
-    const session = await createRunReporter(configPath, undefined, modeName, {
+    const session = await createRunReporter(configPath, reporterPath, modeName, {
         stdout: stream,
         stderr: stream,
     });
@@ -882,6 +912,32 @@ function resolveCommandTokens(rawArgs, command) {
     }
     return values;
 }
+async function buildFileForMode(cache, args) {
+    const reuse = await getBuildReuseInfo(args.configPath, args.file, args.modeName, args.buildFeatureToggles);
+    if (reuse) {
+        const source = cache.get(reuse.signature);
+        if (source && source != reuse.outFile && existsSync(source)) {
+            mkdirSync(path.dirname(reuse.outFile), { recursive: true });
+            copyFileSync(source, reuse.outFile);
+            return true;
+        }
+    }
+    if (args.buildPool) {
+        await args.buildPool.buildFileMode({
+            configPath: args.configPath,
+            file: args.file,
+            modeName: args.modeName,
+            featureToggles: args.buildFeatureToggles,
+        });
+    }
+    else {
+        await build(args.configPath, [args.file], args.modeName, args.buildFeatureToggles);
+    }
+    if (reuse) {
+        cache.set(reuse.signature, reuse.outFile);
+    }
+    return false;
+}
 async function runTestSequential(runFlags, configPath, selectors, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, allowNoSpecFiles = false, modeName, reporterOverride, emitRunComplete = true) {
     const files = await resolveSelectedFiles(configPath, selectors);
     if (!files.length) {
@@ -889,7 +945,7 @@ async function runTestSequential(runFlags, configPath, selectors, buildFeatureTo
             throw await buildNoTestFilesMatchedError(configPath, selectors);
         }
     }
-    const reporterSession = await createRunReporter(configPath, undefined, modeName);
+    const reporterSession = await createRunReporter(configPath, runFlags.reporterPath, modeName);
     const reporter = reporterOverride ?? reporterSession.reporter;
     const snapshotEnabled = runFlags.snapshot !== false;
     reporter.onRunStart?.({
@@ -963,17 +1019,19 @@ async function runBuildModes(configPath, selectors, modes, buildFeatureToggles,
     const loadedConfig = loadConfig(resolvedConfigPath, true);
     const allStartedAt = Date.now();
     let builtCount = 0;
+    const buildReuseCache = new Map();
     for (const modeName of modes) {
         const startedAt = Date.now();
         if (effective.buildJobs > 1) {
             const pool = new BuildWorkerPool(effective.buildJobs);
             try {
                 await runOrderedPool(files, effective.buildJobs, async (file) => {
-                    await pool.buildFileMode({
+                    await buildFileForMode(buildReuseCache, {
                         configPath,
                         file,
                         modeName,
-                        featureToggles: buildFeatureToggles,
+                        buildFeatureToggles,
+                        buildPool: pool,
                     });
                 });
             }
@@ -982,7 +1040,14 @@ async function runBuildModes(configPath, selectors, modes, buildFeatureToggles,
             }
         }
         else {
-            await build(configPath, selectors, modeName, buildFeatureToggles);
+            for (const file of files) {
+                await buildFileForMode(buildReuseCache, {
+                    configPath,
+                    file,
+                    modeName,
+                    buildFeatureToggles,
+                });
+            }
         }
         builtCount += files.length;
         const active = applyMode(loadedConfig, modeName).config;
@@ -1022,6 +1087,7 @@ async function runRuntimeModes(runFlags, configPath, selectors, modes) {
     const buildCommandsByFile = await previewBuildCommands(configPath, selectors, modes[0], {});
     for (const modeName of modes) {
         const result = await run(effectiveRunFlags, configPath, selectors, false, {
+            reporterPath: effectiveRunFlags.reporterPath,
             modeName,
             modeSummaryTotal,
             modeSummaryExecuted: 1,
@@ -1063,11 +1129,13 @@ async function runRuntimeMatrix(runFlags, configPath, selectors, modes, modeSumm
     }));
     const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
     const buildIntervals = [];
+    const buildReuseCache = new Map();
     for (let fileIndex = 0; fileIndex < files.length; fileIndex++) {
         const file = files[fileIndex];
         const fileName = path.basename(file);
         const fileResults = [];
         const modeTimes = modes.map(() => "...");
+        const buildReuseCache = new Map();
         if (liveMatrix) {
             renderMatrixLiveLine(fileName, modeLabels, modeTimes, showPerModeTimes);
         }
@@ -1104,7 +1172,9 @@ async function runRuntimeMatrix(runFlags, configPath, selectors, modes, modeSumm
                 throw error;
             }
         }
-        renderMatrixFileResult(fileName, modeLabels, fileResults, modeTimes, liveMatrix, showPerModeTimes);
+        if (reporterSession.reporterKind == "default") {
+            renderMatrixFileResult(fileName, modeLabels, fileResults, modeTimes, liveMatrix, showPerModeTimes);
+        }
         const verdict = resolveMatrixVerdict(fileResults);
         if (verdict == "fail") {
             fileState[fileIndex].failed = true;
@@ -1158,7 +1228,7 @@ async function runTestModes(runFlags, configPath, selectors, modes, buildFeature
     }
     let failed = false;
     for (const modeName of modes) {
-        const reporterSession = await createRunReporter(configPath, undefined, modeName);
+        const reporterSession = await createRunReporter(configPath, effectiveRunFlags.reporterPath, modeName);
         const modeResult = await runTestSequential(effectiveRunFlags, configPath, selectors, buildFeatureToggles, modeSummaryTotal, fileSummaryTotal, fuzzEnabled, modeName, reporterSession.reporter, !fuzzEnabled);
         if (modeResult.failed)
             failed = true;
@@ -1228,6 +1298,7 @@ async function runTestMatrix(runFlags, configPath, selectors, modes, buildFeatur
         const fileName = path.basename(file);
         const fileResults = [];
         const modeTimes = modes.map(() => "...");
+        const buildReuseCache = new Map();
         if (liveMatrix) {
             renderMatrixLiveLine(fileName, modeLabels, modeTimes, showPerModeTimes);
         }
@@ -1235,7 +1306,12 @@ async function runTestMatrix(runFlags, configPath, selectors, modes, buildFeatur
             const modeName = modes[i];
             try {
                 const buildStartedAt = Date.now();
-                await build(configPath, [file], modeName, buildFeatureToggles);
+                await buildFileForMode(buildReuseCache, {
+                    configPath,
+                    file,
+                    modeName,
+                    buildFeatureToggles,
+                });
                 buildIntervals.push({ start: buildStartedAt, end: Date.now() });
                 const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, buildFeatureToggles);
                 const artifactKey = resolvePerFileArtifactKey(file, duplicateSpecBasenames);
@@ -1267,7 +1343,9 @@ async function runTestMatrix(runFlags, configPath, selectors, modes, buildFeatur
                 throw error;
             }
         }
-        renderMatrixFileResult(fileName, modeLabels, fileResults, modeTimes, liveMatrix, showPerModeTimes);
+        if (reporterSession.reporterKind == "default") {
+            renderMatrixFileResult(fileName, modeLabels, fileResults, modeTimes, liveMatrix, showPerModeTimes);
+        }
         const verdict = resolveMatrixVerdict(fileResults);
         if (verdict == "fail") {
             fileState[fileIndex].failed = true;
@@ -1330,7 +1408,7 @@ async function runRuntimeSingleParallel(runFlags, configPath, selectors, modeNam
     if (!files.length) {
         throw await buildNoTestFilesMatchedError(configPath, selectors);
     }
-    const reporterSession = await createRunReporter(configPath, undefined, modeName);
+    const reporterSession = await createRunReporter(configPath, runFlags.reporterPath, modeName);
     const reporter = reporterSession.reporter;
     const snapshotEnabled = runFlags.snapshot !== false;
     reporter.onRunStart?.({
@@ -1342,15 +1420,20 @@ async function runRuntimeSingleParallel(runFlags, configPath, selectors, modeNam
     });
     const buildCommandsByFile = await previewBuildCommands(configPath, selectors, modeName, {});
     const results = new Array(files.length);
-    const queueDisplay = new ParallelQueueDisplay(!runFlags.clean);
+    const useQueueDisplay = reporterSession.reporterKind == "default";
+    const queueDisplay = new ParallelQueueDisplay(useQueueDisplay && !runFlags.clean);
     const runLimit = createAsyncLimiter(runFlags.runJobs);
     const poolWidth = Math.max(runFlags.buildJobs, runFlags.runJobs);
     await runOrderedPool(files, poolWidth, async (file, index) => {
-        const token = renderQueuedFileStart(queueDisplay, path.basename(file));
-        const buffered = await createBufferedReporter(configPath, modeName);
+        const token = useQueueDisplay
+            ? renderQueuedFileStart(queueDisplay, path.basename(file))
+            : null;
+        const buffered = useQueueDisplay
+            ? await createBufferedReporter(configPath, runFlags.reporterPath, modeName)
+            : null;
         const result = await runLimit(() => run({ ...runFlags, clean: true }, configPath, [file], false, {
-            reporter: buffered.reporter,
-            reporterKind: buffered.reporterKind,
+            reporter: buffered?.reporter,
+            reporterKind: buffered?.reporterKind,
             modeName,
             emitRunComplete: false,
             fileSummaryTotal: 1,
@@ -1358,9 +1441,11 @@ async function runRuntimeSingleParallel(runFlags, configPath, selectors, modeNam
             modeSummaryExecuted: 1,
             buildCommandsByFile: { [file]: buildCommandsByFile[file] ?? "" },
         }));
-        buffered.reporter.flush?.();
+        buffered?.reporter.flush?.();
         results[index] = result;
-        queueDisplay.complete(token, buffered.output());
+        if (buffered && token != null) {
+            queueDisplay.complete(token, buffered.output());
+        }
     });
     queueDisplay.flush();
     const summary = aggregateRunResults(results);
@@ -1384,7 +1469,7 @@ async function runRuntimeMatrixParallel(runFlags, configPath, selectors, modes,
     if (!files.length) {
         throw await buildNoTestFilesMatchedError(configPath, selectors);
     }
-    const reporterSession = await createRunReporter(configPath);
+    const reporterSession = await createRunReporter(configPath, runFlags.reporterPath);
     const reporter = reporterSession.reporter;
     const snapshotEnabled = runFlags.snapshot !== false;
     reporter.onRunStart?.({
@@ -1399,23 +1484,29 @@ async function runRuntimeMatrixParallel(runFlags, configPath, selectors, modes,
     const showPerModeTimes = Boolean(runFlags.verbose);
     const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
     const ordered = new Array(files.length);
-    const queueDisplay = new ParallelQueueDisplay(!runFlags.clean);
+    const useQueueDisplay = reporterSession.reporterKind == "default";
+    const queueDisplay = new ParallelQueueDisplay(useQueueDisplay && !runFlags.clean);
     const poolWidth = Math.max(runFlags.jobs, runFlags.buildJobs, runFlags.runJobs);
     const buildPool = new BuildWorkerPool(runFlags.buildJobs);
     const buildIntervals = [];
     try {
         await runOrderedPool(files, poolWidth, async (file, fileIndex) => {
             const fileName = path.basename(file);
-            const token = renderQueuedFileStart(queueDisplay, fileName);
+            const token = useQueueDisplay
+                ? renderQueuedFileStart(queueDisplay, fileName)
+                : null;
             const fileResults = [];
             const modeTimes = modes.map(() => "...");
+            const buildReuseCache = new Map();
             for (let i = 0; i < modes.length; i++) {
                 const modeName = modes[i];
                 const buildStartedAt = Date.now();
-                await buildPool.buildFileMode({
+                await buildFileForMode(buildReuseCache, {
                     configPath,
                     file,
                     modeName,
+                    buildFeatureToggles: {},
+                    buildPool,
                 });
                 buildIntervals.push({ start: buildStartedAt, end: Date.now() });
                 const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, {});
@@ -1434,7 +1525,9 @@ async function runRuntimeMatrixParallel(runFlags, configPath, selectors, modes,
                 fileResults.push(result);
             }
             ordered[fileIndex] = { fileName, fileResults, modeTimes };
-            queueDisplay.complete(token, formatMatrixFileResultLine(fileName, modeLabels, fileResults, modeTimes, showPerModeTimes) + "\n");
+            if (token != null) {
+                queueDisplay.complete(token, formatMatrixFileResultLine(fileName, modeLabels, fileResults, modeTimes, showPerModeTimes) + "\n");
+            }
         });
     }
     finally {
@@ -1481,7 +1574,7 @@ async function runTestSingleParallel(runFlags, configPath, selectors, buildFeatu
     if (!files.length && !fuzzEnabled) {
         throw await buildNoTestFilesMatchedError(configPath, selectors);
     }
-    const reporterSession = await createRunReporter(configPath, undefined, modeName);
+    const reporterSession = await createRunReporter(configPath, runFlags.reporterPath, modeName);
     const reporter = reporterSession.reporter;
     const snapshotEnabled = runFlags.snapshot !== false;
     reporter.onRunStart?.({
@@ -1493,37 +1586,45 @@ async function runTestSingleParallel(runFlags, configPath, selectors, buildFeatu
     });
     const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
     const results = new Array(files.length);
-    const queueDisplay = new ParallelQueueDisplay(!runFlags.clean);
+    const useQueueDisplay = reporterSession.reporterKind == "default";
+    const queueDisplay = new ParallelQueueDisplay(useQueueDisplay && !runFlags.clean);
     const poolWidth = Math.max(runFlags.jobs, runFlags.buildJobs, runFlags.runJobs);
     const buildIntervals = [];
     if (files.length) {
         const buildPool = new BuildWorkerPool(runFlags.buildJobs);
         try {
             await runOrderedPool(files, poolWidth, async (file, index) => {
-                const token = renderQueuedFileStart(queueDisplay, path.basename(file));
+                const token = useQueueDisplay
+                    ? renderQueuedFileStart(queueDisplay, path.basename(file))
+                    : null;
                 const buildStartedAt = Date.now();
-                await buildPool.buildFileMode({
+                await buildFileForMode(new Map(), {
                     configPath,
                     file,
                     modeName,
-                    featureToggles: buildFeatureToggles,
+                    buildFeatureToggles,
+                    buildPool,
                 });
                 buildIntervals.push({ start: buildStartedAt, end: Date.now() });
                 const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, buildFeatureToggles);
                 const artifactKey = resolvePerFileArtifactKey(file, duplicateSpecBasenames);
-                const buffered = await createBufferedReporter(configPath, modeName);
+                const buffered = useQueueDisplay
+                    ? await createBufferedReporter(configPath, runFlags.reporterPath, modeName)
+                    : null;
                 const result = await run({ ...runFlags, clean: true }, configPath, [file], false, {
-                    reporter: buffered.reporter,
-                    reporterKind: buffered.reporterKind,
+                    reporter: buffered?.reporter,
+                    reporterKind: buffered?.reporterKind,
                     emitRunComplete: false,
                     logFileName: `test.${artifactKey}.log.json`,
                     coverageFileName: `coverage.${artifactKey}.log.json`,
                     buildCommand: formatBuildInvocation(buildInvocation),
                     modeName,
                 });
-                buffered.reporter.flush?.();
+                buffered?.reporter.flush?.();
                 results[index] = result;
-                queueDisplay.complete(token, buffered.output());
+                if (buffered && token != null) {
+                    queueDisplay.complete(token, buffered.output());
+                }
             });
         }
         finally {
@@ -1572,7 +1673,7 @@ async function runTestMatrixParallel(runFlags, configPath, selectors, modes, bui
             throw await buildNoTestFilesMatchedError(configPath, selectors, true);
         }
     }
-    const reporterSession = await createRunReporter(configPath);
+    const reporterSession = await createRunReporter(configPath, runFlags.reporterPath);
     const reporter = reporterSession.reporter;
     const snapshotEnabled = runFlags.snapshot !== false;
     reporter.onRunStart?.({
@@ -1587,24 +1688,29 @@ async function runTestMatrixParallel(runFlags, configPath, selectors, modes, bui
     const showPerModeTimes = Boolean(runFlags.verbose);
     const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
     const ordered = new Array(files.length);
-    const queueDisplay = new ParallelQueueDisplay(!runFlags.clean);
+    const useQueueDisplay = reporterSession.reporterKind == "default";
+    const queueDisplay = new ParallelQueueDisplay(useQueueDisplay && !runFlags.clean);
     const poolWidth = Math.max(runFlags.jobs, runFlags.buildJobs, runFlags.runJobs);
     const buildPool = new BuildWorkerPool(runFlags.buildJobs);
     const buildIntervals = [];
     try {
         await runOrderedPool(files, poolWidth, async (file, fileIndex) => {
             const fileName = path.basename(file);
-            const token = renderQueuedFileStart(queueDisplay, fileName);
+            const token = useQueueDisplay
+                ? renderQueuedFileStart(queueDisplay, fileName)
+                : null;
             const fileResults = [];
             const modeTimes = modes.map(() => "...");
+            const buildReuseCache = new Map();
             for (let i = 0; i < modes.length; i++) {
                 const modeName = modes[i];
                 const buildStartedAt = Date.now();
-                await buildPool.buildFileMode({
+                await buildFileForMode(buildReuseCache, {
                     configPath,
                     file,
                     modeName,
-                    featureToggles: buildFeatureToggles,
+                    buildFeatureToggles,
+                    buildPool,
                 });
                 buildIntervals.push({ start: buildStartedAt, end: Date.now() });
                 const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, buildFeatureToggles);
@@ -1623,7 +1729,9 @@ async function runTestMatrixParallel(runFlags, configPath, selectors, modes, bui
                 fileResults.push(result);
             }
             ordered[fileIndex] = { fileName, fileResults, modeTimes };
-            queueDisplay.complete(token, formatMatrixFileResultLine(fileName, modeLabels, fileResults, modeTimes, showPerModeTimes) + "\n");
+            if (token != null) {
+                queueDisplay.complete(token, formatMatrixFileResultLine(fileName, modeLabels, fileResults, modeTimes, showPerModeTimes) + "\n");
+            }
         });
     }
     finally {

package/bin/reporters/default.js

@@ -465,12 +465,30 @@ function collectSuiteFailures(suite, file, path, printed) {
         const loc = String(test.location ?? "");
         const where = loc.length ? `${file}:${loc}` : file;
         const modeName = String(suiteAny.modeName ?? "");
-        const dedupeKey = `${file}::${modeName}::${title}::${String(test.left)}::${String(test.right)}`;
+        const message = String(test.message ?? "");
+        const dedupeKey = `${file}::${modeName}::${title}::${String(test.left)}::${String(test.right)}::${message}`;
         if (printed.has(dedupeKey))
             continue;
         printed.add(dedupeKey);
         const left = JSON.stringify(test.left);
         const right = JSON.stringify(test.right);
+        if (left == "null" && right == "null") {
+            console.log(`${chalk.bgRed(" FAIL ")} ${chalk.dim(title)} ${chalk.dim("(" + where + ")")}`);
+            if (modeName.length) {
+                console.log(chalk.dim(`Mode: ${modeName}`));
+            }
+            const normalizedMessage = normalizeFailureMessage(message);
+            if (normalizedMessage.length) {
+                for (const line of normalizedMessage.split("\n")) {
+                    console.log(chalk.dim(line));
+                }
+            }
+            else {
+                console.log(chalk.dim("runtime error"));
+            }
+            console.log("");
+            continue;
+        }
         const diffResult = diff(left, right);
         let expected = "";
         for (const res of diffResult.diff) {
@@ -506,6 +524,9 @@ function collectSuiteFailures(suite, file, path, printed) {
         collectSuiteFailures(sub, file, nextPath, printed);
     }
 }
+function normalizeFailureMessage(message) {
+    return message.replace(/\r\n/g, "\n").trim();
+}
 function renderSnapshotSummary(snapshotSummary, leadingGap = true) {
     if (leadingGap) {
         console.log("");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -64,9 +64,9 @@
     "access": "public"
   },
   "scripts": {
-    "test": "node ./bin/index.js test",
+    "test": "node ./bin/index.js test --parallel",
+    "test:ci": "node ./bin/index.js test --parallel --tap --config ./as-test.ci.config.json",
     "fuzz": "node ./bin/index.js fuzz",
-    "test:ci": "node ./bin/index.js test --tap --config ./as-test.ci.config.json",
     "test:examples": "npm --prefix ./examples run test",
     "ci:act": "bash ./tools/act.sh push",
     "ci:act:pr": "bash ./tools/act.sh pull_request",