as-test 1.1.1 → 1.1.2

package/CHANGELOG.md

@@ -1,11 +1,16 @@
 # Change Log
 
-## v1.1.1
+## 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
+
+## 2026-05-12 -v1.1.1
 
 - add `ast clean` command to remove build outputs, coverage outputs, crash reports, and logs.
 - remove deps
 
-## v1.1.0
+## 2026-05-12 -v1.1.0
 
 ### Upgrading to 1.1.0
 
@@ -46,7 +51,7 @@
 
 - feat: add per-mode `default: boolean` selection so modes can be included in implicit runs or kept manual-only.
 - feat: add `ast clean` to remove configured build outputs, coverage outputs, crash reports, and logs.
-- feat: make `ast clean` remove everything by default, prompt with `[Y/n]` before a full clean, and allow `-f` / `--force` to skip that confirmation.
+- feat: make `ast clean` remove everything by default without prompting.
 - fix: restore unnamed root-config execution alongside named default modes when `--mode` is omitted.
 - fix: make `ast clean` ignore mode `default: false` flags and treat an omitted `--mode` as a full clean across every configured mode.
 - fix: make `ast clean --mode ...` stay scoped to the selected mode(s) and skip shared output paths that are still owned by unselected modes instead of deleting them.

package/README.md

@@ -253,18 +253,25 @@ 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);
+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 => {
+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);
 ```

package/as-test.config.schema.json

@@ -336,168 +336,190 @@
                   }
                 ]
               },
-          "outDir": {
-            "type": "string",
-            "description": "Mode-specific build output directory. If omitted, defaults to <outDir>/<mode-name>."
-          },
-          "logs": {
-            "type": "string",
-            "description": "Mode-specific log output directory."
-          },
-          "coverageDir": {
-            "type": "string",
-            "description": "Mode-specific coverage output directory."
-          },
-          "snapshotDir": {
-            "type": "string",
-            "description": "Mode-specific snapshot directory."
-          },
-          "config": {
-            "type": "string",
-            "description": "Mode-specific asconfig path or \"none\"."
-          },
-          "coverage": {
-            "description": "Mode-specific coverage settings.",
-            "oneOf": [
-              {
-                "type": "boolean"
-              },
-              {
-                "type": "object",
-                "additionalProperties": true,
-                "properties": {
-                  "enabled": {
-                    "type": "boolean"
-                  },
-                  "includeSpecs": {
-                    "type": "boolean"
-                  }
-                }
-              }
-            ]
-          },
-          "fuzz": {
-            "type": "object",
-            "additionalProperties": false,
-            "description": "Mode-specific fuzz overrides applied before running `ast fuzz` or `ast test --fuzz` in this mode.",
-            "properties": {
-              "input": {
-                "type": "array",
-                "items": {
-                  "type": "string"
-                }
-              },
-              "runs": {
-                "type": "number"
-              },
-              "seed": {
-                "type": "number"
-              },
-              "maxInputBytes": {
-                "type": "number"
-              },
-              "target": {
+              "outDir": {
                 "type": "string",
-                "enum": ["bindings"]
+                "description": "Mode-specific build output directory. If omitted, defaults to <outDir>/<mode-name>."
               },
-              "corpusDir": {
-                "type": "string"
+              "logs": {
+                "type": "string",
+                "description": "Mode-specific log output directory."
               },
-              "crashDir": {
-                "type": "string"
-              }
-            }
-          },
-          "buildOptions": {
-            "type": "object",
-            "additionalProperties": false,
-            "properties": {
-              "cmd": {
+              "coverageDir": {
                 "type": "string",
-                "description": "Mode-specific custom build command template."
+                "description": "Mode-specific coverage output directory."
               },
-              "args": {
-                "type": "array",
-                "items": {
-                  "type": "string"
-                }
+              "snapshotDir": {
+                "type": "string",
+                "description": "Mode-specific snapshot directory."
               },
-              "target": {
+              "config": {
                 "type": "string",
-                "enum": ["wasi", "bindings", "web"]
+                "description": "Mode-specific asconfig path or \"none\"."
               },
-              "env": {
-                "description": "Mode-specific build environment overrides.",
+              "coverage": {
+                "description": "Mode-specific coverage settings.",
                 "oneOf": [
                   {
-                    "type": "string"
+                    "type": "boolean"
                   },
                   {
+                    "type": "object",
+                    "additionalProperties": true,
+                    "properties": {
+                      "enabled": {
+                        "type": "boolean"
+                      },
+                      "includeSpecs": {
+                        "type": "boolean"
+                      }
+                    }
+                  }
+                ]
+              },
+              "fuzz": {
+                "type": "object",
+                "additionalProperties": false,
+                "description": "Mode-specific fuzz overrides applied before running `ast fuzz` or `ast test --fuzz` in this mode.",
+                "properties": {
+                  "input": {
                     "type": "array",
                     "items": {
                       "type": "string"
                     }
                   },
-                  {
-                    "type": "object",
-                    "additionalProperties": {
-                      "type": "string"
-                    }
+                  "runs": {
+                    "type": "number"
+                  },
+                  "seed": {
+                    "type": "number"
+                  },
+                  "maxInputBytes": {
+                    "type": "number"
+                  },
+                  "target": {
+                    "type": "string",
+                    "enum": ["bindings"]
+                  },
+                  "corpusDir": {
+                    "type": "string"
+                  },
+                  "crashDir": {
+                    "type": "string"
                   }
-                ]
-              }
-            }
-          },
-          "runOptions": {
-            "type": "object",
-            "additionalProperties": false,
-            "properties": {
-              "runtime": {
+                }
+              },
+              "buildOptions": {
                 "type": "object",
                 "additionalProperties": false,
                 "properties": {
                   "cmd": {
                     "type": "string",
-                    "description": "Mode-specific runtime command."
+                    "description": "Mode-specific custom build command template."
+                  },
+                  "args": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
                   },
-                  "browser": {
+                  "target": {
                     "type": "string",
-                    "description": "Mode-specific browser for web targets. Use chrome, chromium, firefox, webkit, or an executable path."
+                    "enum": ["wasi", "bindings", "web"]
+                  },
+                  "env": {
+                    "description": "Mode-specific build environment overrides.",
+                    "oneOf": [
+                      {
+                        "type": "string"
+                      },
+                      {
+                        "type": "array",
+                        "items": {
+                          "type": "string"
+                        }
+                      },
+                      {
+                        "type": "object",
+                        "additionalProperties": {
+                          "type": "string"
+                        }
+                      }
+                    ]
                   }
                 }
               },
-              "reporter": {
-                "description": "Mode-specific reporter config.",
-                "oneOf": [
-                  {
-                    "type": "string"
-                  },
-                  {
+              "runOptions": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "runtime": {
                     "type": "object",
                     "additionalProperties": false,
                     "properties": {
-                      "name": {
+                      "cmd": {
+                        "type": "string",
+                        "description": "Mode-specific runtime command."
+                      },
+                      "browser": {
+                        "type": "string",
+                        "description": "Mode-specific browser for web targets. Use chrome, chromium, firefox, webkit, or an executable path."
+                      }
+                    }
+                  },
+                  "reporter": {
+                    "description": "Mode-specific reporter config.",
+                    "oneOf": [
+                      {
                         "type": "string"
                       },
-                      "options": {
+                      {
+                        "type": "object",
+                        "additionalProperties": false,
+                        "properties": {
+                          "name": {
+                            "type": "string"
+                          },
+                          "options": {
+                            "type": "array",
+                            "items": {
+                              "type": "string"
+                            }
+                          },
+                          "outDir": {
+                            "type": "string"
+                          },
+                          "outFile": {
+                            "type": "string"
+                          }
+                        },
+                        "required": ["name"]
+                      }
+                    ]
+                  },
+                  "env": {
+                    "description": "Mode-specific runtime environment overrides.",
+                    "oneOf": [
+                      {
+                        "type": "string"
+                      },
+                      {
                         "type": "array",
                         "items": {
                           "type": "string"
                         }
                       },
-                      "outDir": {
-                        "type": "string"
-                      },
-                      "outFile": {
-                        "type": "string"
+                      {
+                        "type": "object",
+                        "additionalProperties": {
+                          "type": "string"
+                        }
                       }
-                    },
-                    "required": ["name"]
+                    ]
                   }
-                ]
+                }
               },
               "env": {
-                "description": "Mode-specific runtime environment overrides.",
+                "description": "Mode-wide environment variables merged before build/run-specific env.",
                 "oneOf": [
                   {
                     "type": "string"
@@ -517,28 +539,6 @@
                 ]
               }
             }
-          },
-          "env": {
-            "description": "Mode-wide environment variables merged before build/run-specific env.",
-            "oneOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "array",
-                "items": {
-                  "type": "string"
-                }
-              },
-              {
-                "type": "object",
-                "additionalProperties": {
-                  "type": "string"
-                }
-              }
-            ]
-          }
-            }
           }
         ]
       },

package/assembly/__fuzz__/math.fuzz.ts

@@ -8,21 +8,24 @@ fuzz("bounded integer addition", (left: i32, right: i32): bool => {
   run(seed.i32({ min: -1000, max: 1000 }), seed.i32({ min: -1000, max: 1000 }));
 });
 
-fuzz("numeric matchers stay consistent for bounded integers", (value: i32): bool => {
-  expect(value).toBeNumber();
-  expect(value).toBeInteger();
-  expect(value).toBeFinite();
-  expect(value).toBe(value);
-  expect(value).toBeGreaterOrEqualTo(-1000);
-  expect(value).toBeLessThanOrEqualTo(1000);
+fuzz(
+  "numeric matchers stay consistent for bounded integers",
+  (value: i32): bool => {
+    expect(value).toBeNumber();
+    expect(value).toBeInteger();
+    expect(value).toBeFinite();
+    expect(value).toBe(value);
+    expect(value).toBeGreaterOrEqualTo(-1000);
+    expect(value).toBeLessThanOrEqualTo(1000);
 
-  if (value != 0) {
-    expect(value).toBeTruthy();
-  } else {
-    expect(value).toBeFalsy();
-  }
+    if (value != 0) {
+      expect(value).toBeTruthy();
+    } else {
+      expect(value).toBeFalsy();
+    }
 
-  return true;
-}).generate((seed: FuzzSeed, run: (value: i32) => bool): void => {
+    return true;
+  },
+).generate((seed: FuzzSeed, run: (value: i32) => bool): void => {
   run(seed.i32({ min: -1000, max: 1000 }));
 }, 250);

package/assembly/__fuzz__/seed-perf.fuzz.ts

@@ -59,8 +59,10 @@ fuzz("seed perf bytes/array", (_n: i32): bool => true).generate(
     let score = 0;
     for (let i = 0; i < 64; i++) {
       score += seed.bytes(PERF_BYTES).length;
-      score += seed.array<i32>((s) => s.i32({ min: -9, max: 9 }), PERF_ARRAY)
-        .length;
+      score += seed.array<i32>(
+        (s) => s.i32({ min: -9, max: 9 }),
+        PERF_ARRAY,
+      ).length;
     }
     run(score);
   },

package/assembly/index.ts

@@ -445,10 +445,7 @@ function runFuzzers(): void {
   for (let i = 0; i < entryFuzzers.length; i++) {
     const fuzzer = unchecked(entryFuzzers[i]);
     prepareFuzzIteration();
-    const result = fuzzer.run(
-      config.seed,
-      resolveFuzzerRuns(fuzzer, config),
-    );
+    const result = fuzzer.run(config.seed, resolveFuzzerRuns(fuzzer, config));
     report.fuzzers.push(result);
   }
   sendReport(report.serialize());

package/assembly/src/expectation.ts

@@ -354,7 +354,13 @@ export class Expectation<T> extends Tests {
     // @ts-ignore
     const passed = this._left.indexOf(value) >= 0;
     // @ts-ignore
-    this._resolve(passed, "toMatch", q(this._left as string), q(value), message);
+    this._resolve(
+      passed,
+      "toMatch",
+      q(this._left as string),
+      q(value),
+      message,
+    );
   }
 
   /**

package/assembly/src/fuzz.ts

@@ -79,14 +79,24 @@ export class FuzzSeed {
 
   i8(options: IntegerOptions<i8> | null = null): i8 {
     if (options == null) {
-      return this.nextI8InRange(i8.MIN_VALUE, i8.MAX_VALUE, EMPTY_I8_EXCLUDE, false);
+      return this.nextI8InRange(
+        i8.MIN_VALUE,
+        i8.MAX_VALUE,
+        EMPTY_I8_EXCLUDE,
+        false,
+      );
     }
     return this.nextI8InRange(options.min, options.max, options.exclude, true);
   }
 
   u8(options: IntegerOptions<u8> | null = null): u8 {
     if (options == null) {
-      return this.nextU8InRange(u8.MIN_VALUE, u8.MAX_VALUE, EMPTY_U8_EXCLUDE, false);
+      return this.nextU8InRange(
+        u8.MIN_VALUE,
+        u8.MAX_VALUE,
+        EMPTY_U8_EXCLUDE,
+        false,
+      );
     }
     return this.nextU8InRange(options.min, options.max, options.exclude, true);
   }
@@ -186,7 +196,9 @@ export class FuzzSeed {
       if (!exclude.length) {
         for (let i = 0; i < length; i++) {
           unchecked(
-            (out[i] = <u8>unchecked(include[this.nextRange(0, include.length - 1)])),
+            (out[i] = <u8>(
+              unchecked(include[this.nextRange(0, include.length - 1)])
+            )),
           );
         }
         return out;
@@ -299,7 +311,9 @@ export class FuzzSeed {
       return <i32>this.nextU32();
     }
     if (!exclude.length) {
-      return max <= min ? min : min + <i32>(this.nextU32() % <u32>(max - min + 1));
+      return max <= min
+        ? min
+        : min + <i32>(this.nextU32() % <u32>(max - min + 1));
     }
     for (let attempts = 0; attempts < 1024; attempts++) {
       const value =
@@ -324,12 +338,16 @@ export class FuzzSeed {
     const right = <i32>max;
     if (!exclude.length) {
       return <i8>(
-        right <= left ? left : left + <i32>(this.nextU32() % <u32>(right - left + 1))
+        (right <= left
+          ? left
+          : left + <i32>(this.nextU32() % <u32>(right - left + 1)))
       );
     }
     for (let attempts = 0; attempts < 1024; attempts++) {
       const value = <i8>(
-        right <= left ? left : left + <i32>(this.nextU32() % <u32>(right - left + 1))
+        (right <= left
+          ? left
+          : left + <i32>(this.nextU32() % <u32>(right - left + 1)))
       );
       if (!containsValue<i8>(exclude, value)) return value;
     }
@@ -350,11 +368,13 @@ export class FuzzSeed {
     const left = <u32>min;
     const right = <u32>max;
     if (!exclude.length) {
-      return <u8>(right <= left ? left : left + (this.nextU32() % (right - left + 1)));
+      return <u8>(
+        (right <= left ? left : left + (this.nextU32() % (right - left + 1)))
+      );
     }
     for (let attempts = 0; attempts < 1024; attempts++) {
       const value = <u8>(
-        right <= left ? left : left + (this.nextU32() % (right - left + 1))
+        (right <= left ? left : left + (this.nextU32() % (right - left + 1)))
       );
       if (!containsValue<u8>(exclude, value)) return value;
     }
@@ -376,12 +396,16 @@ export class FuzzSeed {
     const right = <i32>max;
     if (!exclude.length) {
       return <i16>(
-        right <= left ? left : left + <i32>(this.nextU32() % <u32>(right - left + 1))
+        (right <= left
+          ? left
+          : left + <i32>(this.nextU32() % <u32>(right - left + 1)))
       );
     }
     for (let attempts = 0; attempts < 1024; attempts++) {
       const value = <i16>(
-        right <= left ? left : left + <i32>(this.nextU32() % <u32>(right - left + 1))
+        (right <= left
+          ? left
+          : left + <i32>(this.nextU32() % <u32>(right - left + 1)))
       );
       if (!containsValue<i16>(exclude, value)) return value;
     }
@@ -402,11 +426,13 @@ export class FuzzSeed {
     const left = <u32>min;
     const right = <u32>max;
     if (!exclude.length) {
-      return <u16>(right <= left ? left : left + (this.nextU32() % (right - left + 1)));
+      return <u16>(
+        (right <= left ? left : left + (this.nextU32() % (right - left + 1)))
+      );
     }
     for (let attempts = 0; attempts < 1024; attempts++) {
       const value = <u16>(
-        right <= left ? left : left + (this.nextU32() % (right - left + 1))
+        (right <= left ? left : left + (this.nextU32() % (right - left + 1)))
       );
       if (!containsValue<u16>(exclude, value)) return value;
     }
@@ -448,9 +474,7 @@ export class FuzzSeed {
     const left = this.toOrderedU64(min);
     const right = this.toOrderedU64(max);
     if (!exclude.length) {
-      return this.fromOrderedU64(
-        left + this.nextU64Offset(left, right),
-      );
+      return this.fromOrderedU64(left + this.nextU64Offset(left, right));
     }
     for (let attempts = 0; attempts < 1024; attempts++) {
       const value = this.fromOrderedU64(left + this.nextU64Offset(left, right));
@@ -529,7 +553,7 @@ export class FuzzSeed {
   }
 
   private toOrderedU64(value: i64): u64 {
-    return <u64>value ^ I64_SIGN_MASK;
+    return (<u64>value) ^ I64_SIGN_MASK;
   }
 
   private fromOrderedU64(value: u64): i64 {
@@ -543,13 +567,11 @@ const DIGIT_ALPHABET: i32[] = rangeChars(48, 57);
 const HEX_ALPHABET: i32[] = DIGIT_ALPHABET.concat(rangeChars(97, 102));
 const ALNUM_ALPHABET: i32[] = ALPHA_ALPHABET.concat(DIGIT_ALPHABET);
 const BASE64_ALPHABET: i32[] = ALPHA_ALPHABET.concat(DIGIT_ALPHABET).concat([
-  43,
-  47,
-  61,
+  43, 47, 61,
 ]);
-const IDENTIFIER_ALPHABET: i32[] = [95].concat(ALPHA_ALPHABET).concat(
-  DIGIT_ALPHABET,
-);
+const IDENTIFIER_ALPHABET: i32[] = [95]
+  .concat(ALPHA_ALPHABET)
+  .concat(DIGIT_ALPHABET);
 const WHITESPACE_ALPHABET: i32[] = [9, 10, 13, 32];
 
 export abstract class FuzzerBase {
@@ -1113,7 +1135,6 @@ function removeFirst(values: i32[], needle: i32): void {
   if (index >= 0) values.splice(index, 1);
 }
 
-
 function validateLengthRange(label: string, min: i32, max: i32): void {
   if (min < 0 || max < 0) panic();
   if (max < min) panic();