as-test 1.0.13 → 1.0.15

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Change Log
 
+## 2026-05-04 - v1.0.15
+
+- fix: path resolving
+- 
+## 2026-05-04 - v1.0.14
+
+### Fuzzing
+
+- feat: add `FuzzSeed` helpers for `i8`, `u8`, `i16`, `u16`, `i64`, `u64`, and `bool()`.
+- feat: make integer `FuzzSeed` helpers default to the full range of their target type when no options are provided, instead of collapsing to `0`.
+- perf: add unchecked full-range fast paths for default integer seed generation while keeping explicit user-provided ranges validated.
+
 ## 2025-05-03 - v1.0.13
 
 - feat: add `--fuzzer` / `--fuzzers` filtering for `ast fuzz` and `ast test --fuzz`, accept `--suite` / `--suites` as fuzz aliases, and include target-specific repro commands in fuzz failure output.

package/README.md

@@ -365,6 +365,36 @@ If you want to keep more than one runtime around, use modes:
 }
 ```
 
+Modes can also be full config objects. That means a mode can override fuzzing, input globs, output aliases, runtime, build flags, and the rest of the normal config surface:
+
+```json
+{
+  "modes": {
+    "web": {
+      "fuzz": {
+        "input": ["./assembly/__fuzz__/web/*.fuzz.ts"],
+        "runs": 200
+      },
+      "runOptions": {
+        "runtime": {
+          "browser": "chromium"
+        }
+      }
+    }
+  }
+}
+```
+
+If you prefer to keep one mode in a separate file, point the mode directly at that config file:
+
+```json
+{
+  "modes": {
+    "simd": "./as-test.config.simd.json"
+  }
+}
+```
+
 Run a specific mode with:
 
 ```bash

package/as-test.config.schema.json

@@ -294,11 +294,43 @@
     },
     "modes": {
       "type": "object",
-      "description": "Named build/run modes. Each mode can override target/args/runtime/env and artifact directories.",
+      "description": "Named build/run modes. Each mode can be a config object or a path to another as-test config file.",
       "additionalProperties": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
+        "oneOf": [
+          {
+            "type": "string",
+            "description": "Path to another as-test config file used as the selected mode's override config."
+          },
+          {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "$schema": {
+                "type": "string"
+              },
+              "input": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "output": {
+                "oneOf": [
+                  {
+                    "type": "string"
+                  },
+                  {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "properties": {
+                      "build": { "type": "string" },
+                      "logs": { "type": "string" },
+                      "coverage": { "type": "string" },
+                      "snapshots": { "type": "string" }
+                    }
+                  }
+                ]
+              },
           "outDir": {
             "type": "string",
             "description": "Mode-specific build output directory. If omitted, defaults to <outDir>/<mode-name>."
@@ -339,6 +371,38 @@
               }
             ]
           },
+          "fuzz": {
+            "type": "object",
+            "additionalProperties": false,
+            "description": "Mode-specific fuzz overrides applied before running `ast fuzz` or `ast test --fuzz` in this mode.",
+            "properties": {
+              "input": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "runs": {
+                "type": "number"
+              },
+              "seed": {
+                "type": "number"
+              },
+              "maxInputBytes": {
+                "type": "number"
+              },
+              "target": {
+                "type": "string",
+                "enum": ["bindings"]
+              },
+              "corpusDir": {
+                "type": "string"
+              },
+              "crashDir": {
+                "type": "string"
+              }
+            }
+          },
           "buildOptions": {
             "type": "object",
             "additionalProperties": false,
@@ -469,7 +533,9 @@
               }
             ]
           }
-        }
+            }
+          }
+        ]
       },
       "default": {}
     },

package/assembly/as-test.intellisense.d.ts

