as-test 1.0.16 → 1.1.1

package/CHANGELOG.md

@@ -1,5 +1,62 @@
 # Change Log
 
+## v1.1.1
+
+- add `ast clean` command to remove build outputs, coverage outputs, crash reports, and logs.
+- remove deps
+
+## v1.1.0
+
+### Upgrading to 1.1.0
+
+- refresh generated runners with:
+
+  ```bash
+  rm -rf .as-test/runners && npx as-test init
+  ```
+
+- generated runners now use a single file per target and import `instantiate(...)` from `as-test/lib`
+- new bindings and web runners no longer use `*.hooks.js`
+- named modes now support `default: false` to make a mode manual-only
+- the repo examples and default config now use mode names like `node:wasi`, `node:bindings`, `chromium`, and `chromium:headless`
+
+### Runtime & Runners
+
+- feat: replace the split bindings/web hooks model with single-file runners that import `instantiate(...)` from `as-test/lib`, keeping bindings, WASI, and web runner syntax aligned.
+- feat: add `as-test/lib` as the shared JS runtime host layer for bindings, WASI, and web targets, with runtime artifact resolution happening out of sight before runner execution.
+- feat: autodetect bindings helper shape at runtime support level (`raw`, `esm`, or `none`) and keep the generated runner surface minimal.
+- fix: make `ast run` rebuild missing artifacts on demand instead of failing when only some selected outputs already exist.
+- fix: report real lazy-build time in `ast run` summaries instead of always printing `0us build`.
+- fix: remove build artifact copy/reuse shortcuts so each selected file/mode compiles directly, avoiding stale output reuse across modes.
+
+### Web Runtime
+
+- feat: move headful web execution to a persistent single-browser-session architecture that opens one page, runs multiple binaries through it, and keeps browser-side runtime details hidden from the runner file.
+- feat: redesign the non-headless browser page into a minimal macOS-inspired loading surface with light/dark mode support and simpler status messaging.
+- feat: make headful web runs wait for the user to open the local session URL, and expose a browser-side exit control.
+- fix: keep all browser bootstrap, asset, and websocket traffic on one local port.
+- fix: improve browser discovery and launch behavior across Chromium, Firefox, and WebKit, including Playwright cache lookup, macOS app bundle resolution, paths with spaces, and owned-process teardown.
+- fix: fail terminal-side runs when the browser side disconnects unexpectedly, and close the browser side when the websocket is lost.
+
+### WASI
+
+- fix: make the WASI stdin transport retry only on retryable WASI read errors (`AGAIN` and `INTR`), which resolves intermittent snapshot reply corruption in `node:wasi` runs.
+
+### Modes & CLI
+
+- 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.
+- 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.
+- fix: make full `ast clean` remove the configured output roots directly so stale legacy build, coverage, and log directories are removed too.
+- fix: simplify `ast clean` console output so it only prints removed paths plus a final summary.
+
+### Tests
+
+- feat: add integration coverage for bindings (`raw`, `esm`, `none`), WASI, and web runtime paths, including browser-resolution regressions and single-origin web runner behavior.
+
 ## 2026-05-08 - v1.0.16
 
 - feat: modes inherit pre-declared properties if not explicitly overriden

package/README.md

@@ -2,6 +2,14 @@
 ╠═╣ ╚═╗ ══  ║  ╠═  ╚═╗  ║ 
 ╩ ╩ ╚═╝     ╩  ╚═╝ ╚═╝  ╩ </pre></h1>
 
+> **Upgrading to 1.1.0**
+>
+> See [CHANGELOG.md](./CHANGELOG.md) for upgrade notes. In most projects, refreshing generated runners is enough:
+>
+> ```bash
+> rm -rf .as-test/runners && npx as-test init
+> ```
+
 <details>
 <summary>Table of Contents</summary>
 
@@ -77,7 +85,7 @@ Minimal `as-test.config.json`:
   },
   "runOptions": {
     "runtime": {
-      "cmd": "node .as-test/runners/default.wasi.js <file>"
+      "cmd": "node .as-test/runners/default.wasi.js"
     }
   }
 }
@@ -323,7 +331,7 @@ For example, a simple WASI setup in `as-test.config.json` can look like this:
   },
   "runOptions": {
     "runtime": {
-      "cmd": "node ./.as-test/runners/default.wasi.js <file>"
+      "cmd": "node ./.as-test/runners/default.wasi.js"
     }
   }
 }
