as-test 1.1.2 → 1.1.4

package/CHANGELOG.md

@@ -1,16 +1,30 @@
 # Change Log
 
+## 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
+
+- 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-13 - v1.1.2
 
-- update build and run faliures to provide helpful error messages and reproduction commands and instructions
-- remove confirmation from ast clean
+### 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
+## 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
 
@@ -78,7 +92,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/assembly/coverage.ts

@@ -4,6 +4,10 @@ export class CoverPoint {
   public line: i32 = 0;
   public column: i32 = 0;
   public type: string = "";
+  public parentHash: string = "";
+  public scopeKind: string = "";
+  public scopeName: string = "";
+  public depth: i32 = 0;
   public executed: boolean = false;
 }
 
@@ -29,6 +33,10 @@ export function __REGISTER_RAW(
   line: i32,
   column: i32,
   type: string,
+  parentHash: string = "",
+  scopeKind: string = "",
+  scopeName: string = "",
+  depth: i32 = 0,
 ): void {
   if (Coverage.SN.allIndex.has(hash)) return;
   const point = new CoverPoint();
@@ -37,6 +45,10 @@ export function __REGISTER_RAW(
   point.line = line;
   point.column = column;
   point.type = type;
+  point.parentHash = parentHash;
+  point.scopeKind = scopeKind;
+  point.scopeName = scopeName;
+  point.depth = depth;
   Coverage.SN.points++;
   Coverage.SN.allIndex.set(hash, Coverage.SN.all.length);
   Coverage.SN.all.push(point);

package/assembly/index.ts

@@ -548,6 +548,10 @@ class CoveragePointReport {
   column: i32 = 0;
   type: string = "";
   executed: bool = false;
+  parentHash: string = "";
+  scopeKind: string = "";
+  scopeName: string = "";
+  depth: i32 = 0;
 
   serialize(): string {
     return (
@@ -563,6 +567,14 @@ class CoveragePointReport {
       quote(this.type) +
       ',"executed":' +
       (this.executed ? "true" : "false") +
+      ',"parentHash":' +
+      quote(this.parentHash) +
+      ',"scopeKind":' +
+      quote(this.scopeKind) +
+      ',"scopeName":' +
+      quote(this.scopeName) +
+      ',"depth":' +
+      this.depth.toString() +
       "}"
     );
   }
@@ -632,6 +644,10 @@ function toCoveragePointReport(point: CoverPoint): CoveragePointReport {
   out.column = point.column;
   out.type = point.type;
   out.executed = point.executed;
+  out.parentHash = point.parentHash;
+  out.scopeKind = point.scopeKind;
+  out.scopeName = point.scopeName;
+  out.depth = point.depth;
   return out;
 }
 

package/assembly/src/suite.ts

@@ -131,6 +131,8 @@ export class Suite {
       this.verdict = "ok";
     } else if (hasSkip) {
       this.verdict = "skip";
+    } else if (isTestCase) {
+      this.verdict = "ok";
     } else {
       this.verdict = "none";
     }

package/assembly/test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from "as-test";
+// Import JSON and bs directly from json-as.
+// bs import prevents json-as transform from adding broken pnpm paths.
+import { JSON } from "json-as/assembly";
+
+
+@json
+class SimpleData {
+  name: string = "";
+  count: i32 = 0;
+}
+
+
+@json
+class NestedData {
+  id: string = "";
+  items: string[] = [];
+}
+
+describe("JSON", () => {
+  describe("stringify", () => {
+    it("should serialize a simple class", () => {
+      const data = new SimpleData();
+      data.name = "test";
+      data.count = 42;
+
+      const json = JSON.stringify(data);
+
+      expect(json).toBe('{"name":"test","count":42}');
+    });
+
+    it("should serialize a class with arrays", () => {
+      const data = new NestedData();
+      data.id = "abc123";
+      data.items = ["item1", "item2"];
+
+      const json = JSON.stringify(data);
+
+      expect(json).toBe('{"id":"abc123","items":["item1","item2"]}');
+    });
+
+    it("should serialize primitive types", () => {
+      expect(JSON.stringify<i32>(42)).toBe("42");
+      expect(JSON.stringify<bool>(true)).toBe("true");
+      expect(JSON.stringify<string>("hello")).toBe('"hello"');
+    });
+
+    it("should serialize arrays", () => {
+      const arr: i32[] = [1, 2, 3];
+      expect(JSON.stringify(arr)).toBe("[1,2,3]");
+    });
+  });
+
+  describe("parse", () => {
+    it("should deserialize a simple class", () => {
+      const json = '{"name":"test","count":42}';
+      const data = JSON.parse<SimpleData>(json);
+
+      expect(data.name).toBe("test");
+      expect(data.count).toBe(42);
+    });
+
+    it("should deserialize a class with arrays", () => {
+      const json = '{"id":"abc123","items":["item1","item2"]}';
+      const data = JSON.parse<NestedData>(json);
+
+      expect(data.id).toBe("abc123");
+      expect(data.items.length).toBe(2);
+      expect(data.items[0]).toBe("item1");
+      expect(data.items[1]).toBe("item2");
+    });
+
+    it("should round-trip data correctly", () => {
+      const original = new SimpleData();
+      original.name = "round-trip";
+      original.count = 123;
+
+      const json = JSON.stringify(original);
+      const restored = JSON.parse<SimpleData>(json);
+
+      expect(restored.name).toBe(original.name);
+      expect(restored.count).toBe(original.count);
+    });
+  });
+});