as-test 1.1.0 → 1.1.1

package/CHANGELOG.md

@@ -1,6 +1,11 @@
 # Change Log
 
-## Unreleased
+## 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
 
@@ -40,9 +45,13 @@
 ### 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, crash reports, and logs for the selected modes.
+- 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 --mode ...` skip shared output paths that are still owned by unselected modes instead of deleting them.
+- 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
 

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,
     );
   }
 }

package/assembly/util/format.ts

@@ -0,0 +1,104 @@
+export function formatValue<T>(value: T, deep: boolean = false): string {
+  if (isNullable<T>() && changetype<usize>(value) == <usize>0) {
+    return "null";
+  }
+
+  if (isString<T>()) {
+    const text = value as string;
+    return deep ? "'" + text + "'" : text;
+  }
+
+  if (isBoolean<T>() || isInteger<T>() || isFloat<T>()) {
+    // @ts-expect-error: primitive formatting
+    return value.toString();
+  }
+
+  if (isArray<T>()) {
+    // @ts-expect-error: array-like handling
+    const values = value as valueof<T>[];
+    if (!values.length) return "[]";
+    let out = "[";
+    for (let i = 0; i < values.length; i++) {
+      if (i) out += ", ";
+      out += formatValue<valueof<T>>(unchecked(values[i]), true);
+    }
+    out += "]";
+    return out;
+  }
+
+  if (value instanceof Map) {
+    // @ts-expect-error: generic runtime access
+    const keys = value.keys();
+    if (!keys.length) return "Map(0) {}";
+    // @ts-expect-error: generic runtime access
+    const values = value.values();
+    let out = "Map(" + keys.length.toString() + ") { ";
+    for (let i = 0; i < keys.length; i++) {
+      if (i) out += ", ";
+      out += formatValue(changetype<valueof<typeof keys>>(unchecked(keys[i])), true);
+      out += " => ";
+      out += formatValue(
+        changetype<valueof<typeof values>>(unchecked(values[i])),
+        true,
+      );
+    }
+    out += " }";
+    return out;
+  }
+
+  if (value instanceof Set) {
+    // @ts-expect-error: generic runtime access
+    const values = value.values();
+    if (!values.length) return "Set(0) {}";
+    let out = "Set(" + values.length.toString() + ") { ";
+    for (let i = 0; i < values.length; i++) {
+      if (i) out += ", ";
+      out += formatValue(
+        changetype<valueof<typeof values>>(unchecked(values[i])),
+        true,
+      );
+    }
+    out += " }";
+    return out;
+  }
+
+  if (isManaged<T>()) {
+    // @ts-expect-error: custom serializer when provided
+    if (isDefined(value.__as_test_json)) {
+      // @ts-expect-error: dynamic method dispatch
+      return value.__as_test_json();
+    }
+  }
+
+  return nameof<T>();
+}
+
+@inline
+export function colorText(format: i32[], text: string): string {
+  return `\u001b[${format[0].toString()}m${text}\u001b[${format[1].toString()}m`;
+}
+
+@inline
+export function red(text: string): string {
+  return colorText([31, 39], text);
+}
+
+@inline
+export function green(text: string): string {
+  return colorText([32, 39], text);
+}
+
+@inline
+export function bgRed(text: string): string {
+  return colorText([41, 49], text);
+}
+
+@inline
+export function bgGreen(text: string): string {
+  return colorText([42, 49], text);
+}
+
+@inline
+export function bold(text: string): string {
+  return colorText([1, 22], text);
+}

package/assembly/util/helpers.ts

@@ -1,4 +1,4 @@
-import { rainbow } from "as-rainbow";
+import { bgGreen, bgRed } from "./format";
 
 export function visualize<T>(value: T): string {
   if (isNullable<T>() && changetype<usize>(value) == <usize>0) {
@@ -61,16 +61,16 @@ export function diff(left: string, right: string, not: boolean = false): Diff {
     const rChar = right.charAt(i);
     if (not) {
       if (lChar == rChar) {
-        lDiff += rainbow.bgGreen(rChar);
-        rDiff += rainbow.bgRed(lChar);
+        lDiff += bgGreen(rChar);
+        rDiff += bgRed(lChar);
       } else {
         lDiff += rChar;
         rDiff += lChar;
       }
     } else {
       if (lChar != rChar) {
-        lDiff += rainbow.bgGreen(rChar);
-        rDiff += rainbow.bgRed(lChar);
+        lDiff += bgGreen(rChar);
+        rDiff += bgRed(lChar);
       } else {
         lDiff += rChar;
         rDiff += lChar;
@@ -80,9 +80,9 @@ export function diff(left: string, right: string, not: boolean = false): Diff {
 
   if (!not) {
     for (; i < left.length; i++) {
-      rDiff += rainbow.bgRed(left.charAt(i));
+      rDiff += bgRed(left.charAt(i));
     }
-    for (; i < right.length; i++) lDiff += rainbow.bgRed(right.charAt(i));
+    for (; i < right.length; i++) lDiff += bgRed(right.charAt(i));
   }
 
   return {
@@ -90,9 +90,3 @@ export function diff(left: string, right: string, not: boolean = false): Diff {
     right: rDiff,
   };
 }
-
-// @ts-ignore
-@inline
-export function colorText(format: i32[], text: string): string {
-  return `\u001b[${format[0].toString()}m${text}\u001b[${format[1].toString()}m`;
-}

package/assembly/util/json.ts

@@ -1,4 +1,4 @@
-import { stringify } from "as-console/stringify";
+import { formatValue } from "./format";
 
 export function quote(value: string): string {
   return '"' + escape(value) + '"';
@@ -36,7 +36,7 @@ export function stringifyValue<T>(value: T): string {
     return value.__as_test_json();
   }
 
-  const formatted = stringify<T>(value);
+  const formatted = formatValue<T>(value);
   if (formatted != "none") {
     return quote(formatted);
   }

package/assembly/util/wipc.ts

@@ -305,9 +305,12 @@ function wasiWriteAll(data: ArrayBuffer): void {
     store<usize>(iovPtr, <usize>left, sizeof<usize>());
     store<u32>(writtenPtr, 0, 0);
     const errno = wasi_fd_write(1, iovPtr, 1, writtenPtr);
+    if (errno == WASI_ERRNO_AGAIN || errno == WASI_ERRNO_INTR) {
+      continue;
+    }
     if (errno != 0) return;
     const written = <i32>load<u32>(writtenPtr, 0);
-    if (written <= 0) return;
+    if (written <= 0) continue;
     offset += written;
   }
 }

package/bin/commands/clean-core.js

@@ -3,36 +3,50 @@ import { existsSync, rmSync } from "fs";
 import * as path from "path";
 import { applyMode, loadConfig } from "../util.js";
 const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
-export async function clean(configPath = DEFAULT_CONFIG_PATH, modes = [undefined]) {
+export async function clean(configPath = DEFAULT_CONFIG_PATH, modes = [undefined], fullClean = false) {
     const loadedConfig = loadConfig(configPath, true);
     const targets = new Map();
     const ownership = buildOwnershipMap(loadedConfig);
-    for (const modeName of modes) {
-        const active = applyMode(loadedConfig, modeName).config;
-        collectTarget(targets, active.outDir, modeName, "build");
-        collectTarget(targets, active.fuzz.crashDir, modeName, "crashes");
-        collectTarget(targets, active.logs, modeName, "logs");
+    if (fullClean) {
+        collectRootTarget(targets, loadedConfig.outDir, "build");
+        collectRootTarget(targets, loadedConfig.fuzz.crashDir, "crashes");
+        collectRootTarget(targets, loadedConfig.coverageDir, "coverage");
+        collectRootTarget(targets, loadedConfig.logs, "logs");
+        for (const modeName of modes) {
+            const active = applyMode(loadedConfig, modeName).config;
+            collectTarget(targets, active.outDir, modeName, "build");
+            collectTarget(targets, active.fuzz.crashDir, modeName, "crashes");
+            collectTarget(targets, active.coverageDir, modeName, "coverage");
+            collectTarget(targets, active.logs, modeName, "logs");
+        }
+        pruneNestedTargets(targets);
+    }
+    else {
+        for (const modeName of modes) {
+            const active = applyMode(loadedConfig, modeName).config;
+            collectTarget(targets, active.outDir, modeName, "build");
+            collectTarget(targets, active.fuzz.crashDir, modeName, "crashes");
+            collectTarget(targets, active.coverageDir, modeName, "coverage");
+            collectTarget(targets, active.logs, modeName, "logs");
+        }
     }
     let removed = 0;
-    let skipped = 0;
     for (const [targetPath, owners] of [...targets.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
-        const allOwners = ownership.get(targetPath) ?? owners;
-        const unselectedOwners = allOwners.filter((owner) => !owners.includes(owner));
-        if (unselectedOwners.length) {
-            skipped++;
-            process.stdout.write(`${chalk.dim("skip")} ${toRelativePath(targetPath)} ${chalk.dim(`(shared with ${unselectedOwners.join(", ")})`)}\n`);
-            continue;
+        if (!fullClean) {
+            const allOwners = ownership.get(targetPath) ?? owners;
+            const unselectedOwners = allOwners.filter((owner) => !owners.includes(owner));
+            if (unselectedOwners.length) {
+                continue;
+            }
         }
         if (!existsSync(targetPath)) {
-            skipped++;
-            process.stdout.write(`${chalk.dim("skip")} ${toRelativePath(targetPath)} ${chalk.dim(`(${owners.join(", ")})`)}\n`);
             continue;
         }
         rmSync(targetPath, { recursive: true, force: true });
         removed++;
         process.stdout.write(`${chalk.bgGreenBright.black(" CLEAN ")} ${toRelativePath(targetPath)} ${chalk.dim(`(${owners.join(", ")})`)}\n`);
     }
-    process.stdout.write(`${chalk.bold("Summary:")} removed ${removed} path(s), skipped ${skipped} missing path(s)\n`);
+    process.stdout.write(`${chalk.bold("Summary:")} removed ${removed} path(s)\n`);
 }
 function buildOwnershipMap(loadedConfig) {
     const ownership = new Map();
@@ -44,10 +58,25 @@ function buildOwnershipMap(loadedConfig) {
         const active = applyMode(loadedConfig, modeName).config;
         collectOwnership(ownership, active.outDir, modeName, "build");
         collectOwnership(ownership, active.fuzz.crashDir, modeName, "crashes");
+        collectOwnership(ownership, active.coverageDir, modeName, "coverage");
         collectOwnership(ownership, active.logs, modeName, "logs");
     }
     return ownership;
 }
+function collectRootTarget(targets, rawPath, kind) {
+    if (!rawPath || rawPath == "none")
+        return;
+    const resolved = path.resolve(process.cwd(), rawPath);
+    ensureSafeCleanPath(resolved, rawPath, kind);
+    const owner = `all:${kind}`;
+    const existing = targets.get(resolved);
+    if (existing) {
+        if (!existing.includes(owner))
+            existing.push(owner);
+        return;
+    }
+    targets.set(resolved, [owner]);
+}
 function collectOwnership(ownership, rawPath, modeName, kind) {
     if (!rawPath || rawPath == "none")
         return;
@@ -76,6 +105,20 @@ function collectTarget(targets, rawPath, modeName, kind) {
     }
     targets.set(resolved, [owner]);
 }
+function pruneNestedTargets(targets) {
+    const paths = [...targets.keys()].sort((a, b) => a.length - b.length);
+    for (const targetPath of paths) {
+        for (const otherPath of paths) {
+            if (targetPath == otherPath)
+                continue;
+            const relative = path.relative(targetPath, otherPath);
+            if (!relative.length || relative == ".." || relative.startsWith(`..${path.sep}`)) {
+                continue;
+            }
+            targets.delete(otherPath);
+        }
+    }
+}
 function ensureSafeCleanPath(resolvedPath, rawPath, kind) {
     const cwd = path.resolve(process.cwd());
     const relative = path.relative(cwd, resolvedPath);

package/bin/commands/clean.js

@@ -1,6 +1,51 @@
+import chalk from "chalk";
+import { createInterface } from "readline";
 import { clean } from "./clean-core.js";
+import { loadConfig } from "../util.js";
 export { clean } from "./clean-core.js";
-export async function executeCleanCommand(configPath, selectedModes, resolveExecutionModes) {
-    const modeTargets = resolveExecutionModes(configPath, selectedModes);
-    await clean(configPath, modeTargets);
+export async function executeCleanCommand(rawArgs, configPath, selectedModes, resolveExecutionModes) {
+    const force = rawArgs.includes("-f") || rawArgs.includes("--force");
+    const modeTargets = selectedModes.length > 0
+        ? resolveExecutionModes(configPath, selectedModes)
+        : resolveAllCleanModes(configPath);
+    if (!force && selectedModes.length == 0) {
+        await confirmFullClean(configPath);
+    }
+    await clean(configPath, modeTargets, selectedModes.length == 0);
+}
+function resolveAllCleanModes(configPath) {
+    const resolvedConfigPath = configPath ?? "./as-test.config.json";
+    const config = loadConfig(resolvedConfigPath, true);
+    return [undefined, ...Object.keys(config.modes)];
+}
+async function confirmFullClean(configPath) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error('clean without --mode requires confirmation. Re-run with "-f" or "--force" to skip the prompt.');
+    }
+    const target = configPath ? ` in ${configPath}` : "";
+    process.stdout.write(chalk.bold.blue("◇  Confirm Clean") +
+        "\n" +
+        `│  This will remove configured build outputs, crash reports, and logs for every mode${target}.\n` +
+        "│\n");
+    const answer = await promptLine("Continue? [Y/n] ");
+    const normalized = answer.trim().toLowerCase();
+    if (normalized == "" || normalized == "y" || normalized == "yes")
+        return;
+    if (normalized == "n" || normalized == "no") {
+        process.stdout.write(chalk.dim("clean cancelled\n"));
+        process.exit(0);
+    }
+    throw new Error(`invalid answer "${answer}". Expected yes or no.`);
+}
+function promptLine(question) {
+    return new Promise((resolve) => {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
 }

package/bin/index.js

@@ -134,7 +134,7 @@ else if (COMMANDS.includes(args[0])) {
             });
         }
         else if (command === "clean") {
-            executeCleanCommand(configPath, selectedModes, resolveExecutionModes).catch((error) => {
+            executeCleanCommand(_args, configPath, selectedModes, resolveExecutionModes).catch((error) => {
                 printCliError(error);
                 process.exit(1);
             });
@@ -370,10 +370,11 @@ function printCommandHelp(command) {
     }
     if (command == "clean") {
         process.stdout.write(chalk.bold("Usage: ast clean [flags]\n\n"));
-        process.stdout.write("Remove configured build outputs, crash reports, and logs for the selected modes.\n\n");
+        process.stdout.write("Remove configured build outputs, crash reports, and logs.\n\n");
         process.stdout.write(chalk.bold("Flags:\n"));
         process.stdout.write("  --config <path>          Use a specific config file\n");
         process.stdout.write("  --mode <name[,name...]>  Clean one or multiple named modes\n");
+        process.stdout.write("  -f, --force              Skip the full-clean confirmation prompt\n");
         process.stdout.write("  --help, -h               Show this help\n");
         return;
     }

package/bin/wipc.js

@@ -31,8 +31,12 @@ export class Channel {
                 return;
             const idx = this.buffer.indexOf(Channel.MAGIC);
             if (idx === -1) {
-                this.onPassthrough(this.buffer);
-                this.buffer = Buffer.alloc(0);
+                const keep = Math.min(this.buffer.length, Channel.MAGIC_PREFIX_MAX);
+                const flushLength = this.buffer.length - keep;
+                if (flushLength > 0) {
+                    this.onPassthrough(this.buffer.subarray(0, flushLength));
+                    this.buffer = this.buffer.subarray(flushLength);
+                }
                 return;
             }
             if (idx > 0) {
@@ -77,3 +81,4 @@ export class Channel {
 }
 Channel.MAGIC = Buffer.from("WIPC");
 Channel.HEADER_SIZE = 9;
+Channel.MAGIC_PREFIX_MAX = Channel.MAGIC.length - 1;

package/lib/build/index.js

@@ -96,7 +96,25 @@ function readExact(length) {
 }
 function writeRaw(data) {
     const view = Buffer.from(data);
-    fs.writeSync(1, view);
+    let offset = 0;
+    while (offset < view.byteLength) {
+        let written = 0;
+        try {
+            written = fs.writeSync(1, view, offset, view.byteLength - offset);
+        }
+        catch (error) {
+            if (error &&
+                typeof error == "object" &&
+                "code" in error &&
+                error.code == "EAGAIN") {
+                continue;
+            }
+            throw error;
+        }
+        if (!written)
+            continue;
+        offset += written;
+    }
 }
 function mergeImports(...groups) {
     const out = {};

package/lib/src/index.ts

@@ -130,7 +130,25 @@ function readExact(length: number): ArrayBuffer {
 
 function writeRaw(data: ArrayBuffer): void {
   const view = Buffer.from(data);
-  fs.writeSync(1, view);
+  let offset = 0;
+  while (offset < view.byteLength) {
+    let written = 0;
+    try {
+      written = fs.writeSync(1, view, offset, view.byteLength - offset);
+    } catch (error) {
+      if (
+        error &&
+        typeof error == "object" &&
+        "code" in error &&
+        error.code == "EAGAIN"
+      ) {
+        continue;
+      }
+      throw error;
+    }
+    if (!written) continue;
+    offset += written;
+  }
 }
 
 function mergeImports(...groups: unknown[]): AnyImports {

package/package.json

@@ -1,14 +1,12 @@
 {
   "name": "as-test",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/JairusSW/as-test.git"
   },
   "dependencies": {
-    "as-rainbow": "^0.1.0",
-    "as-console": "^7.0.0",
     "chalk": "^5.6.2",
     "glob": "^13.0.6",
     "typer-diff": "^1.1.1",