@@ -45,8 +45,16 @@ declare module "as-test" {
   }
 
   export interface FuzzSeed {
+    boolean(): boolean;
+    bool(): boolean;
+    i8(options?: IntellisenseIntegerOptions): number;
+    u8(options?: IntellisenseIntegerOptions): number;
+    i16(options?: IntellisenseIntegerOptions): number;
+    u16(options?: IntellisenseIntegerOptions): number;
     i32(options?: IntellisenseIntegerOptions): number;
     u32(options?: IntellisenseIntegerOptions): number;
+    i64(options?: IntellisenseIntegerOptions): number;
+    u64(options?: IntellisenseIntegerOptions): number;
     f32(options?: IntellisenseFloatOptions): number;
     f64(options?: IntellisenseFloatOptions): number;
     bytes(options?: IntellisenseBytesOptions): Uint8Array;

package/assembly/src/fuzz.ts

@@ -34,13 +34,20 @@ 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();
+const I64_SIGN_MASK: u64 = 0x8000000000000000;
+const EMPTY_I8_EXCLUDE: i8[] = [];
+const EMPTY_U8_EXCLUDE: u8[] = [];
+const EMPTY_I16_EXCLUDE: i16[] = [];
+const EMPTY_U16_EXCLUDE: u16[] = [];
+const EMPTY_I32_EXCLUDE: i32[] = [];
+const EMPTY_U32_EXCLUDE: u32[] = [];
+const EMPTY_I64_EXCLUDE: i64[] = [];
+const EMPTY_U64_EXCLUDE: u64[] = [];
 
 export class FuzzSeed {
   private state: u32;
@@ -61,19 +68,99 @@ export class FuzzSeed {
     return (this.nextU32() & 1) == 1;
   }
 
+  bool(): bool {
+    return this.boolean();
+  }
+
   pick<T>(values: T[]): T {
     if (!values.length) panic();
     return unchecked(values[this.nextRange(0, values.length - 1)]);
   }
 
+  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(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(options.min, options.max, options.exclude, true);
+  }
+
+  i16(options: IntegerOptions<i16> | null = null): i16 {
+    if (options == null) {
+      return this.nextI16InRange(
+        i16.MIN_VALUE,
+        i16.MAX_VALUE,
+        EMPTY_I16_EXCLUDE,
+        false,
+      );
+    }
+    return this.nextI16InRange(options.min, options.max, options.exclude, true);
+  }
+
+  u16(options: IntegerOptions<u16> | null = null): u16 {
+    if (options == null) {
+      return this.nextU16InRange(
+        u16.MIN_VALUE,
+        u16.MAX_VALUE,
+        EMPTY_U16_EXCLUDE,
+        false,
+      );
+    }
+    return this.nextU16InRange(options.min, options.max, options.exclude, true);
+  }
+
   i32(options: IntegerOptions<i32> | null = null): i32 {
-    const config = options != null ? options : DEFAULT_I32_OPTIONS;
-    return this.nextI32InRange(config.min, config.max, config.exclude);
+    if (options == null) {
+      return this.nextI32InRange(
+        i32.MIN_VALUE,
+        i32.MAX_VALUE,
+        EMPTY_I32_EXCLUDE,
+        false,
+      );
+    }
+    return this.nextI32InRange(options.min, options.max, options.exclude, true);
   }
 
   u32(options: IntegerOptions<u32> | null = null): u32 {
-    const config = options != null ? options : DEFAULT_U32_OPTIONS;
-    return this.nextU32InRange(config.min, config.max, config.exclude);
+    if (options == null) {
+      return this.nextU32InRange(
+        u32.MIN_VALUE,
+        u32.MAX_VALUE,
+        EMPTY_U32_EXCLUDE,
+        false,
+      );
+    }
+    return this.nextU32InRange(options.min, options.max, options.exclude, true);
+  }
+
+  i64(options: IntegerOptions<i64> | null = null): i64 {
+    if (options == null) {
+      return this.nextI64InRange(
+        i64.MIN_VALUE,
+        i64.MAX_VALUE,
+        EMPTY_I64_EXCLUDE,
+        false,
+      );
+    }
+    return this.nextI64InRange(options.min, options.max, options.exclude, true);
+  }
+
+  u64(options: IntegerOptions<u64> | null = null): u64 {
+    if (options == null) {
+      return this.nextU64InRange(
+        u64.MIN_VALUE,
+        u64.MAX_VALUE,
+        EMPTY_U64_EXCLUDE,
+        false,
+      );
+    }
+    return this.nextU64InRange(options.min, options.max, options.exclude, true);
   }
 
   f32(options: FloatOptions<f32> | null = null): f32 {
@@ -201,8 +288,16 @@ export class FuzzSeed {
     return 0;
   }
 
-  private nextI32InRange(min: i32, max: i32, exclude: i32[]): i32 {
-    if (max < min) panic();
+  private nextI32InRange(
+    min: i32,
+    max: i32,
+    exclude: i32[],
+    validateRange: bool = true,
+  ): i32 {
+    if (validateRange && max < min) panic();
+    if (!validateRange && min == i32.MIN_VALUE && max == i32.MAX_VALUE) {
+      return <i32>this.nextU32();
+    }
     if (!exclude.length) {
       return max <= min ? min : min + <i32>(this.nextU32() % <u32>(max - min + 1));
     }
@@ -215,8 +310,120 @@ export class FuzzSeed {
     return min;
   }
 
-  private nextU32InRange(min: u32, max: u32, exclude: u32[]): u32 {
-    if (max < min) panic();
+  private nextI8InRange(
+    min: i8,
+    max: i8,
+    exclude: i8[],
+    validateRange: bool = true,
+  ): i8 {
+    if (validateRange && max < min) panic();
+    if (!validateRange && min == i8.MIN_VALUE && max == i8.MAX_VALUE) {
+      return <i8>this.nextU32();
+    }
+    const left = <i32>min;
+    const right = <i32>max;
+    if (!exclude.length) {
+      return <i8>(
+        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))
+      );
+      if (!containsValue<i8>(exclude, value)) return value;
+    }
+    panic();
+    return min;
+  }
+
+  private nextU8InRange(
+    min: u8,
+    max: u8,
+    exclude: u8[],
+    validateRange: bool = true,
+  ): u8 {
+    if (validateRange && max < min) panic();
+    if (!validateRange && min == u8.MIN_VALUE && max == u8.MAX_VALUE) {
+      return <u8>this.nextU32();
+    }
+    const left = <u32>min;
+    const right = <u32>max;
+    if (!exclude.length) {
+      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))
+      );
+      if (!containsValue<u8>(exclude, value)) return value;
+    }
+    panic();
+    return min;
+  }
+
+  private nextI16InRange(
+    min: i16,
+    max: i16,
+    exclude: i16[],
+    validateRange: bool = true,
+  ): i16 {
+    if (validateRange && max < min) panic();
+    if (!validateRange && min == i16.MIN_VALUE && max == i16.MAX_VALUE) {
+      return <i16>this.nextU32();
+    }
+    const left = <i32>min;
+    const right = <i32>max;
+    if (!exclude.length) {
+      return <i16>(
+        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))
+      );
+      if (!containsValue<i16>(exclude, value)) return value;
+    }
+    panic();
+    return min;
+  }
+
+  private nextU16InRange(
+    min: u16,
+    max: u16,
+    exclude: u16[],
+    validateRange: bool = true,
+  ): u16 {
+    if (validateRange && max < min) panic();
+    if (!validateRange && min == u16.MIN_VALUE && max == u16.MAX_VALUE) {
+      return <u16>this.nextU32();
+    }
+    const left = <u32>min;
+    const right = <u32>max;
+    if (!exclude.length) {
+      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))
+      );
+      if (!containsValue<u16>(exclude, value)) return value;
+    }
+    panic();
+    return min;
+  }
+
+  private nextU32InRange(
+    min: u32,
+    max: u32,
+    exclude: u32[],
+    validateRange: bool = true,
+  ): u32 {
+    if (validateRange && max < min) panic();
+    if (!validateRange && min == u32.MIN_VALUE && max == u32.MAX_VALUE) {
+      return this.nextU32();
+    }
     if (!exclude.length) {
       return max <= min ? min : min + (this.nextU32() % (max - min + 1));
     }
@@ -228,6 +435,52 @@ export class FuzzSeed {
     return min;
   }
 
+  private nextI64InRange(
+    min: i64,
+    max: i64,
+    exclude: i64[],
+    validateRange: bool = true,
+  ): i64 {
+    if (validateRange && max < min) panic();
+    if (!validateRange && min == i64.MIN_VALUE && max == i64.MAX_VALUE) {
+      return <i64>this.nextU64();
+    }
+    const left = this.toOrderedU64(min);
+    const right = this.toOrderedU64(max);
+    if (!exclude.length) {
+      return this.fromOrderedU64(
+        left + this.nextU64Offset(left, right),
+      );
+    }
+    for (let attempts = 0; attempts < 1024; attempts++) {
+      const value = this.fromOrderedU64(left + this.nextU64Offset(left, right));
+      if (!containsValue<i64>(exclude, value)) return value;
+    }
+    panic();
+    return min;
+  }
+
+  private nextU64InRange(
+    min: u64,
+    max: u64,
+    exclude: u64[],
+    validateRange: bool = true,
+  ): u64 {
+    if (validateRange && max < min) panic();
+    if (!validateRange && min == u64.MIN_VALUE && max == u64.MAX_VALUE) {
+      return this.nextU64();
+    }
+    if (!exclude.length) {
+      return min + this.nextU64Offset(min, max);
+    }
+    for (let attempts = 0; attempts < 1024; attempts++) {
+      const value = min + this.nextU64Offset(min, max);
+      if (!containsValue<u64>(exclude, value)) return value;
+    }
+    panic();
+    return min;
+  }
+
   private nextF64InRange<T>(min: T, max: T, exclude: T[]): f64 {
     const left = <f64>min;
     const right = <f64>max;
@@ -268,6 +521,20 @@ export class FuzzSeed {
     const lo = <u64>this.nextU32();
     return (hi << 32) | lo;
   }
+
+  private nextU64Offset(min: u64, max: u64): u64 {
+    if (max <= min) return 0;
+    if (min == 0 && max == u64.MAX_VALUE) return this.nextU64();
+    return this.nextU64() % (max - min + 1);
+  }
+
+  private toOrderedU64(value: i64): u64 {
+    return <u64>value ^ I64_SIGN_MASK;
+  }
+
+  private fromOrderedU64(value: u64): i64 {
+    return <i64>(value ^ I64_SIGN_MASK);
+  }
 }
 
 const ASCII_ALPHABET: i32[] = rangeChars(32, 126);

package/bin/commands/build-core.js

@@ -20,8 +20,8 @@ class BuildFailureError extends Error {
         this.kind = args.kind;
     }
 }
