as-test 1.1.3 → 1.1.5

package/CHANGELOG.md

@@ -1,19 +1,37 @@
 # Change Log
 
-## 2026-05-13 - v1.1.2
+## 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.
+
+## 2026-05-13 - v1.1.3
+
+### Coverage
 
-- update build and run faliures to provide helpful error messages and reproduction commands and instructions
-- remove confirmation from ast clean
 - feat: make coverage gaps hierarchical and easier to scan, with parent-before-child grouping, tree-style connectors, collapsed nested gaps by default, and `--show-coverage=all` / `--verbose` expansion.
 - feat: add richer coverage point names including `DefaultValue`, `Ternary`, `IfBranch`, `Assignment`, `Loop`, `Return`, and `Throw` so uncovered points describe the actual construct instead of falling back to broad labels.
 - fix: make coverage snippets underline the emitted construct span instead of recomputing from the raw column, so cases like inline `if (...) ...` and assignments highlight the right text.
 
-## 2026-05-12 -v1.1.1
+## 2026-05-13 - v1.1.2
+
+### Reporting & CLI
+
+- fix: update build and run failures to provide clearer error messages plus reproduction commands and instructions.
+- fix: remove the confirmation prompt from `ast clean`.
+
+## 2026-05-12 - v1.1.1
 
 - add `ast clean` command to remove build outputs, coverage outputs, crash reports, and logs.
 - remove deps
 
-## 2026-05-12 -v1.1.0
+## 2026-05-12 - v1.1.0
 
 ### Upgrading to 1.1.0
 
@@ -81,7 +99,7 @@
 - feat: make integer `FuzzSeed` helpers default to the full range of their target type when no options are provided, instead of collapsing to `0`.
 - perf: add unchecked full-range fast paths for default integer seed generation while keeping explicit user-provided ranges validated.
 
-## 2025-05-03 - v1.0.13
+## 2026-05-03 - v1.0.13
 
 - feat: add `--fuzzer` / `--fuzzers` filtering for `ast fuzz` and `ast test --fuzz`, accept `--suite` / `--suites` as fuzz aliases, and include target-specific repro commands in fuzz failure output.
 - feat: add `--suite` / `--suites` filtering for `ast run` and `ast test`, and print suite-specific repro commands on failing test assertions.

package/README.md

