as-test 1.0.6 → 1.0.9

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Change Log
 
+## Unreleased
+
+## 2026-03-31 - v1.0.7
+
+### Coverage
+
+- feat: make CLI coverage output easier to scan with a summarized coverage block, per-file breakdown, grouped uncovered points, clickable `file:line:column` locations, trimmed source snippets, aligned gap columns, source-aware labels such as `Function`, `Method`, `Constructor`, `Property`, and `Call`, and coverage-point ignore rules for labels, names, locations, and snippets.
+
+### Fuzzing
+
+- feat: allow `fuzz(...)` and `xfuzz(...)` targets to override their own operation count with an optional third argument, so one file can mix short smoke fuzzers and heavier targets without changing the global `fuzz.runs` config.
+- feat: make `--runs` / `--fuzz-runs` accept absolute and relative overrides such as `500`, `1.5x`, `+10%`, and `+100000`, applying them to each fuzzer's effective run count for that command.
+
 ## 2026-03-31 - v1.0.6
 
 ### Fuzzing

package/README.md

@@ -83,6 +83,23 @@ Minimal `as-test.config.json`:
 }
 ```
 
+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`.
@@ -218,6 +235,34 @@ fuzz("bounded integer addition", (left: i32, right: i32): bool => {
 });
 ```
 
+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

package/as-test.config.schema.json

@@ -121,6 +121,45 @@
                 "type": "string"
               },
               "default": []
+            },
+            "ignore": {
+              "type": "object",
+              "description": "Ignore specific coverage points by derived label, symbol name, location, or source snippet.",
+              "additionalProperties": true,
+              "properties": {
+                "labels": {
+                  "type": "array",
+                  "description": "Ignore all points whose rendered label matches, such as Call, Method, Constructor, Property, or Function.",
+                  "items": {
+                    "type": "string"
+                  },
+                  "default": []
+                },
+                "names": {
+                  "type": "array",
+                  "description": "Ignore declarations or calls whose extracted symbol name matches a glob pattern.",
+                  "items": {
+                    "type": "string"
+                  },
+                  "default": []
+                },
+                "locations": {
+                  "type": "array",
+                  "description": "Ignore points whose file:line:column location matches a glob pattern.",
+                  "items": {
+                    "type": "string"
+                  },
+                  "default": []
+                },
+                "snippets": {
+                  "type": "array",
+                  "description": "Ignore points whose trimmed source snippet matches a glob pattern.",
+                  "items": {
+                    "type": "string"
+                  },
+                  "default": []
+                }
+              }
             }
           }
         }

package/assembly/__fuzz__/string.fuzz.ts

@@ -18,4 +18,4 @@ fuzz(
       exclude: [0x00, 0x0a, 0x0d],
     }),
   );
-});
+}, 250);

package/assembly/as-test.intellisense.d.ts

@@ -0,0 +1,60 @@
+export {};
+
+declare module "as-test" {
+  export interface IntellisenseIntegerOptions {
+    min?: number;
+    max?: number;
+    exclude?: number[];
+  }
+
+  export interface IntellisenseFloatOptions {
+    min?: number;
+    max?: number;
+    exclude?: number[];
+  }
+
+  export interface IntellisenseBytesOptions {
+    min?: number;
+    max?: number;
+    include?: number[];
+    exclude?: number[];
+  }
+
+  export interface IntellisenseStringOptions {
+    charset?:
+      | "ascii"
+      | "alpha"
+      | "alnum"
+      | "digit"
+      | "hex"
+      | "base64"
+      | "identifier"
+      | "whitespace"
+      | "custom";
+    min?: number;
+    max?: number;
+    include?: number[];
+    exclude?: number[];
+    prefix?: string;
+    suffix?: string;
+  }
+
+  export interface IntellisenseArrayOptions {
+    min?: number;
+    max?: number;
+  }
+
+  export interface FuzzSeed {
+    i32(options?: IntellisenseIntegerOptions): number;
+    u32(options?: IntellisenseIntegerOptions): number;
+    f32(options?: IntellisenseFloatOptions): number;
+    f64(options?: IntellisenseFloatOptions): number;
+    bytes(options?: IntellisenseBytesOptions): Uint8Array;
+    buffer(options?: IntellisenseBytesOptions): ArrayBuffer;
+    string(options?: IntellisenseStringOptions): string;
+    array<T>(
+      item: (seed: FuzzSeed) => T,
+      options?: IntellisenseArrayOptions,
+    ): Array<T>;
+  }
+}

package/assembly/index.ts

@@ -169,8 +169,9 @@ export function xit(description: string, callback: () => void): void {
 export function fuzz<T extends Function>(
   description: string,
   callback: T,
+  operations: i32 = 0,
 ): FuzzerBase {
-  const entry = createFuzzer(description, callback);
+  const entry = createFuzzer(description, callback, false, operations);
   entryFuzzers.push(entry);
   return entry;
 }
@@ -178,8 +179,9 @@ export function fuzz<T extends Function>(
 export function xfuzz<T extends Function>(
   description: string,
   callback: T,
+  operations: i32 = 0,
 ): FuzzerBase {
-  const entry = createFuzzer(description, callback, true);
+  const entry = createFuzzer(description, callback, true, operations);
   entryFuzzers.push(entry);
   return entry;
 }
@@ -421,6 +423,8 @@ function containsOnlySuites(values: Suite[]): bool {
 class FuzzConfig {
   runs: i32 = 1000;
   seed: u64 = 1337;
+  runsOverrideKind: i32 = 0;
+  runsOverrideValue: f64 = 0.0;
 }
 
 class FuzzReport {
@@ -444,7 +448,10 @@ function runFuzzers(): void {
   for (let i = 0; i < entryFuzzers.length; i++) {
     const fuzzer = unchecked(entryFuzzers[i]);
     prepareFuzzIteration();
-    const result = fuzzer.run(config.seed, config.runs);
+    const result = fuzzer.run(
+      config.seed,
+      resolveFuzzerRuns(fuzzer, config),
+    );
     report.fuzzers.push(result);
   }
   sendReport(report.serialize());
@@ -455,9 +462,31 @@ function requestFuzzConfig(): FuzzConfig {
   const reply = requestHostFuzzConfig();
   out.runs = reply.runs;
   out.seed = reply.seed;
+  out.runsOverrideKind = reply.runsOverrideKind;
+  out.runsOverrideValue = reply.runsOverrideValue;
   return out;
 }
 
+function resolveFuzzerRuns(fuzzer: FuzzerBase, config: FuzzConfig): i32 {
+  const baseRuns = fuzzer.runsOr(config.runs);
+  const resolved = applyFuzzRunsOverride(
+    baseRuns,
+    config.runsOverrideKind,
+    config.runsOverrideValue,
+  );
+  return resolved > 0 ? resolved : 1;
+}
+
+function applyFuzzRunsOverride(baseRuns: i32, kind: i32, value: f64): i32 {
+  if (kind == 1) return <i32>value;
+  if (kind == 2) return <i32>Math.round(<f64>baseRuns * value);
+  if (kind == 3) return baseRuns + <i32>value;
+  if (kind == 4) {
+    return baseRuns + <i32>Math.round((<f64>baseRuns * value) / 100.0);
+  }
+  return baseRuns;
+}
+
 function registerSuite(
   description: string,
   callback: () => void,

package/assembly/src/fuzz.ts

@@ -186,15 +186,22 @@ export class FuzzSeed {
 export abstract class FuzzerBase {
   public name: string;
   public skipped: bool;
-  constructor(name: string, skipped: bool = false) {
+  public operations: i32;
+  constructor(name: string, skipped: bool = false, operations: i32 = 0) {
     this.name = name;
     this.skipped = skipped;
+    this.operations = operations > 0 ? operations : 0;
   }
 
-  generate<T extends Function>(_generator: T): this {
+  generate<T extends Function>(_generator: T, operations: i32 = 0): this {
+    if (operations > 0) this.operations = operations;
     return this;
   }
 
+  runsOr(defaultRuns: i32): i32 {
+    return this.operations > 0 ? this.operations : defaultRuns;
+  }
+
   abstract run(seed: u64, runs: i32): FuzzerResult;
 }
 
@@ -377,19 +384,25 @@ export class Fuzzer0<R> extends FuzzerBase {
     name: string,
     private callback: () => R,
     skipped: bool = false,
+    operations: i32 = 0,
   ) {
-    super(name, skipped);
+    super(name, skipped, operations);
     this.returnsBool = !isVoid<R>();
   }
 
-  generate<T extends Function>(generator: T): this {
+  generate<T extends Function>(generator: T, operations: i32 = 0): this {
     this.generator =
       changetype<(seed: FuzzSeed, run: () => R) => void>(generator);
+    if (operations > 0) this.operations = operations;
     return this;
   }
 
-  generateTyped(generator: (seed: FuzzSeed, run: () => R) => void): this {
+  generateTyped(
+    generator: (seed: FuzzSeed, run: () => R) => void,
+    operations: i32 = 0,
+  ): this {
     this.generator = generator;
+    if (operations > 0) this.operations = operations;
     return this;
   }
 
@@ -431,19 +444,25 @@ export class Fuzzer1<A, R> extends FuzzerBase {
     name: string,
     private callback: (a: A) => R,
     skipped: bool = false,
+    operations: i32 = 0,
   ) {
-    super(name, skipped);
+    super(name, skipped, operations);
     this.returnsBool = !isVoid<R>();
   }
 
-  generate<T extends Function>(generator: T): this {
+  generate<T extends Function>(generator: T, operations: i32 = 0): this {
     this.generator =
       changetype<(seed: FuzzSeed, run: (a: A) => R) => void>(generator);
+    if (operations > 0) this.operations = operations;
     return this;
   }
 
-  generateTyped(generator: (seed: FuzzSeed, run: (a: A) => R) => void): this {
+  generateTyped(
+    generator: (seed: FuzzSeed, run: (a: A) => R) => void,
+    operations: i32 = 0,
+  ): this {
     this.generator = generator;
+    if (operations > 0) this.operations = operations;
     return this;
   }
 
@@ -494,21 +513,25 @@ export class Fuzzer2<A, B, R> extends FuzzerBase {
     name: string,
     private callback: (a: A, b: B) => R,
     skipped: bool = false,
+    operations: i32 = 0,
   ) {
-    super(name, skipped);
+    super(name, skipped, operations);
     this.returnsBool = !isVoid<R>();
   }
 
-  generate<T extends Function>(generator: T): this {
+  generate<T extends Function>(generator: T, operations: i32 = 0): this {
     this.generator =
       changetype<(seed: FuzzSeed, run: (a: A, b: B) => R) => void>(generator);
+    if (operations > 0) this.operations = operations;
     return this;
   }
 
   generateTyped(
     generator: (seed: FuzzSeed, run: (a: A, b: B) => R) => void,
+    operations: i32 = 0,
   ): this {
     this.generator = generator;
+    if (operations > 0) this.operations = operations;
     return this;
   }
 
@@ -559,20 +582,24 @@ export class Fuzzer3<A, B, C, R> extends FuzzerBase {
     name: string,
     private callback: (a: A, b: B, c: C) => R,
     skipped: bool = false,
+    operations: i32 = 0,
   ) {
-    super(name, skipped);
+    super(name, skipped, operations);
     this.returnsBool = !isVoid<R>();
   }
 
-  generate<T extends Function>(generator: T): this {
+  generate<T extends Function>(generator: T, operations: i32 = 0): this {
     this.generator = changetype<usize>(generator);
+    if (operations > 0) this.operations = operations;
     return this;
   }
 
   generateTyped(
     generator: (seed: FuzzSeed, run: (a: A, b: B, c: C) => R) => void,
+    operations: i32 = 0,
   ): this {
     this.generator = changetype<usize>(generator);
+    if (operations > 0) this.operations = operations;
     return this;
   }
 
@@ -629,16 +656,23 @@ export function createFuzzer<T extends Function>(
   name: string,
   callback: T,
   skipped: bool = false,
+  operations: i32 = 0,
 ): FuzzerBase {
   const length = callback.length;
   if (length == 0) {
-    return new Fuzzer0<usize>(name, changetype<() => usize>(callback), skipped);
+    return new Fuzzer0<usize>(
+      name,
+      changetype<() => usize>(callback),
+      skipped,
+      operations,
+    );
   }
   if (length == 1) {
     return new Fuzzer1<usize, usize>(
       name,
       changetype<(a: usize) => usize>(callback),
       skipped,
+      operations,
     );
   }
   if (length == 2) {
@@ -646,6 +680,7 @@ export function createFuzzer<T extends Function>(
       name,
       changetype<(a: usize, b: usize) => usize>(callback),
       skipped,
+      operations,
     );
   }
   if (length == 3) {
@@ -653,10 +688,16 @@ export function createFuzzer<T extends Function>(
       name,
       changetype<(a: usize, b: usize, c: usize) => usize>(callback),
       skipped,
+      operations,
     );
   }
   panic();
-  return new Fuzzer0<usize>(name, changetype<() => usize>(callback), skipped);
+  return new Fuzzer0<usize>(
+    name,
+    changetype<() => usize>(callback),
+    skipped,
+    operations,
+  );
 }
 
 function buildAlphabet(options: StringOptions): i32[] {

package/assembly/util/wipc.ts

@@ -52,6 +52,8 @@ export class SnapshotReply {
 export class FuzzConfigReply {
   public runs: i32 = 1000;
   public seed: u64 = 1337;
+  public runsOverrideKind: i32 = 0;
+  public runsOverrideValue: f64 = 0.0;
 }
 
 export function sendAssertionFailure(
@@ -141,13 +143,21 @@ export function requestFuzzConfig(): FuzzConfigReply {
   if (!body.length) {
     return new FuzzConfigReply();
   }
-  const sep = body.indexOf("\n");
-  if (sep < 0) return new FuzzConfigReply();
+  const first = body.indexOf("\n");
+  if (first < 0) return new FuzzConfigReply();
   const reply = new FuzzConfigReply();
-  const runs = body.slice(0, sep);
-  const seed = body.slice(sep + 1);
+  const second = body.indexOf("\n", first + 1);
+  const third = second >= 0 ? body.indexOf("\n", second + 1) : -1;
+  const runs = body.slice(0, first);
+  const seed =
+    second >= 0 ? body.slice(first + 1, second) : body.slice(first + 1);
+  const kind =
+    second >= 0 && third >= 0 ? body.slice(second + 1, third) : "";
+  const value = third >= 0 ? body.slice(third + 1) : "";
   if (runs.length) reply.runs = I32.parseInt(runs);
   if (seed.length) reply.seed = U64.parseInt(seed);
+  if (kind.length) reply.runsOverrideKind = I32.parseInt(kind);
+  if (value.length) reply.runsOverrideValue = parseFloat(value);
   return reply;
 }
 

package/bin/commands/fuzz-core.js

@@ -29,12 +29,39 @@ export async function fuzz(configPath = DEFAULT_CONFIG_PATH, selectors = [], mod
     return results;
 }
 function resolveFuzzConfig(raw, overrides) {
-    const config = Object.assign({}, raw, overrides);
+    const config = Object.assign({}, raw);
+    if (typeof overrides.seed == "number") {
+        config.seed = overrides.seed;
+    }
+    if (typeof overrides.runs == "number") {
+        config.runs = overrides.runs;
+    }
+    config.runsOverrideKind = 0;
+    config.runsOverrideValue = 0;
+    if (overrides.runsOverride) {
+        config.runsOverrideKind = encodeRunsOverrideKind(overrides.runsOverride.kind);
+        config.runsOverrideValue = overrides.runsOverride.value;
+        if (overrides.runsOverride.kind == "set") {
+            config.runs = Math.max(1, Math.round(overrides.runsOverride.value));
+        }
+    }
     if (config.target != "bindings") {
         throw new Error(`fuzz target must be "bindings"; received "${config.target}"`);
     }
     return config;
 }
+function encodeRunsOverrideKind(kind) {
+    switch (kind) {
+        case "set":
+            return 1;
+        case "scale":
+            return 2;
+        case "add":
+            return 3;
+        case "percent-add":
+            return 4;
+    }
+}
 async function runFuzzTarget(file, outDir, duplicateBasenames, config, buildStartedAt, buildFinishedAt, buildTime, modeName) {
     const startedAt = Date.now();
     const artifact = resolveArtifactFileName(file, duplicateBasenames, modeName);
@@ -48,7 +75,8 @@ async function runFuzzTarget(file, outDir, duplicateBasenames, config, buildStar
         if (type == 0x02) {
             const event = JSON.parse(payload.toString("utf8"));
             if (String(event.kind ?? "") == "fuzz:config") {
-                respond(`${config.runs}\n${config.seed}`);
+                const resolved = config;
+                respond(`${config.runs}\n${config.seed}\n${resolved.runsOverrideKind ?? 0}\n${resolved.runsOverrideValue ?? 0}`);
             }
             else {
                 respond("");