@@ -342,22 +350,41 @@ If you want to keep more than one runtime around, use modes:
   "input": ["./assembly/__tests__/*.spec.ts"],
   "modes": {
     "wasi": {
+      "default": true,
       "buildOptions": {
         "target": "wasi"
       },
       "runOptions": {
         "runtime": {
-          "cmd": "node ./.as-test/runners/default.wasi.js <file>"
+          "cmd": "node ./.as-test/runners/default.wasi.js"
         }
       }
     },
     "bindings": {
+      "default": true,
       "buildOptions": {
         "target": "bindings"
       },
       "runOptions": {
         "runtime": {
-          "cmd": "node ./.as-test/runners/default.bindings.js <file>"
+          "cmd": "node ./.as-test/runners/default.bindings.js"
+        }
+      }
+    }
+  }
+}
+```
+
+Set `"default": false` on a mode when you want to keep it available for explicit `--mode ...` runs without including it in normal runs:
+
+```json
+{
+  "modes": {
+    "web": {
+      "default": false,
+      "runOptions": {
+        "runtime": {
+          "browser": "chromium"
         }
       }
     }
@@ -365,6 +392,20 @@ If you want to keep more than one runtime around, use modes:
 }
 ```
 
+With that setup:
+
+```bash
+npx ast test
+```
+
+runs the root/default config plus any modes whose `"default"` flag is not `false`, while:
+
+```bash
+npx ast test --mode web
+```
+
+still runs the `web` mode explicitly.
+
 Modes can also be full config objects. That means a mode can override fuzzing, input globs, output aliases, runtime, build flags, and the rest of the normal config surface:
 
 ```json

package/as-test.config.schema.json

@@ -305,6 +305,11 @@
             "type": "object",
             "additionalProperties": false,
             "properties": {
+              "default": {
+                "type": "boolean",
+                "description": "Include this mode when --mode is omitted. Defaults to true.",
+                "default": true
+              },
               "$schema": {
                 "type": "string"
               },

package/assembly/__fuzz__/math.fuzz.ts

@@ -7,3 +7,22 @@ fuzz("bounded integer addition", (left: i32, right: i32): bool => {
 }).generate((seed: FuzzSeed, run: (left: i32, right: i32) => bool): void => {
   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);
+
+  if (value != 0) {
+    expect(value).toBeTruthy();
+  } else {
+    expect(value).toBeFalsy();
+  }
+
+  return true;
+}).generate((seed: FuzzSeed, run: (value: i32) => bool): void => {
+  run(seed.i32({ min: -1000, max: 1000 }));
+}, 250);

package/assembly/__fuzz__/string.fuzz.ts

@@ -19,3 +19,34 @@ fuzz(
     }),
   );
 }, 250);
+
+fuzz(
+  "string matchers stay consistent on derived slices",
+  (input: string): bool => {
+    const split = input.length >> 1;
+    const prefix = input.substr(0, split);
+    const suffix = input.substr(split);
+
+    expect(input).toBeString();
+    expect(input).toContain(prefix);
+    expect(input).toMatch(suffix);
+
+    if (input.length > 0) {
+      expect(input).toBeTruthy();
+      expect(input).toContain(input.charAt(input.length - 1));
+    } else {
+      expect(input).toBeFalsy();
+    }
+
+    return true;
+  },
+).generate((seed: FuzzSeed, run: (input: string) => bool): void => {
+  run(
+    seed.string({
+      charset: "ascii",
+      min: 0,
+      max: 40,
+      exclude: [0x00, 0x0a, 0x0d],
+    }),
+  );
+}, 250);

package/assembly/index.ts

@@ -1,6 +1,5 @@
 import { Suite } from "./src/suite";
 import { Expectation } from "./src/expectation";
