as-test 0.5.2 → 0.5.3

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Change Log
 
+## 2026-02-25 - v0.5.3
+
+### CLI, Modes & Matrix
+
+- feat: support mode fan-out behavior consistently across `ast build`, `ast run`, and `ast test`.
+- feat: when no `--mode` is provided and modes are configured, run using configured modes.
+- feat: add matrix-style per-file output with mode-aware timing:
+  - non-verbose: average time
+  - verbose: per-mode times.
+- feat: add real-time matrix line updates in the default reporter and normalize timing precision to one decimal.
+- feat: support comma-separated bare selectors (for example `ast test box,custom,generics,string`) across build/run/test selectors.
+
+### Config Merge & Env Behavior
+
+- fix: apply mode config as field-level merge over base config instead of replacing entire sections.
+- fix: merge `buildOptions.args` between base config and mode config.
+- fix: pass config env variables to both build and run processes for mode execution.
+
+### Build Pipeline & Feature Flags
+
+- feat: include the exact build command in build failure output.
+- feat: allow `buildOptions.cmd` to override default command generation while still appending user build args.
+- feat: support CLI feature toggles:
+  - `--enable coverage` / `--disable coverage`
+  - `--enable try-as` / `--disable try-as`.
+
+### Reporter & Summaries
+
+- fix: move mode summary rendering into the default reporter (via run-complete event payload).
+- feat: include `modeSummary` for single-mode runs.
+- feat: include mode and snapshot totals in final summary output.
+- fix: `--clean` output now behaves as non-TTY in default reporter:
+  - no in-place line editing,
+  - no suite expand/collapse logs,
+  - final per-file verdict lines only.
+
+### Coverage & Transform
+
+- fix: ignore AssemblyScript builtin/compiler helper calls during coverage instrumentation (including `isString`, `changetype<T>`, `idof<T>`, `sizeof<T>`).
+- fix: mock transform now collects mocked import targets across sources so WASI mock imports are rewritten reliably (resolves import-shape runtime failures).
+
 ## 2026-02-24 - v0.5.2
 
 ### Runtime & Serialization

package/README.md

@@ -74,7 +74,7 @@ describe("math", () => {
 });
 ```
 
-### Test file selection (`ast test`)
+### File selection (`ast run`, `ast build`, `ast test`)
 
 No selectors:
 
@@ -105,6 +105,14 @@ Multiple selectors:
 ast test sleep array ./assembly/__tests__/snapshot.spec.ts
 ```
 
+Comma-separated bare suite names:
+
+```bash
+ast test box,custom,generics,string
+ast run box,custom,generics,string
+ast build box,custom,generics,string
+```
+
 If nothing matches, `ast test` exits non-zero with:
 
 ```text
@@ -114,11 +122,21 @@ No test files matched: ...
 ### Useful flags
 
 - `--config <path>`: use another config file
-- `--mode <name[,name...]>`: run one or multiple named config modes
+- `--mode <name[,name...]>`: run one or multiple named config modes (if omitted and `modes` is configured, as-test runs all configured modes)
 - `--update-snapshots`: write snapshot updates
 - `--no-snapshot`: disable snapshot assertions for the run
 - `--show-coverage`: print uncovered coverage points
+- `--enable <feature>`: enable as-test feature (`coverage`, `try-as`)
+- `--disable <feature>`: disable as-test feature (`coverage`, `try-as`)
 - `--verbose`: keep expanded suite/test lines and update running `....` statuses in place
+- `--clean`: disable in-place TTY updates and print only final per-file verdict lines. Useful for CI/CD.
+
+Example:
+
+```bash
+ast build --enable try-as
+ast test --disable coverage
+```
 
 ## Mocking
 
@@ -236,7 +254,9 @@ Example:
   "snapshotDir": "./.as-test/snapshots",
   "config": "none",
   "coverage": true,
+  "env": {},
   "buildOptions": {
+    "cmd": "",
     "args": [],
     "target": "wasi"
   },
@@ -257,8 +277,10 @@ Key fields:
 - `logs`: log output dir or `"none"`
 - `coverageDir`: coverage output dir or `"none"`
 - `snapshotDir`: snapshot storage dir
+- `env`: environment variables injected into build and runtime processes
+- `buildOptions.cmd`: optional custom build command template; when set it replaces default build command and flags. Supports `<file>`, `<name>`, `<outFile>`, `<target>`, `<mode>`
 - `buildOptions.target`: `wasi` or `bindings`
-- `modes`: named overrides for target/args/runtime/env/artifact directories (selected via `--mode`)
+- `modes`: named overrides for command/target/args/runtime/env/artifact directories (selected via `--mode`); `mode.env` overrides top-level `env`
 - `runOptions.runtime.cmd`: runtime command, supports `<file>` and `<name>`; if its script path is missing, as-test falls back to the default runner for the selected target
 - `runOptions.reporter`: reporter selection as a string or object
 
@@ -309,6 +331,13 @@ Run all modes:
 ast test --mode wasi-simd,wasi-nosimd,bindings-node-simd
 ```
 
