as-test 1.1.4 → 1.1.5

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Change Log
 
+## 2026-05-15 - v1.1.5
+
+- fix: coverage `mode` and `dependencies` filtering now correctly handles AssemblyScript-normalized `~lib/<pkg>/...` paths, which are the actual runtime paths emitted for `node_modules` imports.
+- fix: `ENTRY_FILE` injected by the transform now uses the full relative path instead of the basename, preventing snapshot key collisions between specs with the same filename in different directories; snapshot lookup normalizes the file prefix to maintain backward compatibility with existing `.snap` files.
+- fix: transform visitor and coverage instrumentation now resolve `NodeKind` values at runtime instead of relying on compile-time const enum inlining, so they remain correct across AssemblyScript versions.
+- fix: add a no-op `TupleType` case to the transform visitor so files using tuple types no longer throw during instrumentation.
+
 ## 2026-05-14 - v1.1.4
 
 - feat: add `coverage.mode` (`project` or `all`) plus `coverage.dependencies` package allowlisting so dependency coverage can include normal or pnpm-installed packages without raw path globs.

package/bin/commands/run-core.js

@@ -23,6 +23,7 @@ class SnapshotStore {
         this.matched = 0;
         this.failed = 0;
         this.warnedMissing = new Set();
+        this.specBasename = path.basename(specFile);
         const dir = path.join(process.cwd(), snapshotDir);
         const relative = resolveArtifactRelativePath(specFile, "__tests__").replace(/\.ts$/, ".snap");
         this.filePath = path.join(dir, relative);
@@ -37,6 +38,7 @@ class SnapshotStore {
     }
     assert(key, actual, allowSnapshot, createSnapshots, overwriteSnapshots) {
         key = canonicalizeSnapshotKey(key);
+        key = normalizeSnapshotKeyPrefix(key, this.specBasename);
         if (!allowSnapshot)
             return { ok: true, expected: actual, warnMissing: false };
         if (!(key in this.data)) {
@@ -260,6 +262,12 @@ function localizeSnapshotKey(specFile, key) {
     const prefix = `${path.basename(specFile)}::`;
     return key.startsWith(prefix) ? key.slice(prefix.length) : key;
 }
+function normalizeSnapshotKeyPrefix(key, specBasename) {
+    const sep = key.indexOf("::");
+    if (sep < 0)
+        return key;
+    return `${specBasename}::${key.slice(sep + 2)}`;
+}
 function qualifySnapshotKey(specFile, key) {
     return `${path.basename(specFile)}::${key}`;
 }
@@ -1382,9 +1390,52 @@ function isAllowedCoverageSourceFile(file) {
     const lower = file.toLowerCase();
     return lower.endsWith(".ts") || lower.endsWith(".as");
 }
+// AssemblyScript normalizes node_modules/<pkg>/... to ~lib/<pkg>/... in Source.normalizedPath.
+// This set contains the root names that are actual AS stdlib modules, so we can distinguish
+// real stdlib (~lib/array.ts) from third-party packages (~lib/json-as/assembly/index.ts).
+const AS_STDLIB_ROOT_NAMES = new Set([
+    "array",
+    "arraybuffer",
+    "atomics",
+    "bindings",
+    "builtins",
+    "compat",
+    "console",
+    "crypto",
+    "dataview",
+    "date",
+    "diagnostics",
+    "error",
+    "function",
+    "iterator",
+    "map",
+    "math",
+    "memory",
+    "number",
+    "object",
+    "polyfills",
+    "process",
+    "reference",
+    "regexp",
+    "rt",
+    "set",
+    "shared",
+    "staticarray",
+    "string",
+    "symbol",
+    "table",
+    "typedarray",
+    "uri",
+    "util",
+    "vector",
+]);
 function isAssemblyScriptStdlibFile(file) {
-    if (file.startsWith("~lib/"))
-        return true;
+    if (file.startsWith("~lib/")) {
+        // Extract the first path segment after ~lib/ (strip any file extension)
+        const after = file.slice("~lib/".length);
+        const root = (after.split("/")[0] ?? "").replace(/\.[^.]+$/, "");
+        return AS_STDLIB_ROOT_NAMES.has(root);
+    }
     if (file.includes("/~lib/"))
         return true;
     if (file.startsWith("assemblyscript/std/"))
@@ -1402,6 +1453,21 @@ function classifyCoverageFile(file) {
 }
 function resolveCoverageDependencyPackage(file) {
     const normalized = file.replace(/\\/g, "/");
+    // AssemblyScript normalizes node_modules/<pkg>/... to ~lib/<pkg>/... at compile time.
+    // Handle that path format so coverage.mode and coverage.dependencies work at runtime.
+    if (normalized.startsWith("~lib/")) {
+        const after = normalized.slice("~lib/".length);
+        const segments = after.split("/").filter(Boolean);
+        if (!segments.length)
+            return null;
+        if (segments[0].startsWith("@")) {
+            if (segments.length < 2)
+                return null;
+            return `${segments[0]}/${segments[1]}`;
+        }
+        // Strip file extension for bare module entries like ~lib/json-as.ts (unusual but safe)
+        return segments[0].replace(/\.[^.]+$/, "") || null;
+    }
     const marker = "/node_modules/";
     const prefixed = normalized.startsWith("node_modules/")
         ? `/${normalized}`

package/bin/util.js

@@ -946,15 +946,16 @@ function cloneCoverageOptions(coverage) {
     if (typeof coverage == "boolean")
         return coverage;
     const cloned = Object.assign(new CoverageOptions(), coverage);
+    const ignore = coverage.ignore ?? new CoverageIgnoreOptions();
     cloned.mode = coverage.mode ?? "project";
     cloned.dependencies = [...(coverage.dependencies ?? [])];
     cloned.include = [...(coverage.include ?? [])];
     cloned.exclude = [...(coverage.exclude ?? [])];
-    cloned.ignore = Object.assign(new CoverageIgnoreOptions(), coverage.ignore);
-    cloned.ignore.labels = [...(coverage.ignore.labels ?? [])];
-    cloned.ignore.names = [...(coverage.ignore.names ?? [])];
-    cloned.ignore.locations = [...(coverage.ignore.locations ?? [])];
-    cloned.ignore.snippets = [...(coverage.ignore.snippets ?? [])];
+    cloned.ignore = Object.assign(new CoverageIgnoreOptions(), ignore);
+    cloned.ignore.labels = [...(ignore.labels ?? [])];
+    cloned.ignore.names = [...(ignore.names ?? [])];
+    cloned.ignore.locations = [...(ignore.locations ?? [])];
+    cloned.ignore.snippets = [...(ignore.snippets ?? [])];
     return cloned;
 }
 function cloneBuildOptions(options) {
@@ -1293,8 +1294,8 @@ function appendPathSegment(basePath, segment) {
 }
 export function getCliVersion() {
     const candidates = [
-        join(process.cwd(), "package.json"),
         join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"),
+        join(process.cwd(), "package.json"),
     ];
     for (const pkgPath of candidates) {
         if (!existsSync(pkgPath))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",

package/transform/lib/coverage.js

@@ -2,6 +2,7 @@ import { BlockStatement, ExpressionStatement, Node, } from "assemblyscript/dist/
 import { RangeTransform } from "./range.js";
 import { isStdlib, SimpleParser } from "./util.js";
 import { Visitor } from "./visitor.js";
+import { NodeKind } from "./types.js";
 const COVERAGE_IGNORED_CALLS = new Set([
     "beforeAll",
     "afterAll",
@@ -114,7 +115,7 @@ export class CoverageTransform extends Visitor {
         const coverStmt = createCoverStatement(point.hash, node);
         replacer.visit(coverStmt);
         this.globalStatements.push(registerStmt);
-        if (node.kind == 31) {
+        if (node.kind == NodeKind.Block) {
             const block = node;
             block.statements.unshift(coverStmt);
             return block;
@@ -150,7 +151,7 @@ export class CoverageTransform extends Visitor {
             this.visit(node.expression, node);
             this.visit(node.typeArguments, node);
             for (const arg of node.args) {
-                if (arg.kind == 15)
+                if (arg.kind == NodeKind.Function)
                     continue;
                 this.visit(arg, node);
             }
@@ -278,7 +279,7 @@ export class CoverageTransform extends Visitor {
             const registerStmt = createRegisterStatement(point);
             replacer.visit(registerStmt);
             this.globalStatements.push(registerStmt);
-            if (node.body.kind === 36) {
+            if (node.body.kind === NodeKind.Export) {
                 const coverStmt = SimpleParser.parseStatement(`{
                 __COVER("${point.hash}")
                 return $$REPLACE_ME
@@ -327,14 +328,14 @@ export class CoverageTransform extends Visitor {
         const ifFalse = node.ifFalse;
         const path = node.range.source.normalizedPath;
         if (ifTrue &&
-            ifTrue.kind !== 31 &&
+            ifTrue.kind !== NodeKind.Block &&
             !isBuiltinStatement(ifTrue)) {
             node.ifTrue = this.instrumentStatementBody(path, ifTrue, "IfBranch");
             visitIfTrue = true;
             visitIfFalse = !!ifFalse;
         }
         if (ifFalse &&
-            ifFalse.kind !== 31 &&
+            ifFalse.kind !== NodeKind.Block &&
             !isBuiltinStatement(ifFalse)) {
             node.ifFalse = this.instrumentStatementBody(path, ifFalse, "IfBranch");
             visitIfTrue = true;
@@ -533,35 +534,35 @@ function getCallName(node) {
     return getExpressionName(node.expression);
 }
 function isBuiltinStatement(node) {
-    if (node.kind !== 39)
+    if (node.kind !== NodeKind.Expression)
         return false;
     return isBuiltinCallExpression(node.expression);
 }
 function isBuiltinCallExpression(node) {
     const unwrapped = unwrapParenthesized(node);
-    if (unwrapped.kind !== 10)
+    if (unwrapped.kind !== NodeKind.Call)
         return false;
     const call = unwrapped;
     const expression = unwrapParenthesized(call.expression);
-    if (expression.kind !== 7)
+    if (expression.kind !== NodeKind.Identifier)
         return false;
     const name = expression.text;
     return COVERAGE_IGNORED_BUILTINS.has(name);
 }
 function unwrapParenthesized(node) {
     let current = node;
-    while (current.kind === 21) {
+    while (current.kind === NodeKind.Parenthesized) {
         current = current.expression;
     }
     return current;
 }
 function getExpressionName(node) {
     switch (node.kind) {
-        case 7:
+        case NodeKind.Identifier:
             return node.text;
-        case 22:
+        case NodeKind.PropertyAccess:
             return node.property.text;
-        case 21:
+        case NodeKind.Parenthesized:
             return getExpressionName(node.expression);
         default:
             return null;

package/transform/lib/index.js

@@ -27,7 +27,9 @@ export default class Transformer extends Transform {
             }
         });
         const entrySource = sources.find((v) => v.sourceKind == 1);
-        const entryFile = entrySource ? entrySource.simplePath : "unknown";
+        const entryFile = entrySource
+            ? entrySource.normalizedPath.replace(/\.ts$/, "")
+            : "unknown";
         const mockedImportTargets = collectMockImportTargets(sources);
         for (const target of mockedImportTargets) {
             mock.importMocked.add(target);

package/transform/lib/types.js

@@ -1,3 +1,6 @@
+import * as asc from "assemblyscript/dist/assemblyscript.js";
+export const NodeKind = asc
+    .NodeKind;
 export var PropertyFlags;
 (function (PropertyFlags) {
     PropertyFlags[PropertyFlags["OmitNull"] = 0] = "OmitNull";

package/transform/lib/visitor.js

@@ -1,3 +1,4 @@
+import { NodeKind } from "./types.js";
 export class Visitor {
     currentSource = null;
     visit(node, ref = null) {
@@ -14,216 +15,218 @@ export class Visitor {
     }
     _visit(node, ref) {
         switch (node.kind) {
-            case 0:
+            case NodeKind.Source:
                 this.visitSource(node, ref);
                 break;
-            case 1:
+            case NodeKind.NamedType:
                 this.visitNamedTypeNode(node, ref);
                 break;
-            case 2:
+            case NodeKind.FunctionType:
                 this.visitFunctionTypeNode(node, ref);
                 break;
-            case 4:
+            case NodeKind.TupleType:
+                break;
+            case NodeKind.TypeName:
                 this.visitTypeName(node, ref);
                 break;
-            case 5:
+            case NodeKind.TypeParameter:
                 this.visitTypeParameter(node, ref);
                 break;
-            case 7:
+            case NodeKind.Identifier:
                 this.visitIdentifierExpression(node, ref);
                 break;
-            case 8:
+            case NodeKind.Assertion:
                 this.visitAssertionExpression(node, ref);
                 break;
-            case 9:
+            case NodeKind.Binary:
                 this.visitBinaryExpression(node, ref);
                 break;
-            case 10:
+            case NodeKind.Call:
                 this.visitCallExpression(node, ref);
                 break;
-            case 11:
+            case NodeKind.Class:
                 this.visitClassExpression(node, ref);
                 break;
-            case 12:
+            case NodeKind.Comma:
                 this.visitCommaExpression(node, ref);
                 break;
-            case 13:
+            case NodeKind.ElementAccess:
                 this.visitElementAccessExpression(node, ref);
                 break;
-            case 15:
+            case NodeKind.Function:
                 this.visitFunctionExpression(node, ref);
                 break;
-            case 16:
+            case NodeKind.InstanceOf:
                 this.visitInstanceOfExpression(node, ref);
                 break;
-            case 17:
+            case NodeKind.Literal:
                 this.visitLiteralExpression(node, ref);
                 break;
-            case 18:
+            case NodeKind.New:
                 this.visitNewExpression(node, ref);
                 break;
-            case 21:
+            case NodeKind.Parenthesized:
                 this.visitParenthesizedExpression(node, ref);
                 break;
-            case 22:
+            case NodeKind.PropertyAccess:
                 this.visitPropertyAccessExpression(node, ref);
                 break;
-            case 23:
+            case NodeKind.Ternary:
                 this.visitTernaryExpression(node, ref);
                 break;
-            case 28:
+            case NodeKind.UnaryPostfix:
                 this.visitUnaryPostfixExpression(node, ref);
                 break;
-            case 29:
+            case NodeKind.UnaryPrefix:
                 this.visitUnaryPrefixExpression(node, ref);
                 break;
-            case 31:
+            case NodeKind.Block:
                 this.visitBlockStatement(node, ref);
                 break;
-            case 32:
+            case NodeKind.Break:
                 this.visitBreakStatement(node, ref);
                 break;
-            case 33:
+            case NodeKind.Continue:
                 this.visitContinueStatement(node, ref);
                 break;
-            case 34:
+            case NodeKind.Do:
                 this.visitDoStatement(node, ref);
                 break;
-            case 35:
+            case NodeKind.Empty:
                 this.visitEmptyStatement(node, ref);
                 break;
-            case 36:
+            case NodeKind.Export:
                 this.visitExportStatement(node, ref);
                 break;
-            case 37:
+            case NodeKind.ExportDefault:
                 this.visitExportDefaultStatement(node, ref);
                 break;
-            case 38:
+            case NodeKind.ExportImport:
                 this.visitExportImportStatement(node, ref);
                 break;
-            case 39:
+            case NodeKind.Expression:
                 this.visitExpressionStatement(node, ref);
                 break;
-            case 40:
+            case NodeKind.For:
                 this.visitForStatement(node, ref);
                 break;
-            case 42:
+            case NodeKind.If:
                 this.visitIfStatement(node, ref);
                 break;
-            case 43:
+            case NodeKind.Import:
                 this.visitImportStatement(node, ref);
                 break;
-            case 44:
+            case NodeKind.Return:
                 this.visitReturnStatement(node, ref);
                 break;
-            case 45:
+            case NodeKind.Switch:
                 this.visitSwitchStatement(node, ref);
                 break;
-            case 46:
+            case NodeKind.Throw:
                 this.visitThrowStatement(node, ref);
                 break;
-            case 47:
+            case NodeKind.Try:
                 this.visitTryStatement(node, ref);
                 break;
-            case 48:
+            case NodeKind.Variable:
                 this.visitVariableStatement(node, ref);
                 break;
-            case 50:
+            case NodeKind.While:
                 this.visitWhileStatement(node, ref);
                 break;
-            case 52:
+            case NodeKind.ClassDeclaration:
                 this.visitClassDeclaration(node, false, ref);
                 break;
-            case 53:
+            case NodeKind.EnumDeclaration:
                 this.visitEnumDeclaration(node, false, ref);
                 break;
-            case 54:
+            case NodeKind.EnumValueDeclaration:
                 this.visitEnumValueDeclaration(node, ref);
                 break;
-            case 55:
+            case NodeKind.FieldDeclaration:
                 this.visitFieldDeclaration(node, ref);
                 break;
-            case 56:
+            case NodeKind.FunctionDeclaration:
                 this.visitFunctionDeclaration(node, false, ref);
                 break;
-            case 57:
+            case NodeKind.ImportDeclaration:
                 this.visitImportDeclaration(node, ref);
                 break;
-            case 58:
+            case NodeKind.InterfaceDeclaration:
                 this.visitInterfaceDeclaration(node, false, ref);
                 break;
-            case 59:
+            case NodeKind.MethodDeclaration:
                 this.visitMethodDeclaration(node, ref);
                 break;
-            case 60:
+            case NodeKind.NamespaceDeclaration:
                 this.visitNamespaceDeclaration(node, false, ref);
                 break;
-            case 61:
+            case NodeKind.TypeDeclaration:
                 this.visitTypeDeclaration(node, ref);
                 break;
-            case 62:
+            case NodeKind.VariableDeclaration:
                 this.visitVariableDeclaration(node, ref);
                 break;
-            case 63:
+            case NodeKind.Decorator:
                 this.visitDecoratorNode(node, ref);
                 break;
-            case 64:
+            case NodeKind.ExportMember:
                 this.visitExportMember(node, ref);
                 break;
-            case 65:
+            case NodeKind.SwitchCase:
                 this.visitSwitchCase(node, ref);
                 break;
-            case 66:
+            case NodeKind.IndexSignature:
                 this.visitIndexSignature(node, ref);
                 break;
-            case 19:
+            case NodeKind.Null:
                 this.visitNullExpression(node, ref);
                 break;
-            case 26: {
+            case NodeKind.True: {
                 this.visitTrueExpression(node, ref);
                 break;
             }
-            case 14: {
+            case NodeKind.False: {
                 this.visitFalseExpression(node, ref);
                 break;
             }
-            case 30: {
+            case NodeKind.Compiled: {
                 this.visitCompiledExpression(node, ref);
                 break;
             }
-            case 27: {
+            case NodeKind.Constructor: {
                 this.visitConstructorExpression(node, ref);
                 break;
             }
-            case 67: {
+            case NodeKind.Comment: {
                 this.visitComment(node, ref);
                 break;
             }
-            case 41: {
+            case NodeKind.ForOf: {
                 this.visitForOfStatement(node, ref);
                 break;
             }
-            case 51: {
+            case NodeKind.Module: {
                 this.visitModuleDeclaration(node, ref);
                 break;
             }
-            case 20: {
+            case NodeKind.Omitted: {
                 this.visitOmittedExpression(node, ref);
                 break;
             }
-            case 6: {
+            case NodeKind.Parameter: {
                 this.visitParameter(node, ref);
                 break;
             }
-            case 24: {
+            case NodeKind.Super: {
                 this.visitSuperExpression(node, ref);
                 break;
             }
-            case 25: {
+            case NodeKind.This: {
                 this.visitThisExpression(node, ref);
                 break;
             }
-            case 49: {
+            case NodeKind.Void: {
                 this.visitVoidStatement(node, ref);
                 break;
             }