as-test 1.1.10 → 1.3.0

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 };
   }
@@ -1449,3 +1492,77 @@ export function resolveProjectModule(specifier) {
   }
   return null;
 }
+// picomatch-compatible glob metacharacters; first occurrence marks the start
+// of the dynamic part of a pattern and everything before it is the static base.
+const GLOB_META_RE = /[*?[\](){}!|+@]/;
+// Longest non-glob prefix of a single pattern, returned with native separators.
+// Examples:
+//   "assembly/__tests__/**/*.spec.ts" -> "assembly/__tests__"
+//   "**/*.spec.ts"                    -> ""
+//   "assembly/foo.spec.ts"            -> "assembly" (no glob → use dirname)
+//   "/abs/path/**/*.ts"               -> "/abs/path"
+export function resolveGlobBase(pattern) {
+  const normalized = pattern.replace(/\\/g, "/");
+  const metaIdx = normalized.search(GLOB_META_RE);
+  let base;
+  if (metaIdx < 0) {
+    const dir = dirname(normalized);
+    base = dir == "." ? "" : dir;
+  } else {
+    const slice = normalized.slice(0, metaIdx);
+    const lastSlash = slice.lastIndexOf("/");
+    base = lastSlash < 0 ? "" : slice.slice(0, lastSlash);
+  }
+  if (!base.length) return "";
+  return base.split("/").join(sep);
+}
+// Strip the most-specific matching configured input base off `file`, returning
+// the path relative to that base (with native separators). If no base matches,
+// returns the basename of the file. Comparison is component-wise — so
+// "assembly/__tests" is not a prefix of "assembly/__tests__/foo.spec.ts".
+export function resolveSpecRelativePath(file, inputPatterns) {
+  const patterns = Array.isArray(inputPatterns)
+    ? inputPatterns
+    : [inputPatterns];
+  const absFile = resolve(process.cwd(), file);
+  const fileComponents = toComponents(absFile);
+  let bestBaseAbs = null;
+  let bestLength = -1;
+  for (const pattern of patterns) {
+    const base = resolveGlobBase(pattern);
+    const absBase = base.length
+      ? resolve(process.cwd(), base)
+      : resolve(process.cwd());
+    const baseComponents = toComponents(absBase);
+    if (!isComponentPrefix(baseComponents, fileComponents)) continue;
+    if (baseComponents.length > bestLength) {
+      bestBaseAbs = absBase;
+      bestLength = baseComponents.length;
+    }
+  }
+  if (bestBaseAbs == null) return basename(file);
+  const rel = relative(bestBaseAbs, absFile);
+  return rel.length ? rel : basename(file);
+}
+// Compute the artifact path (relative to outDir) for a given spec/fuzz source
+// file. Strips ".ts" only, keeping ".spec" / ".fuzz" suffixes so spec and
+// fuzz artifacts can coexist in the same outDir.
+//   assembly/__tests__/array.spec.ts        -> "array.spec.wasm"
+//   assembly/__tests__/nested/array.spec.ts -> "nested/array.spec.wasm"
+//   assembly/__fuzz__/nested/array.fuzz.ts  -> "nested/array.fuzz.wasm"
+export function resolveArtifactPath(file, inputPatterns) {
+  const rel = resolveSpecRelativePath(file, inputPatterns);
+  return rel.replace(/\.ts$/i, ".wasm");
+}
+function toComponents(absPath) {
+  return absPath
+    .split(/[\\/]+/)
+    .filter((segment, idx) => segment.length || idx == 0);
+}
+function isComponentPrefix(prefix, full) {
+  if (prefix.length > full.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (prefix[i] !== full[i]) return false;
+  }
+  return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.1.10",
+  "version": "1.3.0",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -18,16 +18,18 @@
   "devDependencies": {
     "@assemblyscript/wasi-shim": "^0.1.0",
     "@eslint/js": "^10.0.1",
-    "@types/node": "^25.6.0",
+    "@types/node": "^25.9.1",
     "as-sleep": "^0.0.2",
     "as-test": "./",
     "assemblyscript": "^0.28.17",
     "assemblyscript-prettier": "^3.0.4",
-    "json-as": "^1.3.6",
+    "husky": "^9.1.7",
+    "json-as": "^1.3.7",
+    "playwright": "^1.60.0",
     "prettier": "3.8.3",
-    "try-as": "^1.0.1",
+    "try-as": "^1.1.0",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.59.1",
+    "typescript-eslint": "^8.59.4",
     "vitepress": "^1.6.4"
   },
   "bin": {
@@ -76,9 +78,9 @@
   },
   "scripts": {
     "test": "npm run test:as && npm run test:integration",
-    "test:as": "node ./bin/index.js test --parallel",
+    "test:as": "node ./bin/index.js test --parallel --enable try-as",
     "test:integration": "npm run build:cli && npm run build:lib && node --test tests/*.test.mjs",
-    "test:ci": "node ./bin/index.js test --parallel --tap --config ./as-test.ci.config.json",
+    "test:ci": "node ./bin/index.js test --parallel --tap --enable try-as --config ./as-test.ci.config.json",
     "fuzz": "node ./bin/index.js fuzz",
     "bench:seed": "node ./bin/index.js fuzz --config ./as-test.bench.config.json --clean",
     "bench:seed:compare": "bash ./tools/bench-seed-compare.sh 7",
@@ -90,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",
@@ -98,7 +100,10 @@
     "docs:preview": "vitepress preview docs",
     "format": "prettier -w .",
     "release:check": "npm run build:cli && npm run build:lib && npm run build:transform && npm run test && npm run test:examples && npm pack --dry-run --cache /tmp/as-test-npm-cache",
-    "prepublishOnly": "npm run build:cli && npm run build:lib && npm run build:transform && npm run test && npm run format"
+    "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",
+    "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;