-import { stringify } from "as-console/stringify";
 import {
   __COVER,
   __POINTS,
@@ -16,6 +15,7 @@ import {
   sendReport,
 } from "./util/wipc";
 import { quote } from "./util/json";
+import { bold, formatValue, green, red } from "./util/format";
 import {
   createFuzzer,
   FuzzerBase,
@@ -245,7 +245,7 @@ export function log<T>(data: T): void {
 }
 
 export function __as_test_log_default<T>(data: T): string {
-  return stringify(data);
+  return formatValue(data);
 }
 
 export function __as_test_log_is_enabled(): bool {
@@ -673,11 +673,11 @@ export class Result {
   }
   display(): string {
     let out = "";
-    out += `${rainbow.boldMk(this.name)} `;
+    out += `${bold(this.name)} `;
     if (this.arg1) {
-      out += `${rainbow.boldMk(rainbow.red(this.arg1.toString() + " " + "failed"))}`;
+      out += `${bold(red(this.arg1.toString() + " failed"))}`;
     } else {
-      out += `${rainbow.boldMk(rainbow.green("0 failed"))}`;
+      out += `${bold(green("0 failed"))}`;
     }
     out += ` ${this.arg1 + this.arg2} total\n`;
     return out;

package/assembly/src/expectation.ts

@@ -62,6 +62,7 @@ export class Expectation<T> extends Tests {
     instr: string,
     left: string,
     right: string,
+    message: string = "",
   ): void {
     if (this._skip) {
       this.verdict = "skip";
@@ -77,7 +78,8 @@ export class Expectation<T> extends Tests {
     this.instr = instr;
     this.left = left;
     this.right = right;
-    this.message = isFail ? this._message : "";
+    const resolvedMessage = message.length ? message : this._message;
+    this.message = isFail ? resolvedMessage : "";
     if (isFail) {
       sendAssertionFailure(this._snapshotKey, instr, left, right, this.message);
       // @ts-ignore
@@ -103,7 +105,7 @@ export class Expectation<T> extends Tests {
   /**
    * Tests if a == null
    */
-  toBeNull(): void {
+  toBeNull(message: string = ""): void {
     const passed =
       (isNullable<T>() && changetype<usize>(this._left) == 0) ||
       (isInteger<T>() && nameof<T>() == "usize" && this._left == 0);
@@ -117,13 +119,14 @@ export class Expectation<T> extends Tests {
       visualize<T>(
         load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
       ),
+      message,
     );
   }
 
   /**
    * Tests if a > b
    */
-  toBeGreaterThan(value: T): void {
+  toBeGreaterThan(value: T, message: string = ""): void {
     if (!isInteger<T>() && !isFloat<T>())
       ERROR("toBeGreaterThan() can only be used on number types!");
 
@@ -139,13 +142,14 @@ export class Expectation<T> extends Tests {
       visualize<T>(
         load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
       ),
+      message,
     );
   }
 
   /**
    * Tests if a >= b
    */
-  toBeGreaterOrEqualTo(value: T): void {
+  toBeGreaterOrEqualTo(value: T, message: string = ""): void {
     if (!isInteger<T>() && !isFloat<T>())
       ERROR("toBeGreaterOrEqualTo() can only be used on number types!");
 
@@ -161,13 +165,14 @@ export class Expectation<T> extends Tests {
       visualize<T>(
         load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
       ),
+      message,
     );
   }
 
   /**
    * Tests if a < b
    */
-  toBeLessThan(value: T): void {
+  toBeLessThan(value: T, message: string = ""): void {
     if (!isInteger<T>() && !isFloat<T>())
       ERROR("toBeLessThan() can only be used on number types!");
 
@@ -183,13 +188,14 @@ export class Expectation<T> extends Tests {
       visualize<T>(
         load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
       ),
+      message,
     );
   }
 
   /**
    * Tests if a <= b
    */
-  toBeLessThanOrEqualTo(value: T): void {
+  toBeLessThanOrEqualTo(value: T, message: string = ""): void {
     if (!isInteger<T>() && !isFloat<T>())
       ERROR("toBeLessThanOrEqualTo() can only be used on number types!");
 
@@ -205,93 +211,127 @@ export class Expectation<T> extends Tests {
       visualize<T>(
         load<T>(changetype<usize>(this), offsetof<Expectation<T>>("_right")),
       ),
+      message,
     );
   }
 
   /**
    * Tests if a is string
    */
-  toBeString(): void {
-    this._resolve(isString<T>(), "toBeString", q(nameof<T>()), q("string"));
+  toBeString(message: string = ""): void {
+    this._resolve(
+      isString<T>(),
+      "toBeString",
+      q(nameof<T>()),
+      q("string"),
+      message,
+    );
   }
 
   /**
    * Tests if a is boolean
    */
-  toBeBoolean(): void {
-    this._resolve(isBoolean<T>(), "toBeBoolean", q(nameof<T>()), q("boolean"));
+  toBeBoolean(message: string = ""): void {
+    this._resolve(
+      isBoolean<T>(),
+      "toBeBoolean",
+      q(nameof<T>()),
+      q("boolean"),
+      message,
+    );
   }
 
   /**
    * Tests if a is array
    */
-  toBeArray(): void {
-    this._resolve(isArray<T>(), "toBeArray", q(nameof<T>()), q("Array<any>"));
+  toBeArray(message: string = ""): void {
+    this._resolve(
+      isArray<T>(),
+      "toBeArray",
+      q(nameof<T>()),
+      q("Array<any>"),
+      message,
+    );
   }
 
   /**
    * Tests if a is number
    */
-  toBeNumber(): void {
+  toBeNumber(message: string = ""): void {
     this._resolve(
       isFloat<T>() || isInteger<T>(),
       "toBeNumber",
       q(nameof<T>()),
       q("number"),
+      message,
     );
   }
 
   /**
    * Tests if a is integer
    */
-  toBeInteger(): void {
-    this._resolve(isInteger<T>(), "toBeInteger", q(nameof<T>()), q("integer"));
+  toBeInteger(message: string = ""): void {
+    this._resolve(
+      isInteger<T>(),
+      "toBeInteger",
+      q(nameof<T>()),
+      q("integer"),
+      message,
+    );
   }
 
   /**
    * Tests if a is float
    */
-  toBeFloat(): void {
-    this._resolve(isFloat<T>(), "toBeFloat", q(nameof<T>()), q("float"));
+  toBeFloat(message: string = ""): void {
+    this._resolve(
+      isFloat<T>(),
+      "toBeFloat",
+      q(nameof<T>()),
+      q("float"),
+      message,
+    );
   }
 
   /**
    * Tests if a is finite
    */
-  toBeFinite(): void {
+  toBeFinite(message: string = ""): void {
     // @ts-ignore
     const passed = (isFloat<T>() || isInteger<T>()) && isFinite(this._left);
-    this._resolve(passed, "toBeFinite", q("Infinity"), q("Finite"));
+    this._resolve(passed, "toBeFinite", q("Infinity"), q("Finite"), message);
   }
 
   /**
    * Tests if a value is truthy
    */
-  toBeTruthy(): void {
+  toBeTruthy(message: string = ""): void {
     this._resolve(
       isTruthy<T>(this._left),
       "toBeTruthy",
       q("falsy"),
       q("truthy"),
+      message,
     );
   }
 
   /**
    * Tests if a value is falsy
    */
-  toBeFalsy(): void {
+  toBeFalsy(message: string = ""): void {
     this._resolve(
       !isTruthy<T>(this._left),
       "toBeFalsy",
       q("truthy"),
       q("falsy"),
+      message,
     );
   }
 
   /**
    * Tests if a floating-point number is close to expected
    */
-  toBeCloseTo(expected: T, precision: i32 = 2): void {
+  toBeCloseTo(expected: T, precision: i32 = 2, message: string = ""): void {
     if (!isFloat<T>() && !isInteger<T>())
       ERROR("toBeCloseTo() can only be used on number types!");
     const factor = Math.pow(10, precision as f64);
@@ -302,67 +342,74 @@ export class Expectation<T> extends Tests {
       "toBeCloseTo",
       visualize<T>(this._left),
       visualize<T>(expected),
+      message,
     );
   }
 
   /**
    * Tests if a string contains substring
    */
-  toMatch(value: string): void {
+  toMatch(value: string, message: string = ""): void {
     if (!isString<T>()) ERROR("toMatch() can only be used on string types!");
     // @ts-ignore
     const passed = this._left.indexOf(value) >= 0;
     // @ts-ignore
-    this._resolve(passed, "toMatch", q(this._left as string), q(value));
+    this._resolve(passed, "toMatch", q(this._left as string), q(value), message);
   }
 
   /**
    * Tests if a string starts with the provided prefix.
    */
-  toStartWith(value: string): void {
+  toStartWith(value: string, message: string = ""): void {
     if (!isString<T>())
       ERROR("toStartWith() can only be used on string types!");
     // @ts-ignore
     const left = this._left as string;
     const passed = left.indexOf(value) == 0;
-    this._resolve(passed, "toStartWith", q(left), q(value));
+    this._resolve(passed, "toStartWith", q(left), q(value), message);
   }
 
   /**
    * Tests if a string ends with the provided suffix.
    */
-  toEndWith(value: string): void {
+  toEndWith(value: string, message: string = ""): void {
     if (!isString<T>()) ERROR("toEndWith() can only be used on string types!");
     // @ts-ignore
     const left = this._left as string;
     const idx = left.lastIndexOf(value);
     const passed = idx >= 0 && idx + value.length == left.length;
-    this._resolve(passed, "toEndWith", q(left), q(value));
+    this._resolve(passed, "toEndWith", q(left), q(value), message);
   }
 
   /**
    * Tests if an array has length x
    */
-  toHaveLength(value: i32): void {
+  toHaveLength(value: i32, message: string = ""): void {
     // @ts-ignore
     const leftLen = this._left.length as i32;
     // @ts-ignore
     const passed = isArray<T>() && leftLen == value;
-    this._resolve(passed, "toHaveLength", leftLen.toString(), value.toString());
+    this._resolve(
+      passed,
+      "toHaveLength",
+      leftLen.toString(),
+      value.toString(),
+      message,
+    );
   }
 
   /**
    * Tests if an array or string contains a value
    */
   // @ts-ignore
-  toContain(value: valueof<T>): void {
+  toContain(value: valueof<T>, message: string = ""): void {
     if (isString<T>()) {
       // @ts-ignore
       const left = this._left as string;
       // @ts-ignore
       const needle = value as string;
       const passed = left.indexOf(needle) >= 0;
-      this._resolve(passed, "toContain", q(left), q(needle));
+      this._resolve(passed, "toContain", q(left), q(needle), message);
       return;
     }
 
@@ -374,6 +421,7 @@ export class Expectation<T> extends Tests {
         "toContain",
         stringifyValue<T>(this._left),
         stringifyValue<valueof<T>>(value),
+        message,
       );
       return;
     }
@@ -385,28 +433,28 @@ export class Expectation<T> extends Tests {
    * Alias for toContain().
    */
   // @ts-ignore
-  toContains(value: valueof<T>): void {
-    this.toContain(value);
+  toContains(value: valueof<T>, message: string = ""): void {
+    this.toContain(value, message);
   }
 
   /**
    * Tests if serialized value matches stored snapshot.
    */
-  toMatchSnapshot(name: string = ""): void {
+  toMatchSnapshot(name: string = "", message: string = ""): void {
     let key = name.length
       ? namedSnapshotKey(this._snapshotKey, name)
       : nextUnnamedSnapshotKey(this._snapshotKey);
 
     const actual = stringifyValue<T>(this._left);
     const res = snapshotAssert(key, actual);
-    this._resolve(res.ok, "toMatchSnapshot", actual, res.expected);
+    this._resolve(res.ok, "toMatchSnapshot", actual, res.expected, message);
   }
 
   /**
    * Delegates throw assertions to try-as when available.
    * If try-as is unavailable, this matcher is disabled and warns once.
    */
-  toThrow(): void {
+  toThrow(message: string = ""): void {
     // @ts-ignore
     if (!isDefined(AS_TEST_TRY_AS)) {
       if (!warnedToThrowDisabled) {
@@ -415,7 +463,7 @@ export class Expectation<T> extends Tests {
         );
         warnedToThrowDisabled = true;
       }
-      this._resolve(true, "toThrow", q("disabled"), q("disabled"));
+      this._resolve(true, "toThrow", q("disabled"), q("disabled"), message);
       return;
     }
 
@@ -425,13 +473,13 @@ export class Expectation<T> extends Tests {
       // @ts-ignore
       __ExceptionState.Failures--;
     }
-    this._resolve(passed, "toThrow", q("throws"), q("throws"));
+    this._resolve(passed, "toThrow", q("throws"), q("throws"), message);
   }
 
   /**
    * Tests for equality
    */
-  toBe(equals: T): void {
+  toBe(equals: T, message: string = ""): void {
     const passed = this._left === equals;
 
     this._resolve(
@@ -439,32 +487,35 @@ export class Expectation<T> extends Tests {
       "toBe",
       stringifyValue<T>(this._left),
       stringifyValue<T>(equals),
+      message,
     );
   }
 
   /**
    * Tests for deep equality
    */
-  toEqual(equals: T): void {
+  toEqual(equals: T, message: string = ""): void {
     const passed = valueEquals<T>(this._left, equals, false);
     this._resolve(
       passed,
       "toEqual",
       stringifyValue<T>(this._left),
       stringifyValue<T>(equals),
+      message,
     );
   }
 
   /**
    * Tests for strict deep equality
    */
-  toStrictEqual(equals: T): void {
+  toStrictEqual(equals: T, message: string = ""): void {
     const passed = valueEquals<T>(this._left, equals, true);
     this._resolve(
       passed,
       "toStrictEqual",
       stringifyValue<T>(this._left),
       stringifyValue<T>(equals),
+      message,
     );
   }
 }