+Summary totals:
+
+- `Modes` in the default reporter is config-scoped (`total` is all configured modes)
+- when selecting fewer modes with `--mode`, unselected modes are counted as `skipped`
+- `Files` in the default reporter is also config-scoped (`total` is all files from configured input patterns)
+- when selecting fewer files, unselected files are counted as `skipped`
+
 When using `--mode`, compiled artifacts are emitted as:
 
 ```text

package/as-test.config.schema.json

@@ -80,10 +80,23 @@
       ],
       "default": true
     },
+    "env": {
+      "type": "object",
+      "description": "Environment variables injected when building/running.",
+      "additionalProperties": {
+        "type": "string"
+      },
+      "default": {}
+    },
     "buildOptions": {
       "type": "object",
       "additionalProperties": false,
       "properties": {
+        "cmd": {
+          "type": "string",
+          "description": "Custom build command template. When set, this replaces the default asc command/flags/output handling. Supports placeholders: <file>, <name>, <outFile>, <target>, <mode>.",
+          "default": ""
+        },
         "args": {
           "type": "array",
           "items": {
@@ -98,6 +111,7 @@
         }
       },
       "default": {
+        "cmd": "",
         "args": [],
         "target": "wasi"
       }
@@ -153,6 +167,10 @@
             "type": "object",
             "additionalProperties": false,
             "properties": {
+              "cmd": {
+                "type": "string",
+                "description": "Mode-specific custom build command template."
+              },
               "args": {
                 "type": "array",
                 "items": {

package/assembly/coverage.ts

@@ -23,6 +23,26 @@ export function __REGISTER(point: CoverPoint): void {
   Coverage.SN.hashes.set(point.hash, point);
 }
 
+export function __REGISTER_RAW(
+  file: string,
+  hash: string,
+  line: i32,
+  column: i32,
+  type: string,
+): void {
+  if (Coverage.SN.allIndex.has(hash)) return;
+  const point = new CoverPoint();
+  point.file = file;
+  point.hash = hash;
+  point.line = line;
+  point.column = column;
+  point.type = type;
+  Coverage.SN.points++;
+  Coverage.SN.allIndex.set(hash, Coverage.SN.all.length);
+  Coverage.SN.all.push(point);
+  Coverage.SN.hashes.set(hash, point);
+}
+
 export function __COVER(hash: string): void {
   if (Coverage.SN.allIndex.has(hash)) {
     const index = Coverage.SN.allIndex.get(hash);

package/assembly/util/json.ts

@@ -18,17 +18,16 @@ export function stringifyValue<T>(value: T): string {
   }
 
   if (isInteger<T>() || isFloat<T>()) {
-    // @ts-ignore
+    // @ts-expect-error: type
     return value.toString();
   }
 
   if (isString<T>()) {
-    // @ts-ignore
     return quote(value as string);
   }
 
   if (isArray<T>()) {
-    // @ts-ignore
+    // @ts-expect-error: type
     return stringifyArray<valueof<T>>(value as valueof<T>[]);
   }
 

package/bin/build.js

@@ -5,29 +5,67 @@ import { execSync } from "child_process";
 import * as path from "path";
 import { applyMode, getPkgRunner, loadConfig } from "./util.js";
 const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
-export async function build(configPath = DEFAULT_CONFIG_PATH, selectors = [], modeName) {
+export async function build(configPath = DEFAULT_CONFIG_PATH, selectors = [], modeName, featureToggles = {}) {
     const loadedConfig = loadConfig(configPath, false);
     const mode = applyMode(loadedConfig, modeName);
     const config = mode.config;
-    ensureDeps(config);
+    if (!hasCustomBuildCommand(config)) {
+        ensureDeps(config);
+    }
     const pkgRunner = getPkgRunner();
     const inputPatterns = resolveInputPatterns(config.input, selectors);
     const inputFiles = (await glob(inputPatterns)).sort((a, b) => a.localeCompare(b));
-    const buildArgs = getBuildArgs(config);
+    const coverageEnabled = resolveCoverageEnabled(config.coverage, featureToggles.coverage);
+    const buildEnv = {
+        ...mode.env,
+        AS_TEST_COVERAGE_ENABLED: coverageEnabled ? "1" : "0",
+    };
     for (const file of inputFiles) {
-        let cmd = `${pkgRunner} asc ${file}${buildArgs}`;
         const outFile = `${config.outDir}/${resolveArtifactFileName(file, config.buildOptions.target, modeName)}`;
-        if (config.outDir) {
-            cmd += " -o " + outFile;
-        }
+        const cmd = getBuildCommand(config, pkgRunner, file, outFile, modeName, featureToggles);
         try {
-            buildFile(cmd, mode.env);
+            buildFile(cmd, buildEnv);
         }
         catch (error) {
-            throw new Error(`Failed to build ${path.basename(file)} with ${getBuildStderr(error)}`);
+            const modeLabel = modeName ?? "default";
+            throw new Error(`Failed to build ${path.basename(file)} in mode ${modeLabel} with ${getBuildStderr(error)}\nBuild command: ${cmd}`);
         }
     }
 }
+function hasCustomBuildCommand(config) {
+    return !!config.buildOptions.cmd.trim().length;
+}
+function getBuildCommand(config, pkgRunner, file, outFile, modeName, featureToggles = {}) {
+    const userArgs = getUserBuildArgs(config);
+    if (hasCustomBuildCommand(config)) {
+        return `${expandBuildCommand(config.buildOptions.cmd, file, outFile, config.buildOptions.target, modeName)}${userArgs}`;
+    }
+    const defaultArgs = getDefaultBuildArgs(config, featureToggles);
+    let cmd = `${pkgRunner} asc ${file}${userArgs}${defaultArgs}`;
+    if (config.outDir) {
+        cmd += " -o " + outFile;
+    }
+    return cmd;
+}
+function getUserBuildArgs(config) {
+    const args = config.buildOptions.args.filter((value) => value.length > 0);
+    if (args.length) {
+        return " " + args.join(" ");
+    }
+    return "";
+}
+function expandBuildCommand(template, file, outFile, target, modeName) {
+    const name = path
+        .basename(file)
+        .replace(/\.spec\.ts$/, "")
+        .replace(/\.ts$/, "");
+    return template
+        .replace(/<file>/g, file)
+        .replace(/<name>/g, name)
+        .replace(/<outFile>/g, outFile)
+        .replace(/<target>/g, target)
+        .replace(/<mode>/g, modeName ?? "");
+}
 function resolveArtifactFileName(file, target, modeName) {
     const base = path
         .basename(file)
@@ -45,7 +83,7 @@ function resolveInputPatterns(configured, selectors) {
     if (!selectors.length)
         return configuredInputs;
     const patterns = new Set();
-    for (const selector of selectors) {
+    for (const selector of expandSelectors(selectors)) {
         if (!selector)
             continue;
         if (isBareSuiteSelector(selector)) {
@@ -59,6 +97,30 @@ function resolveInputPatterns(configured, selectors) {
     }
     return [...patterns];
 }
+function expandSelectors(selectors) {
+    const expanded = [];
+    for (const selector of selectors) {
+        if (!selector)
+            continue;
+        if (!shouldSplitSelector(selector)) {
+            expanded.push(selector);
+            continue;
+        }
+        for (const token of selector.split(",")) {
+            const trimmed = token.trim();
+            if (!trimmed.length)
+                continue;
+            expanded.push(trimmed);
+        }
+    }
+    return expanded;
+}
+function shouldSplitSelector(selector) {
+    return (selector.includes(",") &&
+        !selector.includes("/") &&
+        !selector.includes("\\") &&
+        !/[*?[\]{}]/.test(selector));
+}
 function isBareSuiteSelector(selector) {
     return (!selector.includes("/") &&
         !selector.includes("\\") &&
@@ -98,16 +160,17 @@ function getBuildStderr(error) {
     const message = typeof err?.message == "string" ? err.message.trim() : "";
     return message || "unknown error";
 }
-function getBuildArgs(config) {
+function getDefaultBuildArgs(config, featureToggles) {
     let buildArgs = "";
+    const tryAsEnabled = resolveTryAsEnabled(featureToggles.tryAs);
     buildArgs += " --transform as-test/transform";
-    if (hasTryAsRuntime()) {
+    if (tryAsEnabled) {
         buildArgs += " --transform try-as/transform";
     }
     if (config.config && config.config !== "none") {
         buildArgs += " --config " + config.config;
     }
-    if (hasTryAsRuntime()) {
+    if (tryAsEnabled) {
         buildArgs += " --use AS_TEST_TRY_AS=1";
     }
     // Should also strip any bindings-enabling from asconfig
@@ -124,12 +187,29 @@ function getBuildArgs(config) {
         console.log(`${chalk.bgRed(" ERROR ")}${chalk.dim(":")} could not determine target in config! Set target to 'bindings' or 'wasi'`);
         process.exit(1);
     }
-    if (config.buildOptions.args.length &&
-        config.buildOptions.args.find((v) => v.length > 0)) {
-        buildArgs += " " + config.buildOptions.args.join(" ");
-    }
     return buildArgs;
 }
+function resolveTryAsEnabled(override) {
+    const installed = hasTryAsRuntime();
+    if (override === false)
+        return false;
+    if (override === true && !installed) {
+        throw new Error('try-as feature was enabled, but package "try-as" is not installed');
+    }
+    return installed;
+}
+function resolveCoverageEnabled(rawCoverage, override) {
+    if (override != undefined)
+        return override;
+    if (typeof rawCoverage == "boolean")
+        return rawCoverage;
+    if (rawCoverage && typeof rawCoverage == "object") {
+        const enabled = rawCoverage.enabled;
+        if (typeof enabled == "boolean")
+            return enabled;
+    }
+    return true;
+}
 function hasTryAsRuntime() {
     return (existsSync(path.join(process.cwd(), "node_modules/try-as")) ||
         existsSync(path.join(process.cwd(), "node_modules/try-as/package.json")));