as-test 1.0.10 → 1.0.12

package/CHANGELOG.md

@@ -1,6 +1,15 @@
 # Change Log
 
-## Unreleased
+## 2026-04-28 - v1.0.12
+
+- perf: faster seed generation
+- feat: make fuzz campaigns use a random base seed by default when `fuzz.seed` and CLI seed overrides are not set, while keeping deterministic replay via `--seed` / `--fuzz-seed`.
+
+## 2026-04-18 - v1.0.11
+
+### Coverage
+
+- fix: ignore additional AssemblyScript compile-time builtin calls during coverage instrumentation, including `isVector`, `isVoid`, and `lengthof`.
 
 ## 2026-04-18 - v1.0.10
 

package/README.md

@@ -276,6 +276,8 @@ If you used `npx ast init` with a fuzzer example, the config is already there. O
 
 `ast fuzz` runs fuzz files across the selected modes, reports one result per file, and keeps the final summary separate from the normal test totals. If you want one combined command, use `ast test --fuzz`.
 
+By default, each fuzz run campaign picks a new random base seed. Pin a seed with `--seed <n>` (or `--fuzz-seed <n>` on `ast test`) when you want deterministic replay.
+
 When a fuzzer fails, `as-test` now prints the exact failing seeds and one-run repro commands such as `ast fuzz ... --seed <seed+n> --runs 1`. Crash records in `.as-test/crashes` also include the captured inputs passed to `run(...)`, which helps when the generator itself has side effects.
 
 Run only fuzzers:

package/as-test.config.schema.json

