as-test 1.2.0 → 1.3.0

package/bin/index.js

@@ -3,8 +3,10 @@ import chalk from "chalk";
 import {
   build,
   BuildFailureError,
+  flushModeWarnings,
   formatInvocation as formatBuildInvocation,
   getBuildInvocationPreview,
+  warnOnUnknownModeReferences,
 } from "./commands/build.js";
 import { createRunReporter, run } from "./commands/run.js";
 import { executeBuildCommand } from "./commands/build.js";
@@ -26,6 +28,7 @@ import {
   resolveModeNames,
   resolveSpecRelativePath,
 } from "./util.js";
+import { normalizeFeatureName } from "./types.js";
 import * as path from "path";
 import { spawnSync } from "child_process";
 import { glob } from "glob";
@@ -289,10 +292,10 @@ function printCommandHelp(command) {
       "  --mode <name[,name...]>  Run one or multiple named config modes\n",
     );
     process.stdout.write(
-      "  --enable <feature>       Enable build feature (coverage|try-as)\n",
+      "  --enable <list>          Enable features, comma-separated (e.g. coverage,try-as,simd)\n",
     );
     process.stdout.write(
-      "  --disable <feature>      Disable build feature (coverage|try-as)\n",
+      "  --disable <list>         Disable features, comma-separated\n",
     );
     process.stdout.write(
       "  --parallel              Run files through an ordered worker pool using an automatic worker count\n",
@@ -356,10 +359,10 @@ function printCommandHelp(command) {
     );
     process.stdout.write("  --suites <name[,name...]> Alias for --suite\n");
     process.stdout.write(
-      "  --enable <feature>       Enable feature (coverage|try-as)\n",
+      "  --enable <list>          Enable features, comma-separated (e.g. coverage,try-as,simd)\n",
     );
     process.stdout.write(
-      "  --disable <feature>      Disable feature (coverage|try-as)\n",
+      "  --disable <list>         Disable features, comma-separated\n",
     );
     process.stdout.write(
       "  --reporter <name|path>   Use built-in reporter (default|tap) or custom module path\n",
@@ -428,10 +431,10 @@ function printCommandHelp(command) {
     );
     process.stdout.write("  --suites <name[,name...]> Alias for --suite\n");
     process.stdout.write(
-      "  --enable <feature>       Enable feature (coverage|try-as)\n",
+      "  --enable <list>          Enable features, comma-separated (e.g. coverage,try-as,simd)\n",
     );
     process.stdout.write(
-      "  --disable <feature>      Disable feature (coverage|try-as)\n",
+      "  --disable <list>         Disable features, comma-separated\n",
     );
     process.stdout.write(
       "  --fuzz                   Run fuzz targets after the normal test pass\n",
@@ -534,6 +537,12 @@ function printCommandHelp(command) {
     process.stdout.write(
       "  --example <minimal|full|none>           Set example template\n",
     );
+    process.stdout.write(
+      "  --enable <list>                         Enable features, comma-separated (coverage,try-as)\n",
+    );
+    process.stdout.write(
+      "  --disable <list>                        Disable features, comma-separated\n",
+    );
     process.stdout.write(
       "  --install                               Install dependencies after scaffolding\n",
     );
@@ -709,8 +718,9 @@ function resolveCommandArgs(rawArgs, command) {
   return values;
 }
 function resolveFeatureToggles(rawArgs, command) {
-  if (command !== "build" && command !== "run" && command !== "test") return {};
-  const out = {};
+  if (command !== "build" && command !== "run" && command !== "test")
+    return { featureOverrides: {} };
+  const out = { featureOverrides: {} };
   let seenCommand = false;
   for (let i = 0; i < rawArgs.length; i++) {
     const arg = rawArgs[i];
@@ -722,7 +732,9 @@ function resolveFeatureToggles(rawArgs, command) {
       const enabled = arg == "--enable";
       const next = rawArgs[i + 1];
       if (next && !next.startsWith("-")) {
-        applyFeatureToggle(out, next, enabled);
+        for (const name of splitFeatureList(next)) {
+          applyFeatureToggle(out, name, enabled);
+        }
         i++;
       }
       continue;
@@ -730,9 +742,9 @@ function resolveFeatureToggles(rawArgs, command) {
     if (arg.startsWith("--enable=") || arg.startsWith("--disable=")) {
       const enabled = arg.startsWith("--enable=");
       const eq = arg.indexOf("=");
-      const value = arg.slice(eq + 1).trim();
-      if (value.length) {
-        applyFeatureToggle(out, value, enabled);
+      const value = arg.slice(eq + 1);
+      for (const name of splitFeatureList(value)) {
+        applyFeatureToggle(out, name, enabled);
       }
     }
   }
@@ -1280,19 +1292,24 @@ function parseIntegerFlag(flag, value) {
   }
   return Math.floor(parsed);
 }
+function splitFeatureList(value) {
+  return value
+    .split(",")
+    .map((part) => part.trim())
+    .filter((part) => part.length > 0);
+}
 function applyFeatureToggle(out, rawFeature, enabled) {
-  const key = rawFeature.trim().toLowerCase();
+  const key = normalizeFeatureName(rawFeature);
+  if (!key.length) {
+    throw new Error(
+      `empty feature name passed to ${enabled ? "--enable" : "--disable"}`,
+    );
+  }
   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`,
-  );
+  out.featureOverrides[key] = enabled;
 }
 function resolveCommandTokens(rawArgs, command) {
   const values = [];
@@ -1425,6 +1442,7 @@ async function runTestSequential(
       ),
     });
     reporter.flush?.();
+    flushModeWarnings(process.argv.includes("--show-warnings"));
   }
   return {
     failed,
@@ -1874,6 +1892,7 @@ async function runTestModesCore(
           ),
         });
         reporterSession.reporter.flush?.();
+        flushModeWarnings(process.argv.includes("--show-warnings"));
       }
     }
   } finally {
@@ -2063,6 +2082,14 @@ async function runTestMatrix(
   fuzzOverrides,
 ) {
   const files = await resolveSelectedFiles(configPath, selectors);
+  if (files.length && configPath) {
+    try {
+      const loaded = loadConfig(configPath, false);
+      warnOnUnknownModeReferences(files, loaded.modes ?? {});
+    } catch {
+      // Best-effort: never fail the run on a scan error.
+    }
+  }
   if (!files.length) {
     if (!fuzzEnabled) {
       throw await buildNoTestFilesMatchedError(configPath, selectors);
@@ -2215,6 +2242,7 @@ async function runTestMatrix(
     modeSummary: buildModeSummary(modeState, modeSummaryTotal),
   });
   reporter.flush?.();
+  flushModeWarnings(process.argv.includes("--show-warnings"));
   return failed;
 }
 async function runFuzzModes(
@@ -2372,6 +2400,7 @@ async function runRuntimeSingleParallel(
     ),
   });
   reporter.flush?.();
+  flushModeWarnings(process.argv.includes("--show-warnings"));
   return results.some((result) => result.failed);
 }
 async function runRuntimeMatrixParallel(
@@ -2516,6 +2545,7 @@ async function runRuntimeMatrixParallel(
     modeSummary: buildModeSummary(modeState, modeSummaryTotal),
   });
   reporter.flush?.();
+  flushModeWarnings(process.argv.includes("--show-warnings"));
   return allResults.some((result) => result.failed);
 }
 async function runTestSingleParallel(
@@ -2671,6 +2701,7 @@ async function runTestSingleParallel(
     ),
   });
   reporter.flush?.();
+  flushModeWarnings(process.argv.includes("--show-warnings"));
   return failed;
 }
 async function runTestMatrixParallel(
@@ -2687,6 +2718,14 @@ async function runTestMatrixParallel(
   fuzzOverrides,
 ) {
   const files = await resolveSelectedFiles(configPath, selectors);
+  if (files.length && configPath) {
+    try {
+      const loaded = loadConfig(configPath, false);
+      warnOnUnknownModeReferences(files, loaded.modes ?? {});
+    } catch {
+      // Best-effort: never fail the run on a scan error.
+    }
+  }
   if (!files.length) {
     if (!fuzzEnabled) {
       throw await buildNoTestFilesMatchedError(configPath, selectors);
@@ -2851,6 +2890,7 @@ async function runTestMatrixParallel(
     modeSummary: buildModeSummary(modeState, modeSummaryTotal),
   });
   reporter.flush?.();
+  flushModeWarnings(process.argv.includes("--show-warnings"));
   return failed;
 }
 async function runFuzzMatrixResultsParallel(

package/bin/types.js

@@ -8,6 +8,7 @@ export class Config {
     this.snapshotDir = "./.as-test/snapshots";
     this.config = "none";
     this.coverage = false;
+    this.features = [];
     this.env = {};
     this.buildOptions = new BuildOptions();
     this.runOptions = new RunOptions();
@@ -15,6 +16,12 @@ export class Config {
     this.modes = {};
   }
 }
+export const INTERNAL_FEATURE_NAMES = new Set(["try-as"]);
+export function normalizeFeatureName(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed == "try_as" || trimmed == "tryas") return "try-as";
+  return trimmed;
+}
 export class CoverageOptions {
   constructor() {
     this.enabled = false;

package/bin/util.js

@@ -6,6 +6,7 @@ import {
   CoverageIgnoreOptions,
   FuzzConfig,
   ModeConfig,
+  normalizeFeatureName,
   ReporterConfig,
   RunOptions,
   Runtime,
@@ -186,6 +187,7 @@ function parseConfigRaw(raw, configPath) {
     typeof config.fuzz.crashDir == "string" && config.fuzz.crashDir.length
       ? config.fuzz.crashDir
       : "./.as-test/crashes";
+  config.features = parseFeaturesField(raw.features);
   config.modes = parseModes(raw.modes, configDir);
   CONFIG_META.set(config, {
     sourcePath: configPath,
@@ -193,6 +195,19 @@ function parseConfigRaw(raw, configPath) {
   });
   return config;
 }
+function parseFeaturesField(raw) {
+  if (!Array.isArray(raw)) return [];
+  const seen = new Set();
+  const out = [];
+  for (const value of raw) {
+    if (typeof value != "string") continue;
+    const name = normalizeFeatureName(value);
+    if (!name.length || seen.has(name)) continue;
+    seen.add(name);
+    out.push(name);
+  }
+  return out;
+}
 const TOP_LEVEL_KEYS = new Set([
   "$schema",
   "input",
@@ -203,6 +218,7 @@ const TOP_LEVEL_KEYS = new Set([
   "snapshotDir",
   "config",
   "coverage",
+  "features",
   "env",
   "buildOptions",
   "fuzz",
@@ -238,6 +254,7 @@ function validateConfig(raw, configPath) {
   validateStringField(raw, "snapshotDir", "$", issues);
   validateStringField(raw, "config", "$", issues);
   validateCoverageField(raw, "coverage", "$", issues);
+  validateFeaturesField(raw, "features", "$", issues);
   validateEnvField(raw, "env", "$", issues);
   validateBuildOptionsField(raw, "buildOptions", "$", issues);
   validateFuzzField(raw, "fuzz", "$", issues);
@@ -742,12 +759,34 @@ function validateModesField(raw, key, pathPrefix, issues) {
     validateStringField(modeObj, "snapshotDir", modePath, issues);
     validateStringField(modeObj, "config", modePath, issues);
     validateCoverageField(modeObj, "coverage", modePath, issues);
+    validateFeaturesField(modeObj, "features", modePath, issues);
     validateFuzzField(modeObj, "fuzz", modePath, issues);
     validateEnvField(modeObj, "env", modePath, issues);
     validateBuildOptionsField(modeObj, "buildOptions", modePath, issues);
     validateRunOptionsField(modeObj, "runOptions", modePath, issues);
   }
 }
+function validateFeaturesField(raw, key, pathPrefix, issues) {
+  if (!(key in raw) || raw[key] == undefined) return;
+  const value = raw[key];
+  if (!Array.isArray(value)) {
+    issues.push({
+      path: `${pathPrefix}.${key}`,
+      message: "must be an array of feature name strings",
+      fix: 'example: "features": ["try-as", "simd"]',
+    });
+    return;
+  }
+  for (let i = 0; i < value.length; i++) {
+    if (typeof value[i] != "string" || !value[i].trim().length) {
+      issues.push({
+        path: `${pathPrefix}.${key}[${i}]`,
+        message: "must be a non-empty string",
+        fix: 'feature names look like "try-as" or "simd"',
+      });
+    }
+  }
+}
 function isStringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item == "string");
 }
@@ -1051,6 +1090,7 @@ function cloneConfig(config) {
   cloned.runOptions = cloneRunOptions(config.runOptions);
   cloned.fuzz = cloneFuzzConfig(config.fuzz);
   cloned.coverage = cloneCoverageOptions(config.coverage);
+  cloned.features = [...config.features];
   cloned.modes = Object.fromEntries(
     Object.entries(config.modes).map(([name, mode]) => [
       name,
@@ -1211,6 +1251,9 @@ function mergeRootConfig(base, override) {
       raw.coverage,
     );
   }
+  if (Array.isArray(raw.features)) {
+    merged.features = [...override.features];
+  }
   if ("env" in raw) {
     merged.env = { ...override.env };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -25,6 +25,7 @@
     "assemblyscript-prettier": "^3.0.4",
     "husky": "^9.1.7",
     "json-as": "^1.3.7",
+    "playwright": "^1.60.0",
     "prettier": "3.8.3",
     "try-as": "^1.1.0",
     "typescript": "^6.0.3",
@@ -91,7 +92,7 @@
     "typecheck": "tsc -p cli --noEmit && tsc -p tsconfig.lib.json --noEmit && tsc -p transform --noEmit",
     "lint": "eslint transform/src/**/*.ts tools/**/*.js eslint.config.js",
     "build:lib": "tsc -p ./tsconfig.lib.json",
-    "build:transform": "tsc -p ./transform",
+    "build:transform": "tsc -p ./transform && prettier -w ./transform/",
     "build:cli": "tsc -p cli",
     "build:run": "npm run build:cli",
     "docs:dev": "vitepress dev docs",
@@ -102,7 +103,6 @@
     "prepublishOnly": "npm run build:cli && npm run build:lib && npm run build:transform && npm run test && npm run format",
     "commitmsg:verify": "bash ./scripts/commit-msg.sh",
     "precommit:verify": "bash ./scripts/pre-commit.sh",
-    "prepush:verify": "bash ./scripts/pre-push.sh",
     "prepare": "husky"
   },
   "type": "module"

package/transform/lib/index.js

@@ -5,8 +5,10 @@ import { MockTransform } from "./mock.js";
 import { LocationTransform } from "./location.js";
 import { LogTransform } from "./log.js";
 import { isStdlib } from "./util.js";
+import { NodeKind } from "./types.js";
 export default class Transformer extends Transform {
     afterParse(parser) {
+        patchModeName(parser, process.env.AS_TEST_MODE_NAME ?? "default");
         const mock = new MockTransform();
         const location = new LocationTransform();
         const log = new LogTransform(parser);
@@ -81,6 +83,30 @@ export default class Transformer extends Transform {
         }
     }
 }
+function patchModeName(parser, modeName) {
+    for (const source of parser.sources) {
+        if (!source.normalizedPath.endsWith("assembly/src/mode.ts"))
+            continue;
+        for (const stmt of source.statements) {
+            if (stmt.kind !== NodeKind.Variable)
+                continue;
+            const decls = stmt.declarations;
+            for (const decl of decls) {
+                if (decl.name.text !== "AS_TEST_MODE_NAME")
+                    continue;
+                if (!decl.initializer)
+                    continue;
+                if (decl.initializer.kind !== NodeKind.Literal)
+                    continue;
+                const literal = decl.initializer;
+                if (literal.literalKind !== 2)
+                    continue;
+                literal.value = modeName;
+                return;
+            }
+        }
+    }
+}
 function collectMockImportTargets(sources) {
     const out = new Set();
     const pattern = /\bmockImport\s*\(\s*["']([^"']+)["']/g;