@@ -16,12 +16,13 @@
 - [Why as-test](#why-as-test)
 - [Installation](#installation)
 - [Docs](#docs)
-- [Project Layout](#project-layout)
 - [Writing Tests](#writing-tests)
 - [Mocking](#mocking)
 - [Snapshots](#snapshots)
-- [Fuzzing](#fuzzing)
 - [Runtimes](#runtimes)
+- [Modes](#modes)
+- [Coverage](#coverage)
+- [Fuzzing](#fuzzing)
 - [Examples](#examples)
 - [License](#license)
 
@@ -33,15 +34,6 @@ Most AssemblyScript testing tools are tied to a single runtime, usually Node.js.
 If you deploy to WASI, Wazero, or a custom runtime, you often end up mocking everything and maintaining parallel logic just for tests.
 as-test solves this by letting you run tests on your actual target runtime, while only mocking what’s necessary.
 
-Key benefits
-
-- Runtime-agnostic: test on WASI, bindings, or custom runners
-- Minimal mocking: keep real imports when possible
-- Production-like testing: catch runtime-specific issues early
-- Inline mocking and snapshots
-- Custom reporters and coverage
-- Integrated fuzzing support
-
 ## Installation
 
 The easiest way to start is with the project initializer:
@@ -64,50 +56,6 @@ Full documentation lives at:
 
 <https://docs.jairus.dev/as-test>
 
-## Project Layout
-
-By default, `as-test` looks for:
-
-- tests in `assembly/__tests__`
-- fuzzers in `assembly/__fuzz__`
-- config in `as-test.config.json`
-
-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"
-    }
-  }
-}
-```
-
-Coverage point filtering is configurable when you want to ignore known-noisy gaps:
-
-```json
-{
-  "coverage": {
-    "enabled": true,
-    "include": ["assembly/src/**/*.ts"],
-    "ignore": {
-      "labels": ["Call"],
-      "names": ["panic", "serialize"],
-      "locations": ["assembly/src/fuzz.ts:38:*"],
-      "snippets": ["*message: string*"]
-    }
-  }
-}
-```
-
 ## Writing Tests
 
 Tests usually live in `assembly/__tests__/*.spec.ts`.
@@ -119,7 +67,7 @@ import { describe, expect, test } from "as-test";
 
 describe("math", () => {
   test("adds numbers", () => {
-    expect(1 + 2).toBe(3);
+    expect(1 + 2).toBe(3, "should add two numbers");
   });
 });
 ```
@@ -145,8 +93,8 @@ npx ast test math
 Re-run one suite inside a matching file:
 
 ```bash
-npx ast run math --suite array-check
-npx ast run math --suite array-manipulation/array-check
+npx ast run math --suite math
+npx ast run math --suite math/adds-numbers
 ```
 
 You do not need to learn every CLI flag to get started. Most projects can begin with `npx ast test`, then add more configuration only when they need it.
@@ -232,96 +180,6 @@ If an existing snapshot legitimately changed, overwrite it with:
 npx ast test --overwrite-snapshots
 ```
 
-## Fuzzing
-
-Fuzzers usually live in `assembly/__fuzz__/*.fuzz.ts`.
-
-Example:
-
-```ts
-import { expect, FuzzSeed, fuzz } from "as-test";
-
-fuzz("bounded integer addition", (left: i32, right: i32): bool => {
-  const sum = left + right;
-  expect(sum - right).toBe(left);
-  return sum >= i32.MIN_VALUE;
-}).generate((seed: FuzzSeed, run: (left: i32, right: i32) => bool): void => {
-  run(seed.i32({ min: -1000, max: 1000 }), seed.i32({ min: -1000, max: 1000 }));
-});
-```
-
-Pass a third argument to override the operation count for one target without changing the global fuzz config:
-
-```ts
-fuzz(
-  "hot path stays stable",
-  (): void => {
-    expect(1 + 1).toBe(2);
-  },
-  250,
-);
-```
-
-Or pass it as the second argument to `.generate(...)`:
-
-```ts
-fuzz(
-  "ascii strings survive concatenation boundaries",
-  (input: string): bool => {
-    expect(input.length <= 40).toBe(true);
-    return true;
-  },
-).generate((seed: FuzzSeed, run: (input: string) => bool): void => {
-  run(seed.string({ charset: "ascii", min: 0, max: 40 }));
-}, 250);
-```
-
-You can still override fuzz runs from the CLI when you want to force a different count for the current command:
-
-```bash
-npx ast fuzz --runs 500
-npx ast fuzz --runs 1.5x
-npx ast fuzz --runs +10%
-npx ast fuzz --runs +100000
-```
-
-If you used `npx ast init` with a fuzzer example, the config is already there. Otherwise, add a `fuzz` block to `as-test.config.json` so `npx ast fuzz` knows what to build:
-
-```json
-{
-  "fuzz": {
-    "input": ["./assembly/__fuzz__/*.fuzz.ts"],
-    "target": "bindings"
-  }
-}
-```
-
-`ast fuzz` runs fuzz files across the selected modes, reports one result per file, and keeps the final summary separate from the normal test totals. If you want one combined command, use `ast test --fuzz`.
-
-By default, each fuzz run campaign picks a new random base seed. Pin a seed with `--seed <n>` (or `--fuzz-seed <n>` on `ast test`) when you want deterministic replay.
-
-When a fuzzer fails, `as-test` now prints the exact failing seeds and one-run repro commands such as `ast fuzz ... --seed <seed+n> --runs 1`. Crash records in `.as-test/crashes` also include the captured inputs passed to `run(...)`, which helps when the generator itself has side effects.
-
-Run only fuzzers:
-
-```bash
-npx ast fuzz
-```
-
-Run one matching fuzz target:
-
-```bash
-npx ast fuzz string --fuzzer ascii-strings-survive-concatenation-boundaries
-```
-
-Run tests and fuzzers together:
-
-```bash
-npx ast test --fuzz
-```
-
-Fuzzing is there when you want broader input coverage, but it does not get in the way of the normal test flow. You can start with ordinary specs and add fuzzers later.
-
 ## Runtimes
 
 One of the main reasons to use `as-test` is that you are not locked into a single runtime.
@@ -350,7 +208,13 @@ Then run your tests normally:
 npx ast test
 ```
 
-If you want to keep more than one runtime around, use modes:
+If you want to keep a single runtime, one config is enough. If you want to fan out across multiple runtimes, use modes.
+
+## Modes
+
+Modes let one project keep more than one runtime or build target available at the same time.
+
+For example:
 
 ```json
 {
@@ -389,8 +253,12 @@ Set `"default": false` on a mode when you want to keep it available for explicit
   "modes": {
     "web": {
       "default": false,
+      "buildOptions": {
+        "target": "web"
+      },
       "runOptions": {
         "runtime": {
+          "cmd": "node ./.as-test/runners/default.web.js",
           "browser": "chromium"
         }
       }
@@ -423,8 +291,12 @@ Modes can also be full config objects. That means a mode can override fuzzing, i
         "input": ["./assembly/__fuzz__/web/*.fuzz.ts"],
         "runs": 200
       },
+      "buildOptions": {
+        "target": "web"
+      },
       "runOptions": {
         "runtime": {
+          "cmd": "node ./.as-test/runners/default.web.js",
           "browser": "chromium"
         }
       }
@@ -455,6 +327,135 @@ or
 npx ast test --mode wasi,bindings
 ```
 
+## Coverage
+
+Coverage is opt-in.
+
+Enable it from the CLI:
+
+```bash
+npx ast test --enable coverage
+npx ast test --enable coverage --show-coverage
+npx ast test --enable coverage --show-coverage=all
+```
+
+Or from config:
+
+```json
+{
+  "coverage": {
+    "enabled": true,
+    "mode": "project",
+    "dependencies": ["json-as"],
+    "includeSpecs": false
+  }
+}
+```
+
+Coverage modes:
+
+- `project`
+  - covers project files only
+  - excludes dependency files by default
+- `all`
+  - covers project files and dependency files
+  - still excludes AssemblyScript stdlib files
+
+If you only want specific dependencies, keep `mode: "project"` and list package names in `dependencies`.
+That works for both normal installs and `pnpm` layouts.
+
+`--show-coverage` prints uncovered point details. `--show-coverage=all` and `--verbose` expand nested uncovered gaps instead of collapsing them.
+
+## Fuzzing
+
+Fuzzers usually live in `assembly/__fuzz__/*.fuzz.ts`.
+
+Example:
+
+```ts
+import { expect, FuzzSeed, fuzz } from "as-test";
+
+fuzz("bounded integer addition", (left: i32, right: i32): bool => {
+  const sum = left + right;
+  expect(sum - right).toBe(left);
+  return sum >= i32.MIN_VALUE;
+}).generate((seed: FuzzSeed, run: (left: i32, right: i32) => bool): void => {
+  run(seed.i32({ min: -1000, max: 1000 }), seed.i32({ min: -1000, max: 1000 }));
+});
+```
+
+Pass a third argument to override the operation count for one target without changing the global fuzz config:
+
+```ts
+fuzz(
+  "hot path stays stable",
+  (): void => {
+    expect(1 + 1).toBe(2);
+  },
+  250,
+);
+```
+
+Or pass it as the second argument to `.generate(...)`:
+
+```ts
+fuzz(
+  "ascii strings survive concatenation boundaries",
+  (input: string): bool => {
+    expect(input.length <= 40).toBe(true);
+    return true;
+  },
+).generate((seed: FuzzSeed, run: (input: string) => bool): void => {
+  run(seed.string({ charset: "ascii", min: 0, max: 40 }));
+}, 250);
+```
+
+You can still override fuzz runs from the CLI when you want to force a different count for the current command:
+
+```bash
+npx ast fuzz --runs 500
+npx ast fuzz --runs 1.5x
+npx ast fuzz --runs +10%
+npx ast fuzz --runs +100000
+```
+
+If you used `npx ast init` with a fuzzer example, the config is already there. Otherwise, add a `fuzz` block to `as-test.config.json` so `npx ast fuzz` knows what to build:
+
+```json
+{
+  "fuzz": {
+    "input": ["./assembly/__fuzz__/*.fuzz.ts"],
+    "target": "bindings"
+  }
+}
+```
+
+`ast fuzz` runs fuzz files across the selected modes, reports one result per file, and keeps the final summary separate from the normal test totals. If you want one combined command, use `ast test --fuzz`.
+
+By default, each fuzz run campaign picks a new random base seed. Pin a seed with `--seed <n>` (or `--fuzz-seed <n>` on `ast test`) when you want deterministic replay.
+
+When a fuzzer fails, `as-test` now prints the exact failing seeds and one-run repro commands such as `ast fuzz ... --seed <seed+n> --runs 1`. Crash records in `.as-test/crashes` also include the captured inputs passed to `run(...)`, which helps when the generator itself has side effects.
+
+Run only fuzzers:
+
+```bash
+npx ast fuzz
+```
+
+Run one matching fuzz target:
+
+```bash
+npx ast fuzz string --fuzzer ascii-strings-survive-concatenation-boundaries
+```
+
+Run tests and fuzzers together:
+
+```bash
+npx ast test --fuzz
+```
+
+Fuzzing is there when you want broader input coverage, but it does not get in the way of the normal test flow. You can start with ordinary specs and add fuzzers later.
+
 This is the general idea throughout the project: write tests once, then choose the runtime that matches how your code actually runs.
 
 ## Examples

package/as-test.config.schema.json

@@ -101,11 +101,25 @@
               "type": "boolean",
               "default": false
             },
+            "mode": {
+              "type": "string",
+              "enum": ["project", "all"],
+              "description": "Broad coverage eligibility. \"project\" covers project sources only. \"all\" also includes dependency sources.",
+              "default": "project"
+            },
             "includeSpecs": {
               "type": "boolean",
               "description": "Include *.spec.ts files in coverage collection.",
               "default": false
             },
+            "dependencies": {
+              "type": "array",
+              "description": "Package-name allowlist for dependency coverage, including pnpm-installed packages.",
+              "items": {
+                "type": "string"
+              },
+              "default": []
+            },
             "include": {
               "type": "array",
               "description": "Only include matching source files in coverage reports when this list is not empty.",
@@ -369,8 +383,18 @@
                       "enabled": {
                         "type": "boolean"
                       },
+                      "mode": {
+                        "type": "string",
+                        "enum": ["project", "all"]
+                      },
                       "includeSpecs": {
                         "type": "boolean"
+                      },
+                      "dependencies": {
+                        "type": "array",
+                        "items": {
+                          "type": "string"
+                        }
                       }
                     }
                   }

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}`;
 }
@@ -1313,12 +1321,18 @@ function isIgnoredCoverageFile(file, coverage) {
     const normalized = file.replace(/\\/g, "/");
     if (!isAllowedCoverageSourceFile(normalized))
         return true;
-    if (normalized.startsWith("node_modules/"))
-        return true;
-    if (normalized.includes("/node_modules/"))
-        return true;
     if (isAssemblyScriptStdlibFile(normalized))
         return true;
+    const classification = classifyCoverageFile(normalized);
+    if (classification.kind == "dependency") {
+        if (coverage.mode != "all" && !coverage.dependencies.length)
+            return true;
+        if (coverage.dependencies.length &&
+            (!classification.packageName ||
+                !coverage.dependencies.includes(classification.packageName))) {
+            return true;
+        }
+    }
     if (!coverage.includeSpecs && normalized.endsWith(".spec.ts"))
         return true;
     if (coverage.include.length &&
@@ -1376,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/"))
@@ -1387,11 +1444,57 @@ function isAssemblyScriptStdlibFile(file) {
         return true;
     return false;
 }
+function classifyCoverageFile(file) {
+    const packageName = resolveCoverageDependencyPackage(file);
+    if (packageName) {
+        return { kind: "dependency", packageName };
+    }
+    return { kind: "project", packageName: null };
+}
+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}`
+        : normalized;
+    const index = prefixed.lastIndexOf(marker);
+    if (index == -1)
+        return null;
+    const after = prefixed.slice(index + marker.length);
+    if (!after.length)
+        return null;
+    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]}`;
+    }
+    return segments[0];
+}
 function resolveCoverageOptions(raw) {
     if (typeof raw == "boolean") {
         return {
             enabled: raw,
+            mode: "project",
             includeSpecs: false,
+            dependencies: [],
             include: [],
             exclude: [],
             ignore: {
@@ -1409,7 +1512,11 @@ function resolveCoverageOptions(raw) {
             : null;
         return {
             enabled: obj.enabled == null ? false : Boolean(obj.enabled),
+            mode: obj.mode == "all" ? "all" : "project",
             includeSpecs: Boolean(obj.includeSpecs),
+            dependencies: Array.isArray(obj.dependencies)
+                ? obj.dependencies.filter((item) => typeof item == "string")
+                : [],
             include: Array.isArray(obj.include)
                 ? obj.include.filter((item) => typeof item == "string")
                 : [],
@@ -1434,7 +1541,9 @@ function resolveCoverageOptions(raw) {
     }
     return {
         enabled: false,
+        mode: "project",
         includeSpecs: false,
+        dependencies: [],
         include: [],
         exclude: [],
         ignore: {
@@ -2489,3 +2598,9 @@ function resolveReporterFactory(mod) {
     }
     throw new Error(`reporter module must export a factory as "createReporter" or default`);
 }
+export const __coverageInternals = {
+    classifyCoverageFile,
+    resolveCoverageDependencyPackage,
+    isIgnoredCoverageFile,
+    resolveCoverageOptions,
+};

package/bin/types.js

@@ -18,7 +18,9 @@ export class Config {
 export class CoverageOptions {
     constructor() {
         this.enabled = false;
+        this.mode = "project";
         this.includeSpecs = false;
+        this.dependencies = [];
         this.include = [];
         this.exclude = [];
         this.ignore = new CoverageIgnoreOptions();

package/bin/util.js

@@ -332,7 +332,7 @@ function validateCoverageValue(value, path, issues) {
         issues.push({
             path,
             message: "must be a boolean or object",
-            fix: 'use true/false or { "enabled": true, "includeSpecs": false, "include": ["assembly/**/*.ts"], "exclude": ["assembly/__tests__/**/*.spec.ts"] }',
+            fix: 'use true/false or { "enabled": true, "mode": "project", "includeSpecs": false, "dependencies": ["json-as"], "include": ["assembly/**/*.ts"], "exclude": ["assembly/__tests__/**/*.spec.ts"] }',
         });
         return;
     }
@@ -344,6 +344,22 @@ function validateCoverageValue(value, path, issues) {
             fix: "set to true or false",
         });
     }
+    if ("mode" in obj && obj.mode != undefined) {
+        if (typeof obj.mode != "string") {
+            issues.push({
+                path: `${path}.mode`,
+                message: 'must be "project" or "all"',
+                fix: 'set "mode" to "project" or "all"',
+            });
+        }
+        else if (obj.mode != "project" && obj.mode != "all") {
+            issues.push({
+                path: `${path}.mode`,
+                message: 'must be "project" or "all"',
+                fix: 'set "mode" to "project" or "all"',
+            });
+        }
+    }
     if ("includeSpecs" in obj && typeof obj.includeSpecs != "boolean") {
         issues.push({
             path: `${path}.includeSpecs`,
@@ -351,6 +367,7 @@ function validateCoverageValue(value, path, issues) {
             fix: "set to true or false",
         });
     }
+    validateStringArrayField(obj, "dependencies", path, issues);
     validateStringArrayField(obj, "include", path, issues);
     validateStringArrayField(obj, "exclude", path, issues);
     if ("ignore" in obj && obj.ignore != undefined) {
@@ -929,13 +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) {
@@ -1035,8 +1055,12 @@ function mergeCoverageConfig(base, override, raw) {
     const rawObject = raw;
     if ("enabled" in rawObject)
         mergedBase.enabled = overrideOptions.enabled;
+    if ("mode" in rawObject)
+        mergedBase.mode = overrideOptions.mode;
     if ("includeSpecs" in rawObject)
         mergedBase.includeSpecs = overrideOptions.includeSpecs;
+    if ("dependencies" in rawObject)
+        mergedBase.dependencies = [...overrideOptions.dependencies];
     if ("include" in rawObject)
         mergedBase.include = [...overrideOptions.include];
     if ("exclude" in rawObject)
@@ -1270,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.3",
+  "version": "1.1.5",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -94,7 +94,7 @@
     "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:integration && 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 test:integration"
+    "prepublishOnly": "npm run build:cli && npm run build:lib && npm run build:transform && npm run format && npm run test && npm run test:integration"
   },
   "type": "module"
 }

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);
             }
@@ -264,7 +265,7 @@ export class CoverageTransform extends Visitor {
             this.globalStatements.push(registerStmt);
         }
     }
-    visitFunctionDeclaration(node, isDefault) {
+    visitFunctionDeclaration(node) {
         if (node.visited)
             return;
         node.visited = true;
@@ -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;
             }