@@ -259,8 +259,7 @@
         },
         "seed": {
           "type": "number",
-          "description": "Base deterministic seed for input mutation.",
-          "default": 1337
+          "description": "Optional base seed for input mutation. If omitted, a random seed is generated each run."
         },
         "maxInputBytes": {
           "type": "number",
@@ -287,7 +286,6 @@
       "default": {
         "input": ["./assembly/__fuzz__/*.fuzz.ts"],
         "runs": 1000,
-        "seed": 1337,
         "maxInputBytes": 4096,
         "target": "bindings",
         "corpusDir": "./.as-test/fuzz/corpus",

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

@@ -0,0 +1,68 @@
+import {
+  fuzz,
+  FuzzSeed,
+  IntegerOptions,
+  FloatOptions,
+  StringOptions,
+  BytesOptions,
+  ArrayOptions,
+} from "as-test";
+
+const PERF_I32 = new IntegerOptions<i32>();
+PERF_I32.min = -100000;
+PERF_I32.max = 100000;
+const PERF_U32 = new IntegerOptions<u32>();
+PERF_U32.min = 0;
+PERF_U32.max = 1000000;
+const PERF_F64 = new FloatOptions<f64>();
+PERF_F64.min = -1.0;
+PERF_F64.max = 1.0;
+const PERF_ASCII = new StringOptions();
+PERF_ASCII.charset = "ascii";
+PERF_ASCII.min = 4;
+PERF_ASCII.max = 24;
+const PERF_BYTES = new BytesOptions();
+PERF_BYTES.min = 8;
+PERF_BYTES.max = 32;
+const PERF_ARRAY = new ArrayOptions();
+PERF_ARRAY.min = 4;
+PERF_ARRAY.max = 16;
+
+fuzz("seed perf i32/u32/f64", (_n: i32): bool => true).generate(
+  (seed: FuzzSeed, run: (n: i32) => bool): void => {
+    let accI: i32 = 0;
+    let accU: u32 = 0;
+    let accF: f64 = 0.0;
+    for (let i = 0; i < 128; i++) {
+      accI += seed.i32(PERF_I32);
+      accU ^= seed.u32(PERF_U32);
+      accF += seed.f64(PERF_F64);
+    }
+    run(accI + <i32>accU + <i32>accF);
+  },
+  20000,
+);
+
+fuzz("seed perf strings", (_n: i32): bool => true).generate(
+  (seed: FuzzSeed, run: (n: i32) => bool): void => {
+    let total = 0;
+    for (let i = 0; i < 96; i++) {
+      total += seed.string(PERF_ASCII).length;
+    }
+    run(total);
+  },
+  20000,
+);
+
+fuzz("seed perf bytes/array", (_n: i32): bool => true).generate(
+  (seed: FuzzSeed, run: (n: i32) => bool): void => {
+    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;
+    }
+    run(score);
+  },
+  20000,
+);

package/assembly/src/fuzz.ts

@@ -34,8 +34,28 @@ export class ArrayOptions {
   max: i32 = 16;
 }
 
+const DEFAULT_I32_OPTIONS = new IntegerOptions<i32>();
+const DEFAULT_U32_OPTIONS = new IntegerOptions<u32>();
+const DEFAULT_F32_OPTIONS = new FloatOptions<f32>();
+const DEFAULT_F64_OPTIONS = new FloatOptions<f64>();
+const DEFAULT_STRING_OPTIONS = new StringOptions();
+const DEFAULT_BYTES_OPTIONS = new BytesOptions();
+const DEFAULT_ARRAY_OPTIONS = new ArrayOptions();
+
 export class FuzzSeed {
-  constructor(private state: u64) {}
+  private state: u32;
+
+  constructor(seed: u64) {
+    this.reseed(seed);
+  }
+
+  reseed(seed: u64): void {
+    const lo = <u32>seed;
+    const hi = <u32>(seed >> 32);
+    let mixed = lo ^ (hi * 0x9e3779b9) ^ 0xa341316c;
+    if (mixed == 0) mixed = 0x6d2b79f5;
+    this.state = mixed;
+  }
 
   boolean(): bool {
     return (this.nextU32() & 1) == 1;
@@ -46,59 +66,108 @@ export class FuzzSeed {
     return unchecked(values[this.nextRange(0, values.length - 1)]);
   }
 
-  i32(options: IntegerOptions<i32> = new IntegerOptions<i32>()): i32 {
-    return this.nextI32InRange(options.min, options.max, options.exclude);
+  i32(options: IntegerOptions<i32> | null = null): i32 {
+    const config = options != null ? options : DEFAULT_I32_OPTIONS;
+    return this.nextI32InRange(config.min, config.max, config.exclude);
   }
 
-  u32(options: IntegerOptions<u32> = new IntegerOptions<u32>()): u32 {
-    return this.nextU32InRange(options.min, options.max, options.exclude);
+  u32(options: IntegerOptions<u32> | null = null): u32 {
+    const config = options != null ? options : DEFAULT_U32_OPTIONS;
+    return this.nextU32InRange(config.min, config.max, config.exclude);
   }
 
-  f32(options: FloatOptions<f32> = new FloatOptions<f32>()): f32 {
+  f32(options: FloatOptions<f32> | null = null): f32 {
+    const config = options != null ? options : DEFAULT_F32_OPTIONS;
     return <f32>(
-      this.nextF64InRange<f32>(options.min, options.max, options.exclude)
+      this.nextF64InRange<f32>(config.min, config.max, config.exclude)
     );
   }
 
-  f64(options: FloatOptions<f64> = new FloatOptions<f64>()): f64 {
-    return this.nextF64InRange<f64>(options.min, options.max, options.exclude);
+  f64(options: FloatOptions<f64> | null = null): f64 {
+    const config = options != null ? options : DEFAULT_F64_OPTIONS;
+    return this.nextF64InRange<f64>(config.min, config.max, config.exclude);
   }
 
-  bytes(options: BytesOptions = new BytesOptions()): Uint8Array {
-    validateLengthRange("seed.bytes()", options.min, options.max);
-    const length = this.nextRange(options.min, options.max);
+  bytes(options: BytesOptions | null = null): Uint8Array {
+    const config = options != null ? options : DEFAULT_BYTES_OPTIONS;
+    validateLengthRange("seed.bytes()", config.min, config.max);
+    const length = this.nextRange(config.min, config.max);
     const out = new Uint8Array(length);
+    const include = config.include;
+    const exclude = config.exclude;
+    if (include.length) {
+      if (!exclude.length) {
+        for (let i = 0; i < length; i++) {
+          unchecked(
+            (out[i] = <u8>unchecked(include[this.nextRange(0, include.length - 1)])),
+          );
+        }
+        return out;
+      }
+      for (let i = 0; i < length; i++) {
+        unchecked((out[i] = this.byteFromOptions(config)));
+      }
+      return out;
+    }
+    if (!exclude.length) {
+      for (let i = 0; i < length; i++) {
+        unchecked((out[i] = <u8>(this.nextU32() & 0xff)));
+      }
+      return out;
+    }
     for (let i = 0; i < length; i++) {
-      out[i] = this.byteFromOptions(options);
+      unchecked((out[i] = this.byteFromOptions(config)));
     }
     return out;
   }
 
-  buffer(options: BytesOptions = new BytesOptions()): ArrayBuffer {
+  buffer(options: BytesOptions | null = null): ArrayBuffer {
     return this.bytes(options).buffer;
   }
 
-  string(options: StringOptions = new StringOptions()): string {
-    validateLengthRange("seed.string()", options.min, options.max);
-    const alphabet = buildAlphabet(options);
+  string(options: StringOptions | null = null): string {
+    const config = options != null ? options : DEFAULT_STRING_OPTIONS;
+    validateLengthRange("seed.string()", config.min, config.max);
+    const alphabet = buildAlphabet(config);
     if (!alphabet.length) {
       panic();
     }
-    const length = this.nextRange(options.min, options.max);
-    let out = options.prefix;
-    for (let i = 0; i < length; i++) {
-      out += String.fromCharCode(this.pick(alphabet));
+    const coreLength = this.nextRange(config.min, config.max);
+    const prefixLength = config.prefix.length;
+    const suffixLength = config.suffix.length;
+    const totalLength = prefixLength + coreLength + suffixLength;
+    if (!totalLength) return "";
+
+    // Allocate UTF-16 payload directly and fill code units in one pass.
+    const outPtr = __new(<usize>(totalLength << 1), idof<string>());
+    let cursor: usize = outPtr;
+
+    for (let i = 0; i < prefixLength; i++) {
+      store<u16>(cursor, <u16>config.prefix.charCodeAt(i));
+      cursor += 2;
     }
-    out += options.suffix;
-    return out;
+
+    const last = alphabet.length - 1;
+    for (let i = 0; i < coreLength; i++) {
+      store<u16>(cursor, <u16>unchecked(alphabet[this.nextRange(0, last)]));
+      cursor += 2;
+    }
+
+    for (let i = 0; i < suffixLength; i++) {
+      store<u16>(cursor, <u16>config.suffix.charCodeAt(i));
+      cursor += 2;
+    }
+
+    return changetype<string>(outPtr);
   }
 
   array<T>(
     item: (seed: FuzzSeed) => T,
-    options: ArrayOptions = new ArrayOptions(),
+    options: ArrayOptions | null = null,
   ): Array<T> {
-    validateLengthRange("seed.array()", options.min, options.max);
-    const length = this.nextRange(options.min, options.max);
+    const config = options != null ? options : DEFAULT_ARRAY_OPTIONS;
+    validateLengthRange("seed.array()", config.min, config.max);
+    const length = this.nextRange(config.min, config.max);
     const out = new Array<T>(length);
     for (let i = 0; i < length; i++) {
       unchecked((out[i] = item(this)));
@@ -110,17 +179,23 @@ export class FuzzSeed {
     const include = options.include;
     const exclude = options.exclude;
     if (include.length) {
+      if (!exclude.length) {
+        return <u8>unchecked(include[this.nextRange(0, include.length - 1)]);
+      }
       for (let attempts = 0; attempts < 1024; attempts++) {
         const picked = unchecked(
           include[this.nextRange(0, include.length - 1)],
         );
-        if (!exclude.includes(picked)) return picked;
+        if (!containsValue<u8>(exclude, picked)) return picked;
       }
       panic();
     }
+    if (!exclude.length) {
+      return <u8>(this.nextU32() & 0xff);
+    }
     for (let attempts = 0; attempts < 1024; attempts++) {
       const value = <u8>(this.nextU32() & 0xff);
-      if (!exclude.includes(value)) return value;
+      if (!containsValue<u8>(exclude, value)) return value;
     }
     panic();
     return 0;
@@ -128,6 +203,9 @@ export class FuzzSeed {
 
   private nextI32InRange(min: i32, max: i32, exclude: i32[]): i32 {
     if (max < min) panic();
+    if (!exclude.length) {
+      return max <= min ? min : min + <i32>(this.nextU32() % <u32>(max - min + 1));
+    }
     for (let attempts = 0; attempts < 1024; attempts++) {
       const value =
         max <= min ? min : min + <i32>(this.nextU32() % <u32>(max - min + 1));
@@ -139,6 +217,9 @@ export class FuzzSeed {
 
   private nextU32InRange(min: u32, max: u32, exclude: u32[]): u32 {
     if (max < min) panic();
+    if (!exclude.length) {
+      return max <= min ? min : min + (this.nextU32() % (max - min + 1));
+    }
     for (let attempts = 0; attempts < 1024; attempts++) {
       const value = max <= min ? min : min + (this.nextU32() % (max - min + 1));
       if (!containsValue<u32>(exclude, value)) return value;
@@ -151,6 +232,9 @@ export class FuzzSeed {
     const left = <f64>min;
     const right = <f64>max;
     if (right < left) panic();
+    if (!exclude.length) {
+      return left + (right - left) * this.nextUnit();
+    }
     for (let attempts = 0; attempts < 1024; attempts++) {
       const value = left + (right - left) * this.nextUnit();
       if (!containsFloatValue<T>(exclude, changetype<T>(value))) return value;
@@ -169,11 +253,14 @@ export class FuzzSeed {
   }
 
   private nextU32(): u32 {
-    this.state += 0x9e3779b97f4a7c15;
-    let z = this.state;
-    z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
-    z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
-    return <u32>(z ^ (z >> 31));
+    // mulberry32: very fast integer-only PRNG suitable for fuzz input generation.
+    let x = this.state;
+    x += 0x6d2b79f5;
+    this.state = x;
+    let z = x;
+    z = <u32>Math.imul(z ^ (z >> 15), z | 1);
+    z ^= z + <u32>Math.imul(z ^ (z >> 7), z | 61);
+    return z ^ (z >> 14);
   }
 
   private nextU64(): u64 {
@@ -183,6 +270,21 @@ export class FuzzSeed {
   }
 }
 
+const ASCII_ALPHABET: i32[] = rangeChars(32, 126);
+const ALPHA_ALPHABET: i32[] = rangeChars(65, 90).concat(rangeChars(97, 122));
+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,
+]);
+const IDENTIFIER_ALPHABET: i32[] = [95].concat(ALPHA_ALPHABET).concat(
+  DIGIT_ALPHABET,
+);
+const WHITESPACE_ALPHABET: i32[] = [9, 10, 13, 32];
+
 export abstract class FuzzerBase {
   public name: string;
   public skipped: bool;
@@ -409,12 +511,13 @@ export class Fuzzer0<R> extends FuzzerBase {
   run(seedBase: u64, runs: i32): FuzzerResult {
     if (this.skipped) return createSkippedResult(this.name);
     const result = createResult(this.name, runs);
+    const seed = new FuzzSeed(seedBase);
     __fuzz_callback0 = changetype<() => usize>(this.callback);
     __fuzz_returns_bool = this.returnsBool;
     for (let i = 0; i < runs; i++) {
       prepareFuzzIteration();
       __fuzz_calls = 0;
-      const seed = new FuzzSeed(seedBase + <u64>i);
+      seed.reseed(seedBase + <u64>i);
       if (this.generator) {
         this.generator(seed, changetype<() => R>(__fuzz_run0));
       } else {
@@ -469,12 +572,13 @@ export class Fuzzer1<A, R> extends FuzzerBase {
   run(seedBase: u64, runs: i32): FuzzerResult {
     if (this.skipped) return createSkippedResult(this.name);
     const result = createResult(this.name, runs);
+    const seed = new FuzzSeed(seedBase);
     __fuzz_callback1 = changetype<(a: usize) => usize>(this.callback);
     __fuzz_returns_bool = this.returnsBool;
     for (let i = 0; i < runs; i++) {
       prepareFuzzIteration();
       __fuzz_calls = 0;
-      const seed = new FuzzSeed(seedBase + <u64>i);
+      seed.reseed(seedBase + <u64>i);
       if (!this.generator) {
         failFuzzIteration(
           "generate",
@@ -538,12 +642,13 @@ export class Fuzzer2<A, B, R> extends FuzzerBase {
   run(seedBase: u64, runs: i32): FuzzerResult {
     if (this.skipped) return createSkippedResult(this.name);
     const result = createResult(this.name, runs);
+    const seed = new FuzzSeed(seedBase);
     __fuzz_callback2 = changetype<(a: usize, b: usize) => usize>(this.callback);
     __fuzz_returns_bool = this.returnsBool;
     for (let i = 0; i < runs; i++) {
       prepareFuzzIteration();
       __fuzz_calls = 0;
-      const seed = new FuzzSeed(seedBase + <u64>i);
+      seed.reseed(seedBase + <u64>i);
       if (!this.generator) {
         failFuzzIteration(
           "generate",
@@ -606,6 +711,7 @@ export class Fuzzer3<A, B, C, R> extends FuzzerBase {
   run(seedBase: u64, runs: i32): FuzzerResult {
     if (this.skipped) return createSkippedResult(this.name);
     const result = createResult(this.name, runs);
+    const seed = new FuzzSeed(seedBase);
     __fuzz_callback3 = changetype<(a: usize, b: usize, c: usize) => usize>(
       this.callback,
     );
@@ -613,7 +719,7 @@ export class Fuzzer3<A, B, C, R> extends FuzzerBase {
     for (let i = 0; i < runs; i++) {
       prepareFuzzIteration();
       __fuzz_calls = 0;
-      const seed = new FuzzSeed(seedBase + <u64>i);
+      seed.reseed(seedBase + <u64>i);
       if (!this.generator) {
         failFuzzIteration(
           "generate",
@@ -701,13 +807,13 @@ export function createFuzzer<T extends Function>(
 }
 
 function buildAlphabet(options: StringOptions): i32[] {
-  const out = baseAlphabet(options.charset);
-  if (options.charset == "custom") {
-    out.length = 0;
+  if (!options.include.length && !options.exclude.length) {
+    return baseAlphabet(options.charset);
   }
+  const out = baseAlphabet(options.charset).slice(0);
   for (let i = 0; i < options.include.length; i++) {
     const value = unchecked(options.include[i]);
-    if (!out.includes(value)) out.push(value);
+    if (!containsValue<i32>(out, value)) out.push(value);
   }
   for (let i = 0; i < options.exclude.length; i++) {
     removeFirst(out, unchecked(options.exclude[i]));
@@ -716,21 +822,15 @@ function buildAlphabet(options: StringOptions): i32[] {
 }
 
 function baseAlphabet(charset: string): i32[] {
-  if (charset == "alpha") return rangeChars(65, 90).concat(rangeChars(97, 122));
-  if (charset == "alnum")
-    return baseAlphabet("alpha").concat(rangeChars(48, 57));
-  if (charset == "digit") return rangeChars(48, 57);
-  if (charset == "hex") return rangeChars(48, 57).concat(rangeChars(97, 102));
-  if (charset == "base64")
-    return rangeChars(65, 90)
-      .concat(rangeChars(97, 122))
-      .concat(rangeChars(48, 57))
-      .concat([43, 47, 61]);
-  if (charset == "identifier")
-    return [95].concat(baseAlphabet("alpha")).concat(rangeChars(48, 57));
-  if (charset == "whitespace") return [9, 10, 13, 32];
+  if (charset == "alpha") return ALPHA_ALPHABET;
+  if (charset == "alnum") return ALNUM_ALPHABET;
+  if (charset == "digit") return DIGIT_ALPHABET;
+  if (charset == "hex") return HEX_ALPHABET;
+  if (charset == "base64") return BASE64_ALPHABET;
+  if (charset == "identifier") return IDENTIFIER_ALPHABET;
+  if (charset == "whitespace") return WHITESPACE_ALPHABET;
   if (charset == "custom") return [];
-  return rangeChars(32, 126);
+  return ASCII_ALPHABET;
 }
 
 function rangeChars(start: i32, end: i32): i32[] {
@@ -746,6 +846,7 @@ 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/util/wipc.ts

@@ -33,6 +33,7 @@ const MAGIC_C: u8 = 0x43; // C
 const HEADER_SIZE: i32 = 9;
 const IOV_SIZE: usize = sizeof<usize>() * 2;
 const U32_SIZE: usize = sizeof<u32>();
+const REPORT_CHUNK_BYTES: i32 = 65536;
 
 // @ts-ignore
 const IS_BINDINGS: bool = isDefined(AS_TEST_BINDINGS);
@@ -162,7 +163,35 @@ export function requestFuzzConfig(): FuzzConfigReply {
 }
 
 export function sendReport(report: string): void {
-  sendFrame(MessageType.DATA, String.UTF8.encode(report));
+  const payload = String.UTF8.encode(report);
+  if (payload.byteLength <= REPORT_CHUNK_BYTES) {
+    sendFrame(MessageType.DATA, payload);
+    sendFrame(MessageType.CLOSE, new ArrayBuffer(0));
+    return;
+  }
+
+  const totalBytes = payload.byteLength;
+  const chunkCount = (totalBytes + REPORT_CHUNK_BYTES - 1) / REPORT_CHUNK_BYTES;
+  sendJson(
+    MessageType.CALL,
+    `{"kind":"report:start","encoding":"utf8-chunks","totalBytes":${totalBytes.toString()},"chunkCount":${chunkCount.toString()},"chunkBytes":${REPORT_CHUNK_BYTES.toString()}}`,
+  );
+
+  const ptr = changetype<usize>(payload);
+  let offset = 0;
+  while (offset < totalBytes) {
+    const size = min<i32>(REPORT_CHUNK_BYTES, totalBytes - offset);
+    const chunk = new ArrayBuffer(size);
+    memory.copy(changetype<usize>(chunk), ptr + offset, size);
+    sendFrame(MessageType.DATA, chunk);
+    offset += size;
+  }
+
+  sendJson(
+    MessageType.CALL,
+    `{"kind":"report:end","totalBytes":${totalBytes.toString()},"chunkCount":${chunkCount.toString()}}`,
+  );
+  sendFrame(MessageType.CLOSE, new ArrayBuffer(0));
 }
 
 export function sendWarning(message: string): void {

package/bin/commands/fuzz-core.js

@@ -8,6 +8,7 @@ import { persistCrashRecord } from "../crash-store.js";
 const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
 const MAGIC = Buffer.from("WIPC");
 const HEADER_SIZE = 9;
+const MAX_DEFAULT_SEED = 0x7fffffff;
 export async function fuzz(configPath = DEFAULT_CONFIG_PATH, selectors = [], modeName, overrides = {}) {
     const loadedConfig = loadConfig(configPath, false);
     const mode = applyMode(loadedConfig, modeName);
@@ -33,6 +34,9 @@ function resolveFuzzConfig(raw, overrides) {
     if (typeof overrides.seed == "number") {
         config.seed = overrides.seed;
     }
+    else if (config.seed < 0) {
+        config.seed = generateRandomSeed();
+    }
     if (typeof overrides.runs == "number") {
         config.runs = overrides.runs;
     }
@@ -50,6 +54,9 @@ function resolveFuzzConfig(raw, overrides) {
     }
     return config;
 }
+function generateRandomSeed() {
+    return Math.floor(Math.random() * (MAX_DEFAULT_SEED + 1));
+}
 function encodeRunsOverrideKind(kind) {
     switch (kind) {
         case "set":
@@ -71,20 +78,56 @@ async function runFuzzTarget(file, outDir, duplicateBasenames, config, buildStar
     const binary = readFileSync(wasmPath);
     const module = new WebAssembly.Module(binary);
     let report = null;
+    let reportParseError = null;
+    const reportStream = {
+        sawChunkStart: false,
+        sawChunkEnd: false,
+        chunkCountExpected: 0,
+        chunkTotalBytesExpected: 0,
+        chunkFramesReceived: 0,
+        chunkBytesReceived: 0,
+        chunks: [],
+    };
     const captured = captureFrames((type, payload, respond) => {
         if (type == 0x02) {
             const event = JSON.parse(payload.toString("utf8"));
-            if (String(event.kind ?? "") == "fuzz:config") {
+            const kind = String(event.kind ?? "");
+            if (kind == "fuzz:config") {
                 const resolved = config;
                 respond(`${config.runs}\n${config.seed}\n${resolved.runsOverrideKind ?? 0}\n${resolved.runsOverrideValue ?? 0}`);
             }
+            else if (kind == "report:start") {
+                reportStream.sawChunkStart = true;
+                reportStream.sawChunkEnd = false;
+                reportStream.chunkCountExpected = Number(event.chunkCount ?? 0);
+                reportStream.chunkTotalBytesExpected = Number(event.totalBytes ?? 0);
+                reportStream.chunkFramesReceived = 0;
+                reportStream.chunkBytesReceived = 0;
+                reportStream.chunks = [];
+            }
+            else if (kind == "report:end") {
+                reportStream.sawChunkEnd = true;
+            }
             else {
                 respond("");
             }
             return;
         }
         if (type == 0x03) {
-            report = JSON.parse(payload.toString("utf8"));
+            if (reportStream.sawChunkStart && !reportStream.sawChunkEnd) {
+                reportStream.chunkFramesReceived++;
+                reportStream.chunkBytesReceived += payload.length;
+                reportStream.chunks.push(payload.toString("utf8"));
+            }
+            else {
+                try {
+                    report = JSON.parse(payload.toString("utf8"));
+                    reportParseError = null;
+                }
+                catch (error) {
+                    reportParseError = String(error);
+                }
+            }
         }
     });
     try {
@@ -119,14 +162,35 @@ async function runFuzzTarget(file, outDir, duplicateBasenames, config, buildStar
         };
     }
     const passthrough = captured.restore();
+    if (reportStream.sawChunkStart) {
+        if (reportStream.sawChunkEnd) {
+            const chunkedPayload = reportStream.chunks.join("");
+            try {
+                report = JSON.parse(chunkedPayload);
+                reportParseError = null;
+            }
+            catch (error) {
+                reportParseError = String(error);
+            }
+        }
+    }
     if (!report?.fuzzers) {
+        const diagnostics = [
+            `chunked=${reportStream.sawChunkStart ? "yes" : "no"}`,
+            `chunkStart=${reportStream.sawChunkStart ? "yes" : "no"}`,
+            `chunkEnd=${reportStream.sawChunkEnd ? "yes" : "no"}`,
+            `chunkFrames=${reportStream.chunkFramesReceived}`,
+            `expectedChunkFrames=${reportStream.chunkCountExpected}`,
+            `chunkBytes=${reportStream.chunkBytesReceived}`,
+            `expectedChunkBytes=${reportStream.chunkTotalBytesExpected}`,
+        ].join(", ");
         const crash = persistCrashRecord(config.crashDir, {
             kind: "fuzz",
             file,
             entryKey: buildFuzzCrashEntryKey(file, modeName ?? "default"),
             mode: modeName ?? "default",
             seed: config.seed,
-            error: `missing fuzz report payload from ${path.basename(file)}`,
+            error: `${reportParseError ? `invalid fuzz report payload: ${reportParseError}` : `missing fuzz report payload from ${path.basename(file)}`} (${diagnostics})`,
             stdout: passthrough.stdout,
             stderr: "",
         });

package/bin/commands/init-core.js

@@ -472,7 +472,6 @@ function applyInit(root, target, example, fuzzExample, force) {
                 fuzz: {
                     input: ["assembly/__fuzz__/*.fuzz.ts"],
                     runs: 1000,
-                    seed: 1337,
                     target: "bindings",
                     corpusDir: ".as-test/corpus",
                     crashDir: ".as-test/crashes",

package/bin/commands/run-core.js

@@ -1483,6 +1483,31 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
     let stderrPendingLine = "";
     let stdoutBuffer = "";
     let spawnError = null;
+    let sawChannelClose = false;
+    const runtimeEvents = {
+        sawFileStart: false,
+        sawFileEnd: false,
+        fileName: path.basename(specFile),
+        fileVerdict: "none",
+        fileTime: "",
+        suiteStarts: 0,
+        suiteEnds: 0,
+        assertionFails: 0,
+        warnings: 0,
+        logs: 0,
+    };
+    const reportStream = {
+        dataFrames: 0,
+        dataBytes: 0,
+        sawChunkStart: false,
+        sawChunkEnd: false,
+        chunkCountExpected: 0,
+        chunkBytesExpected: 0,
+        chunkTotalBytesExpected: 0,
+        chunkFramesReceived: 0,
+        chunkBytesReceived: 0,
+        chunks: [],
+    };
     child.on("error", (error) => {
         spawnError = error;
     });
@@ -1512,6 +1537,7 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
             const event = msg;
             const kind = String(event.kind ?? "");
             if (kind === "event:assert-fail") {
+                runtimeEvents.assertionFails++;
                 reporter.onAssertionFail?.({
                     key: String(event.key ?? ""),
                     instr: String(event.instr ?? ""),
@@ -1522,6 +1548,8 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
                 return;
             }
             if (kind === "event:file-start") {
+                runtimeEvents.sawFileStart = true;
+                runtimeEvents.fileName = String(event.file ?? runtimeEvents.fileName);
                 reporter.onFileStart?.({
                     file: String(event.file ?? "unknown"),
                     depth: 0,
@@ -1531,6 +1559,10 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
                 return;
             }
             if (kind === "event:file-end") {
+                runtimeEvents.sawFileEnd = true;
+                runtimeEvents.fileName = String(event.file ?? runtimeEvents.fileName);
+                runtimeEvents.fileVerdict = String(event.verdict ?? "none");
+                runtimeEvents.fileTime = String(event.time ?? "");
                 reporter.onFileEnd?.({
                     file: String(event.file ?? "unknown"),
                     depth: 0,
@@ -1542,6 +1574,7 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
                 return;
             }
             if (kind === "event:suite-start") {
+                runtimeEvents.suiteStarts++;
                 reporter.onSuiteStart?.({
                     file: String(event.file ?? "unknown"),
                     depth: Number(event.depth ?? 0),
@@ -1551,6 +1584,7 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
                 return;
             }
             if (kind === "event:suite-end") {
+                runtimeEvents.suiteEnds++;
                 reporter.onSuiteEnd?.({
                     file: String(event.file ?? "unknown"),
                     depth: Number(event.depth ?? 0),
@@ -1561,12 +1595,14 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
                 return;
             }
             if (kind === "event:warn") {
+                runtimeEvents.warnings++;
                 reporter.onWarning?.({
                     message: String(event.message ?? ""),
                 });
                 return;
             }
             if (kind === "event:log") {
+                runtimeEvents.logs++;
                 reporter.onLog?.({
                     file: String(event.file ?? "unknown"),
                     depth: Number(event.depth ?? 0),
@@ -1584,16 +1620,43 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
                 this.send(MessageType.CALL, Buffer.from(`${result.ok ? "1" : "0"}\n${result.expected}`, "utf8"));
                 return;
             }
+            if (kind === "report:start") {
+                reportStream.sawChunkStart = true;
+                reportStream.sawChunkEnd = false;
+                reportStream.chunkCountExpected = Number(event.chunkCount ?? 0);
+                reportStream.chunkBytesExpected = Number(event.chunkBytes ?? 0);
+                reportStream.chunkTotalBytesExpected = Number(event.totalBytes ?? 0);
+                reportStream.chunkFramesReceived = 0;
+                reportStream.chunkBytesReceived = 0;
+                reportStream.chunks = [];
+                return;
+            }
+            if (kind === "report:end") {
+                reportStream.sawChunkEnd = true;
+                return;
+            }
             this.sendJSON(MessageType.CALL, { ok: true, expected: "" });
         }
         onDataMessage(data) {
+            reportStream.dataFrames++;
+            reportStream.dataBytes += data.length;
+            if (reportStream.sawChunkStart && !reportStream.sawChunkEnd) {
+                reportStream.chunkFramesReceived++;
+                reportStream.chunkBytesReceived += data.length;
+                reportStream.chunks.push(data.toString("utf8"));
+                return;
+            }
             try {
                 report = JSON.parse(data.toString("utf8"));
+                parseError = null;
             }
             catch (error) {
                 parseError = String(error);
             }
         }
+        onClose() {
+            sawChannelClose = true;
+        }
     }
     const _channel = new TestChannel(child.stdout, child.stdin);
     const code = await new Promise((resolve) => {
@@ -1614,29 +1677,93 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
         });
         return createRuntimeFailureReport(specFile, modeName, "failed to start test runtime", errorText, stdoutBuffer, stderrBuffer);
     }
+    if (reportStream.sawChunkStart) {
+        if (!reportStream.sawChunkEnd) {
+            parseError =
+                parseError ??
+                    "missing report:end marker for chunked report payload";
+        }
+        else {
+            const chunkedPayload = reportStream.chunks.join("");
+            try {
+                report = JSON.parse(chunkedPayload);
+                parseError = null;
+            }
+            catch (error) {
+                parseError = `could not parse chunked report payload: ${String(error)}`;
+            }
+            if (reportStream.chunkCountExpected > 0 &&
+                reportStream.chunkFramesReceived !== reportStream.chunkCountExpected) {
+                parseError =
+                    parseError ??
+                        `chunk count mismatch: expected ${reportStream.chunkCountExpected}, received ${reportStream.chunkFramesReceived}`;
+            }
+            if (reportStream.chunkTotalBytesExpected > 0 &&
+                reportStream.chunkBytesReceived !== reportStream.chunkTotalBytesExpected) {
+                parseError =
+                    parseError ??
+                        `chunk size mismatch: expected ${reportStream.chunkTotalBytesExpected} bytes, received ${reportStream.chunkBytesReceived}`;
+            }
+        }
+    }
     if (parseError) {
         const errorText = `could not parse report payload: ${parseError}`;
+        const diagnostics = buildRuntimeReportDiagnostics(code, sawChannelClose, reportStream, runtimeEvents);
+        const fullError = `${errorText}\n${diagnostics}`;
         persistCrashRecord(crashDir, {
             kind: "test",
             file: specFile,
             mode: modeName ?? "default",
-            error: errorText,
+            error: fullError,
             stdout: stdoutBuffer,
             stderr: stderrBuffer,
         });
-        return createRuntimeFailureReport(specFile, modeName, "runtime returned an invalid report payload", errorText, stdoutBuffer, stderrBuffer);
+        return createRuntimeFailureReport(specFile, modeName, "runtime returned an invalid report payload", fullError, stdoutBuffer, stderrBuffer);
     }
     if (!report) {
+        const synthesized = synthesizeReportFromRuntimeEvents(specFile, runtimeEvents);
+        if (synthesized) {
+            reporter.onWarning?.({
+                message: "runtime report payload missing; reconstructed result from streamed lifecycle events",
+            });
+            if (code !== 0 || hasMeaningfulRuntimeOutput(stderrBuffer)) {
+                const errorParts = [];
+                if (code !== 0) {
+                    errorParts.push(`child process exited with code ${code}`);
+                }
+                const stderrText = normalizeRuntimeOutput(stderrBuffer);
+                if (stderrText.length) {
+                    errorParts.push(stderrText);
+                }
+                const diagnostics = buildRuntimeReportDiagnostics(code, sawChannelClose, reportStream, runtimeEvents);
+                errorParts.push(diagnostics);
+                const errorText = errorParts.join("\n\n");
+                persistCrashRecord(crashDir, {
+                    kind: "test",
+                    file: specFile,
+                    mode: modeName ?? "default",
+                    error: errorText || "runtime reported an unknown error",
+                    stdout: stdoutBuffer,
+                    stderr: stderrBuffer,
+                });
+                return appendRuntimeFailureReport(synthesized, specFile, modeName, code !== 0
+                    ? `test runtime failed with exit code ${code}`
+                    : "test runtime wrote to stderr", errorText, stdoutBuffer, stderrBuffer);
+            }
+            return synthesized;
+        }
         const errorText = "missing report payload from test runtime";
+        const diagnostics = buildRuntimeReportDiagnostics(code, sawChannelClose, reportStream, runtimeEvents);
+        const fullError = `${errorText}\n${diagnostics}`;
         persistCrashRecord(crashDir, {
             kind: "test",
             file: specFile,
             mode: modeName ?? "default",
-            error: errorText,
+            error: fullError,
             stdout: stdoutBuffer,
             stderr: stderrBuffer,
         });
-        return createRuntimeFailureReport(specFile, modeName, "test runtime exited without sending a report", errorText, stdoutBuffer, stderrBuffer);
+        return createRuntimeFailureReport(specFile, modeName, "test runtime exited without sending a report", fullError, stdoutBuffer, stderrBuffer);
     }
     if (code !== 0 || hasMeaningfulRuntimeOutput(stderrBuffer)) {
         const errorParts = [];
@@ -1662,6 +1789,52 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
     }
     return report;
 }
+function synthesizeReportFromRuntimeEvents(specFile, runtimeEvents) {
+    if (!runtimeEvents.sawFileEnd &&
+        runtimeEvents.suiteStarts <= 0 &&
+        runtimeEvents.suiteEnds <= 0) {
+        return null;
+    }
+    let verdict = runtimeEvents.fileVerdict;
+    if (verdict == "none" && runtimeEvents.assertionFails > 0) {
+        verdict = "fail";
+    }
+    else if (verdict == "none" && runtimeEvents.sawFileEnd) {
+        verdict = "ok";
+    }
+    return {
+        suites: [
+            {
+                file: specFile,
+                description: runtimeEvents.fileName || path.basename(specFile),
+                depth: 0,
+                kind: "file",
+                verdict,
+                time: {
+                    start: 0,
+                    end: 0,
+                },
+                suites: [],
+                logs: [],
+                tests: [],
+            },
+        ],
+        coverage: {
+            total: 0,
+            covered: 0,
+            uncovered: 0,
+            percent: 100,
+            points: [],
+        },
+    };
+}
+function buildRuntimeReportDiagnostics(code, sawChannelClose, reportStream, runtimeEvents) {
+    return [
+        `runtime diagnostics: exitCode=${code}, channelClose=${sawChannelClose ? "yes" : "no"}`,
+        `report stream: dataFrames=${reportStream.dataFrames}, dataBytes=${reportStream.dataBytes}, chunked=${reportStream.sawChunkStart ? "yes" : "no"}, chunkStart=${reportStream.sawChunkStart ? "yes" : "no"}, chunkEnd=${reportStream.sawChunkEnd ? "yes" : "no"}, chunkFrames=${reportStream.chunkFramesReceived}, expectedChunkFrames=${reportStream.chunkCountExpected}, chunkBytes=${reportStream.chunkBytesReceived}, expectedChunkBytes=${reportStream.chunkTotalBytesExpected}`,
+        `runtime events: fileStart=${runtimeEvents.sawFileStart ? "yes" : "no"}, fileEnd=${runtimeEvents.sawFileEnd ? "yes" : "no"}, fileVerdict=${runtimeEvents.fileVerdict}, suiteStarts=${runtimeEvents.suiteStarts}, suiteEnds=${runtimeEvents.suiteEnds}, assertionFails=${runtimeEvents.assertionFails}, warnings=${runtimeEvents.warnings}, logs=${runtimeEvents.logs}`,
+    ].join("\n");
+}
 function createRuntimeFailureReport(specFile, modeName, title, details, stdout, stderr) {
     return appendRuntimeFailureReport({
         suites: [],

package/bin/index.js

@@ -282,7 +282,7 @@ function printCommandHelp(command) {
         process.stdout.write("  --disable <feature>      Disable feature (coverage|try-as)\n");
         process.stdout.write("  --fuzz                   Run fuzz targets after the normal test pass\n");
         process.stdout.write("  --fuzz-runs <value>      Override fuzz iteration count, e.g. 500, 1.5x, +10%, +100000\n");
-        process.stdout.write("  --fuzz-seed <n>          Override fuzz seed for this run\n");
+        process.stdout.write("  --fuzz-seed <n>          Pin fuzz seed for this run (default uses random seed)\n");
         process.stdout.write("  --parallel              Run files through an ordered worker pool using an automatic worker count\n");
         process.stdout.write("  --jobs <n>               Run files through an ordered worker pool\n");
         process.stdout.write("  --build-jobs <n>         Limit concurrent build tasks (defaults to --jobs)\n");
@@ -303,7 +303,7 @@ function printCommandHelp(command) {
         process.stdout.write("  --config <path>          Use a specific config file\n");
         process.stdout.write("  --mode <name[,name...]>  Run one or multiple named config modes\n");
         process.stdout.write("  --runs <value>           Override fuzz iteration count, e.g. 500, 1.5x, +10%, +100000\n");
-        process.stdout.write("  --seed <n>               Override fuzz seed\n");
+        process.stdout.write("  --seed <n>               Pin fuzz seed (default uses random seed)\n");
         process.stdout.write("  --jobs <n>               Run files through an ordered worker pool\n");
         process.stdout.write("  --build-jobs <n>         Limit concurrent build tasks (defaults to --jobs)\n");
         process.stdout.write("  --run-jobs <n>           Limit concurrent run tasks (defaults to --jobs)\n");

package/bin/reporters/default.js

@@ -354,8 +354,8 @@ function renderFailedFuzzers(results) {
                     rendered = true;
                 }
                 console.log(`${chalk.bgRed(" FAIL ")} ${formatFuzzFailureTitle(modeResult.file, fuzzer.name)}`);
-                if (fuzzer.failure?.message?.length) {
-                    console.log(chalk.dim(`Message: ${fuzzer.failure.message}`));
+                if (fuzzer.failure) {
+                    renderAssertionFailureDetails(fuzzer.failure.left, fuzzer.failure.right, fuzzer.failure.message);
                 }
                 console.log(chalk.dim(`Mode: ${modeResult.modeName}`));
                 console.log(chalk.dim(`Runs: ${fuzzer.passed + fuzzer.failed + fuzzer.crashed} completed (${fuzzer.passed} passed, ${fuzzer.failed} failed, ${fuzzer.crashed} crashed)`));
@@ -487,52 +487,11 @@ function collectSuiteFailures(suite, file, path, printed) {
         if (printed.has(dedupeKey))
             continue;
         printed.add(dedupeKey);
-        const left = JSON.stringify(test.left);
-        const right = JSON.stringify(test.right);
-        if (left == "null" && right == "null") {
-            console.log(`${chalk.bgRed(" FAIL ")} ${chalk.dim(title)} ${chalk.dim("(" + where + ")")}`);
-            if (modeName.length) {
-                console.log(chalk.dim(`Mode: ${modeName}`));
-            }
-            const normalizedMessage = normalizeFailureMessage(message);
-            if (normalizedMessage.length) {
-                for (const line of normalizedMessage.split("\n")) {
-                    console.log(chalk.dim(line));
-                }
-            }
-            else {
-                console.log(chalk.dim("runtime error"));
-            }
-            console.log("");
-            continue;
-        }
-        const diffResult = diff(left, right);
-        let expected = "";
-        for (const res of diffResult.diff) {
-            switch (res.type) {
-                case "correct":
-                    expected += chalk.dim(res.value);
-                    break;
-                case "extra":
-                    expected += chalk.red.strikethrough(res.value);
-                    break;
-                case "missing":
-                    expected += chalk.bgBlack(res.value);
-                    break;
-                case "wrong":
-                    expected += chalk.bgRed(res.value);
-                    break;
-                case "untouched":
-                case "spacer":
-                    break;
-            }
-        }
         console.log(`${chalk.bgRed(" FAIL ")} ${chalk.dim(title)} ${chalk.dim("(" + where + ")")}`);
         if (modeName.length) {
             console.log(chalk.dim(`Mode: ${modeName}`));
         }
-        console.log(`${chalk.dim("(expected) ->")} ${expected}`);
-        console.log(`${chalk.dim("(received) ->")} ${chalk.dim(left)}\n`);
+        renderAssertionFailureDetails(test.left, test.right, message);
     }
     const suites = Array.isArray(suiteAny.suites)
         ? suiteAny.suites
@@ -544,6 +503,46 @@ function collectSuiteFailures(suite, file, path, printed) {
 function normalizeFailureMessage(message) {
     return message.replace(/\r\n/g, "\n").trim();
 }
+function renderAssertionFailureDetails(leftRaw, rightRaw, messageRaw) {
+    const left = JSON.stringify(leftRaw);
+    const right = JSON.stringify(rightRaw);
+    const message = String(messageRaw ?? "");
+    if (left == "null" && right == "null") {
+        const normalizedMessage = normalizeFailureMessage(message);
+        if (normalizedMessage.length) {
+            for (const line of normalizedMessage.split("\n")) {
+                console.log(chalk.dim(line));
+            }
+        }
+        else {
+            console.log(chalk.dim("runtime error"));
+        }
+        return;
+    }
+    const diffResult = diff(left, right);
+    let expected = "";
+    for (const res of diffResult.diff) {
+        switch (res.type) {
+            case "correct":
+                expected += chalk.dim(res.value);
+                break;
+            case "extra":
+                expected += chalk.red.strikethrough(res.value);
+                break;
+            case "missing":
+                expected += chalk.bgBlack(res.value);
+                break;
+            case "wrong":
+                expected += chalk.bgRed(res.value);
+                break;
+            case "untouched":
+            case "spacer":
+                break;
+        }
+    }
+    console.log(`${chalk.dim("(expected) ->")} ${expected}`);
+    console.log(`${chalk.dim("(received) ->")} ${chalk.dim(left)}\n`);
+}
 function renderSnapshotSummary(snapshotSummary, leadingGap = true) {
     if (leadingGap) {
         console.log("");

package/bin/types.js

@@ -77,7 +77,7 @@ export class FuzzConfig {
     constructor() {
         this.input = ["./assembly/__fuzz__/*.fuzz.ts"];
         this.runs = 1000;
-        this.seed = 1337;
+        this.seed = -1;
         this.maxInputBytes = 4096;
         this.target = "bindings";
         this.corpusDir = "./.as-test/fuzz/corpus";

package/bin/util.js

@@ -115,7 +115,7 @@ export function loadConfig(CONFIG_PATH, warn = false) {
                 ? [fuzzRaw.input]
                 : new FuzzConfig().input;
         config.fuzz.runs = normalizePositiveNumber(config.fuzz.runs, 1000);
-        config.fuzz.seed = normalizeNonNegativeNumber(config.fuzz.seed, 1337);
+        config.fuzz.seed = normalizeNonNegativeNumber(config.fuzz.seed, -1);
         config.fuzz.maxInputBytes = normalizePositiveNumber(config.fuzz.maxInputBytes, 4096);
         config.fuzz.target =
             typeof config.fuzz.target == "string" && config.fuzz.target.length

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -68,6 +68,8 @@
     "test": "node ./bin/index.js test --parallel",
     "test:ci": "node ./bin/index.js test --parallel --tap --config ./as-test.ci.config.json",
     "fuzz": "node ./bin/index.js fuzz",
+    "bench:seed": "node ./bin/index.js fuzz --config ./as-test.bench.config.json --clean",
+    "bench:seed:compare": "bash ./tools/bench-seed-compare.sh 7",
     "test:examples": "npm --prefix ./examples run test",
     "ci:act": "bash ./tools/act.sh push",
     "ci:act:pr": "bash ./tools/act.sh pull_request",

package/transform/lib/coverage.js

@@ -34,7 +34,10 @@ const COVERAGE_IGNORED_BUILTINS = new Set([
     "isReference",
     "isSigned",
     "isString",
+    "isVector",
+    "isVoid",
     "isUnsigned",
+    "lengthof",
     "load",
     "nameof",
     "offsetof",