-export async function build(configPath = DEFAULT_CONFIG_PATH, selectors = [], modeName, featureToggles = {}, overrides = {}) {
-    const loadedConfig = loadConfig(configPath, false);
+export async function build(configPath = DEFAULT_CONFIG_PATH, selectors = [], modeName, featureToggles = {}, overrides = {}, resolvedConfig) {
+    const loadedConfig = resolvedConfig ?? loadConfig(configPath, false);
     const mode = applyMode(loadedConfig, modeName);
     const config = Object.assign(Object.create(Object.getPrototypeOf(mode.config)), mode.config);
     config.buildOptions = Object.assign(Object.create(Object.getPrototypeOf(mode.config.buildOptions)), mode.config.buildOptions);
@@ -44,7 +44,9 @@ export async function build(configPath = DEFAULT_CONFIG_PATH, selectors = [], mo
         ...config.buildOptions.env,
         AS_TEST_COVERAGE_ENABLED: coverageEnabled ? "1" : "0",
     };
-    if (!process.env.AS_TEST_BUILD_API && !hasCustomBuildCommand(config)) {
+    if (!resolvedConfig &&
+        !process.env.AS_TEST_BUILD_API &&
+        !hasCustomBuildCommand(config)) {
         const pool = getSerialBuildWorkerPool();
         for (const file of inputFiles) {
             await pool.buildFileMode({

package/bin/commands/fuzz-core.js

@@ -12,7 +12,8 @@ const MAX_DEFAULT_SEED = 0x7fffffff;
 export async function fuzz(configPath = DEFAULT_CONFIG_PATH, selectors = [], modeName, overrides = {}, fuzzerSelectors = []) {
     const loadedConfig = loadConfig(configPath, false);
     const mode = applyMode(loadedConfig, modeName);
-    const config = resolveFuzzConfig(loadedConfig.fuzz, overrides);
+    const activeConfig = mode.config;
+    const config = resolveFuzzConfig(activeConfig.fuzz, overrides);
     const inputPatterns = resolveFuzzInputPatterns(config.input, selectors);
     const inputFiles = (await glob(inputPatterns)).sort((a, b) => a.localeCompare(b));
     if (!inputFiles.length) {
@@ -22,10 +23,10 @@ export async function fuzz(configPath = DEFAULT_CONFIG_PATH, selectors = [], mod
     const results = [];
     for (const file of inputFiles) {
         const buildStartedAt = Date.now();
-        await build(configPath, [file], modeName, { coverage: false }, { target: "bindings", args: ["--use", "AS_TEST_FUZZ=1"], kind: "fuzz" });
+        await build(configPath, [file], modeName, { coverage: false }, { target: "bindings", args: ["--use", "AS_TEST_FUZZ=1"], kind: "fuzz" }, loadedConfig);
         const buildFinishedAt = Date.now();
         const buildTime = buildFinishedAt - buildStartedAt;
-        results.push(await runFuzzTarget(file, mode.config.outDir, duplicateBasenames, config, fuzzerSelectors, buildStartedAt, buildFinishedAt, buildTime, modeName));
+        results.push(await runFuzzTarget(file, activeConfig.outDir, duplicateBasenames, config, fuzzerSelectors, buildStartedAt, buildFinishedAt, buildTime, modeName));
     }
     return results;
 }

package/bin/index.js

@@ -1390,7 +1390,7 @@ async function runTestMatrix(runFlags, configPath, selectors, suiteSelectors, fu
         if (!fuzzEnabled) {
             throw await buildNoTestFilesMatchedError(configPath, selectors);
         }
-        const fuzzFiles = await resolveSelectedFuzzFiles(configPath, selectors);
+        const fuzzFiles = await resolveSelectedFuzzFiles(configPath, selectors, modes);
         if (!fuzzFiles.length) {
             throw await buildNoTestFilesMatchedError(configPath, selectors, true);
         }
@@ -1514,7 +1514,7 @@ async function runFuzzModes(configPath, selectors, fuzzerSelectors, modes, rawAr
     const overrides = resolveFuzzOverrides(rawArgs, "fuzz");
     const parallelSettings = resolveFuzzParallelJobs(rawArgs);
     const clean = rawArgs.includes("--clean");
-    const fuzzFiles = await resolveSelectedFuzzFiles(configPath, selectors);
+    const fuzzFiles = await resolveSelectedFuzzFiles(configPath, selectors, modes);
     const { jobs, buildJobs, runJobs } = resolveEffectiveParallelJobs(parallelSettings, fuzzFiles.length);
     if (jobs > 1) {
         const results = await runFuzzMatrixResultsParallel(configPath, selectors, fuzzerSelectors, modes, overrides, jobs, buildJobs, runJobs, clean);
@@ -1798,7 +1798,7 @@ async function runTestMatrixParallel(runFlags, configPath, selectors, suiteSelec
         if (!fuzzEnabled) {
             throw await buildNoTestFilesMatchedError(configPath, selectors);
         }
-        const fuzzFiles = await resolveSelectedFuzzFiles(configPath, selectors);
+        const fuzzFiles = await resolveSelectedFuzzFiles(configPath, selectors, modes);
         if (!fuzzFiles.length) {
             throw await buildNoTestFilesMatchedError(configPath, selectors, true);
         }
@@ -1918,7 +1918,11 @@ async function runTestMatrixParallel(runFlags, configPath, selectors, suiteSelec
     return failed;
 }
 async function runFuzzMatrixResultsParallel(configPath, selectors, fuzzerSelectors, modes, overrides, jobs, buildJobs, runJobs, clean) {
-    const files = await resolveSelectedFuzzFiles(configPath, selectors);
+    const filesByMode = new Map();
+    for (const modeName of modes) {
+        filesByMode.set(modeName, await resolveSelectedFuzzFiles(configPath, selectors, [modeName]));
+    }
+    const files = [...new Set([...filesByMode.values()].flat())].sort((a, b) => a.localeCompare(b));
     if (!files.length) {
         throw new Error(`No fuzz files matched: ${selectors.length ? selectors.join(", ") : "configured input patterns"}`);
     }
@@ -1929,6 +1933,8 @@ async function runFuzzMatrixResultsParallel(configPath, selectors, fuzzerSelecto
         const token = renderQueuedFileStart(queueDisplay, path.basename(file));
         const fileResults = [];
         for (const modeName of modes) {
+            if (!(filesByMode.get(modeName)?.includes(file) ?? false))
+                continue;
             const modeResults = await fuzz(configPath, [file], modeName, overrides, fuzzerSelectors);
             fileResults.push(...modeResults);
         }
@@ -1942,19 +1948,22 @@ async function runFuzzMatrixResultsParallel(configPath, selectors, fuzzerSelecto
     return ordered.flat();
 }
 async function runFuzzMatrixResults(configPath, selectors, fuzzerSelectors, modes, overrides, reporter) {
-    const files = await resolveSelectedFuzzFiles(configPath, selectors);
-    if (!files.length) {
-        throw new Error(`No fuzz files matched: ${selectors.length ? selectors.join(", ") : "configured input patterns"}`);
-    }
     const results = [];
-    for (const file of files) {
-        const fileResults = [];
-        for (const modeName of modes) {
+    for (const modeName of modes) {
+        const files = await resolveSelectedFuzzFiles(configPath, selectors, [modeName]);
+        if (!files.length) {
+            continue;
+        }
+        for (const file of files) {
+            const fileResults = [];
             const modeResults = await fuzz(configPath, [file], modeName, overrides, fuzzerSelectors);
             fileResults.push(...modeResults);
             results.push(...modeResults);
+            reporter?.onFuzzFileComplete?.({ file, results: fileResults });
         }
-        reporter?.onFuzzFileComplete?.({ file, results: fileResults });
+    }
+    if (!results.length) {
+        throw new Error(`No fuzz files matched: ${selectors.length ? selectors.join(", ") : "configured input patterns"}`);
     }
     return results;
 }
@@ -2214,13 +2223,21 @@ async function resolveSelectedFiles(configPath, selectors, warn = true) {
     const specs = matches.filter((file) => file.endsWith(".spec.ts"));
     return [...new Set(specs)].sort((a, b) => a.localeCompare(b));
 }
-async function resolveSelectedFuzzFiles(configPath, selectors) {
+async function resolveSelectedFuzzFiles(configPath, selectors, modes = [undefined]) {
     const resolvedConfigPath = configPath ?? path.join(process.cwd(), "./as-test.config.json");
-    const config = loadConfig(resolvedConfigPath, false);
-    const patterns = resolveFuzzPatterns(config.fuzz.input, selectors);
-    const matches = await glob(patterns);
-    const fuzzFiles = matches.filter((file) => file.endsWith(".fuzz.ts"));
-    return [...new Set(fuzzFiles)].sort((a, b) => a.localeCompare(b));
+    const files = new Set();
+    for (const modeName of modes) {
+        const loaded = loadConfig(resolvedConfigPath, false);
+        const applied = applyMode(loaded, modeName);
+        const config = applied.config;
+        const patterns = resolveFuzzPatterns(config.fuzz.input, selectors);
+        const matches = await glob(patterns);
+        for (const file of matches) {
+            if (file.endsWith(".fuzz.ts"))
+                files.add(file);
+        }
+    }
+    return [...files].sort((a, b) => a.localeCompare(b));
 }
 async function resolveSelectedTestInputs(configPath, selectors) {
     const [specs, fuzz] = await Promise.all([
@@ -2662,9 +2679,9 @@ async function listExecutionPlan(command, configPath, selectors, modes, listFlag
         return;
     const specFiles = command == "fuzz" ? [] : await resolveSelectedFiles(configPath, selectors);
     const fuzzFiles = command == "fuzz"
-        ? await resolveSelectedFuzzFiles(configPath, selectors)
+        ? await resolveSelectedFuzzFiles(configPath, selectors, modes)
         : command == "test" && fuzzEnabled
-            ? await resolveSelectedFuzzFiles(configPath, selectors)
+            ? await resolveSelectedFuzzFiles(configPath, selectors, modes)
             : [];
     const files = command == "fuzz" ? fuzzFiles : specFiles;
     if (!specFiles.length && !fuzzFiles.length) {
@@ -2710,8 +2727,7 @@ async function listExecutionPlan(command, configPath, selectors, modes, listFlag
             }
         }
         const envOverrides = {
-            ...config.env,
-            ...(modeName ? (config.modes[modeName]?.env ?? {}) : {}),
+            ...active.env,
             ...(command == "build"
                 ? active.buildOptions.env
                 : command == "run" || command == "test"