as-test 1.1.1 → 1.1.3

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();

package/assembly/src/suite.ts

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

package/assembly/test.ts

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

package/assembly/util/format.ts

@@ -35,7 +35,10 @@ export function formatValue<T>(value: T, deep: boolean = false): string {
     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 += formatValue(
+        changetype<valueof<typeof keys>>(unchecked(keys[i])),
+        true,
+      );
       out += " => ";
       out += formatValue(
         changetype<valueof<typeof values>>(unchecked(values[i])),
@@ -73,31 +76,37 @@ export function formatValue<T>(value: T, deep: boolean = false): string {
   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/wipc.ts

@@ -154,8 +154,7 @@ export function requestFuzzConfig(): FuzzConfigReply {
   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 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);

package/bin/build-worker-pool.js

@@ -21,6 +21,7 @@ export class BuildWorkerPool {
                 configPath: args.configPath,
                 file: args.file,
                 modeName: args.modeName,
+                buildCommand: args.buildCommand,
                 featureToggles,
                 overrides,
                 resolve,
@@ -80,7 +81,12 @@ export class BuildWorkerPool {
             worker.busy = false;
             worker.task = null;
             if (failedTask) {
-                failedTask.reject(new Error("build worker exited unexpectedly"));
+                const modeLabel = failedTask.modeName ?? "default";
+                const fileLabel = failedTask.file;
+                const commandText = failedTask.buildCommand?.trim().length
+                    ? `\nBuild command: ${failedTask.buildCommand}`
+                    : "";
+                failedTask.reject(new Error(`build worker exited unexpectedly while building ${fileLabel} in mode ${modeLabel}${commandText}`));
             }
             if (!pool || this.closed)
                 return;

package/bin/commands/build-core.js

@@ -8,7 +8,7 @@ import { applyMode, getPkgRunner, loadConfig, tokenizeCommand, resolveProjectMod
 import { persistCrashRecord } from "../crash-store.js";
 import { BuildWorkerPool } from "../build-worker-pool.js";
 const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
-class BuildFailureError extends Error {
+export class BuildFailureError extends Error {
     constructor(args) {
         super(args.message);
         this.name = "BuildFailureError";
@@ -18,6 +18,7 @@ class BuildFailureError extends Error {
         this.stdout = args.stdout;
         this.stderr = args.stderr;
         this.kind = args.kind;
+        this.crashLogPath = args.crashLogPath;
     }
 }
 export async function build(configPath = DEFAULT_CONFIG_PATH, selectors = [], modeName, featureToggles = {}, overrides = {}, resolvedConfig) {
@@ -49,10 +50,13 @@ export async function build(configPath = DEFAULT_CONFIG_PATH, selectors = [], mo
         !hasCustomBuildCommand(config)) {
         const pool = getSerialBuildWorkerPool();
         for (const file of inputFiles) {
+            const outFile = `${config.outDir}/${resolveArtifactFileName(file, config.buildOptions.target, modeName, duplicateSpecBasenames)}`;
+            const invocation = getBuildCommand(config, pkgRunner, file, outFile, modeName, featureToggles);
             await pool.buildFileMode({
                 configPath,
                 file,
                 modeName,
+                buildCommand: formatInvocation(invocation),
                 featureToggles,
                 overrides,
             });
@@ -90,6 +94,7 @@ export async function build(configPath = DEFAULT_CONFIG_PATH, selectors = [], mo
                 stdout,
                 stderr,
                 kind,
+                crashLogPath: crash.logPath,
                 message: `Failed to build ${path.basename(file)} in mode ${modeLabel} with ${stderr || stdout || "unknown build error"}\n` +
                     `Build command: ${buildCommand}\n` +
                     `Crash log: ${crash.logPath}`,

package/bin/commands/build.js

@@ -1,6 +1,6 @@
 import { closeSerialBuildWorkerPool, } from "./build-core.js";
 export { build } from "./build-core.js";
-export { formatInvocation, getBuildInvocationPreview, getBuildReuseInfo, } from "./build-core.js";
+export { BuildFailureError, formatInvocation, getBuildInvocationPreview, getBuildReuseInfo, } from "./build-core.js";
 export async function executeBuildCommand(rawArgs, configPath, selectedModes, deps) {
     const commandArgs = deps.resolveCommandArgs(rawArgs, "build");
     const listFlags = deps.resolveListFlags(rawArgs, "build");

package/bin/commands/clean-core.js

@@ -112,7 +112,9 @@ function pruneNestedTargets(targets) {
             if (targetPath == otherPath)
                 continue;
             const relative = path.relative(targetPath, otherPath);
-            if (!relative.length || relative == ".." || relative.startsWith(`..${path.sep}`)) {
+            if (!relative.length ||
+                relative == ".." ||
+                relative.startsWith(`..${path.sep}`)) {
                 continue;
             }
             targets.delete(otherPath);

package/bin/commands/clean.js

@@ -1,16 +1,10 @@
-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(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) {
@@ -18,34 +12,3 @@ function resolveAllCleanModes(configPath) {
     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/commands/fuzz-core.js

@@ -292,10 +292,10 @@ function buildFuzzCrashEntryKey(file, modeName) {
     return `${path.basename(file).replace(/\.ts$/, "")}.${sanitizeEntryName(modeName)}`;
 }
 function sanitizeEntryName(name) {
-    return name
+    return (name
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "") || "fuzzer";
+        .replace(/^-+|-+$/g, "") || "fuzzer");
 }
 function captureFrames(onFrame) {
     const originalWrite = process.stdout.write.bind(process.stdout);