as-test 1.1.5 → 1.1.6-patch.1

package/CHANGELOG.md

@@ -1,11 +1,28 @@
 # Change Log
 
-## 2026-05-15 - v1.1.5
+## 2026-05-19 - v1.1.6-patch.1
+
+### Directory-preserving artifact layout
+
+- feat: build artifacts, fuzz artifacts, snapshots, readable logs, coverage logs, and crash records now mirror the source tree under the configured input globs instead of being flattened into a single directory with a `____`-mangled disambiguator suffix. For `assembly/__tests__/nested/array.spec.ts` the artifact is `outDir/<mode>/nested/array.spec.wasm` (previously `outDir/<mode>/array.<mode>.<target>.assembly____tests____nested.wasm`). Sidecar `.js` / `.d.ts` files sit next to the wasm.
+- feat: filename simplified to `<stem>.wasm` — the `.<mode>.<target>` suffix has been dropped since the mode is already a directory level and the target is implied by the mode config.
+- feat: add `resolveGlobBase`, `resolveSpecRelativePath`, and `resolveArtifactPath` in `cli/util.ts` as the shared path helpers used by every code path that writes or looks up a per-spec artifact. Glob bases are computed component-wise (so `assembly/__tests` is not a prefix of `assembly/__tests__/foo.spec.ts`) and the longest matching base wins when multiple configured input patterns overlap. Patterns without a static prefix (e.g. `**/*.spec.ts`) fall back to the file's cwd-relative path.
+- feat: add an up-front collision check in `build()` that throws a clear error naming both source files when two configured inputs would resolve to the same artifact path.
+- fix: `ast test <one-spec>`, `ast run <one-spec>`, and `ast fuzz <one-spec>` no longer drop the disambiguator when only one of two same-basename files is being built. The build side and the runner side now compute the same path from the same configured input set, so the runner no longer reports `bindings artifact not found` after a single-file build.
+- fix: build sites now `mkdir -p` the artifact's parent directory before invoking `asc` — pinned `assemblyscript@0.28.17`'s `-o` flag does not create parents and would otherwise ENOENT for any new nested directory.
+- fix: `persistCrashRecord` now `mkdir -p`'s the entry's parent directory, supporting `/` in entry keys so nested specs and fuzz failures get their own crash files instead of clobbering by basename.
+- fix: replace the hardcoded `/__tests__/` and `/__fuzz__/` markers in snapshot and readable-log path resolution with proper glob-base computation, so projects with custom input layouts (e.g. `tests/specs/**/*.spec.ts`) now nest correctly instead of silently falling back to basename-only paths.
+- fix: clean break on snapshot file layout — the legacy `${base}.snap.json` and `${base}.${disambiguator}.snap.json` fallbacks have been removed. After upgrading, run `--create-snapshots` or `--overwrite-snapshots` once so snapshots are written at their new relative-path locations.
+- chore: delete the duplicate-basename plumbing introduced by the patch immediately preceding this one. Every code path that used to thread `Set<string>` of duplicate basenames now reads paths directly. No back-compat for the old flat-with-suffix scheme — `ast clean` removes any orphan artifacts.
+
+## 2026-05-14 - v1.1.6
 
 - fix: coverage `mode` and `dependencies` filtering now correctly handles AssemblyScript-normalized `~lib/<pkg>/...` paths, which are the actual runtime paths emitted for `node_modules` imports.
 - fix: `ENTRY_FILE` injected by the transform now uses the full relative path instead of the basename, preventing snapshot key collisions between specs with the same filename in different directories; snapshot lookup normalizes the file prefix to maintain backward compatibility with existing `.snap` files.
 - fix: transform visitor and coverage instrumentation now resolve `NodeKind` values at runtime instead of relying on compile-time const enum inlining, so they remain correct across AssemblyScript versions.
 - fix: add a no-op `TupleType` case to the transform visitor so files using tuple types no longer throw during instrumentation.
+- fix: coverage transform no longer wraps `return this` in constructors, preventing AS231 ("A class with a constructor explicitly returning something else than 'this' must be '@final'").
+- fix: coverage transform preserves expression-body arrows instead of converting them to block bodies, preventing TS1140 ("Type argument expected") on typed arrow parameters such as `[1,2,3].map((x: i32) => x + 1)`.
 
 ## 2026-05-14 - v1.1.4
 

package/assembly/__fuzz__/nested/array.fuzz.ts

@@ -0,0 +1,13 @@
+import { expect, fuzz, FuzzSeed } from "as-test";
+
+fuzz(
+  "nested array.fuzz: index windows stay ordered",
+  (start: i32, end: i32): bool => {
+    expect(start <= end).toBe(true);
+    return end - start <= 64;
+  },
+).generate((seed: FuzzSeed, run: (start: i32, end: i32) => bool): void => {
+  const start = seed.i32({ min: 0, max: 64 });
+  const width = seed.i32({ min: 0, max: 64 });
+  run(start, start + width);
+});

package/bin/commands/build-core.js

@@ -1,10 +1,10 @@
-import { existsSync } from "fs";
+import { existsSync, mkdirSync } from "fs";
 import { glob } from "glob";
 import chalk from "chalk";
 import { spawn } from "child_process";
 import * as path from "path";
 import { createMemoryStream, main as ascMain, } from "assemblyscript/dist/asc.js";
-import { applyMode, getPkgRunner, loadConfig, tokenizeCommand, resolveProjectModule, } from "../util.js";
+import { applyMode, getPkgRunner, loadConfig, resolveArtifactPath, resolveSpecRelativePath, tokenizeCommand, resolveProjectModule, } from "../util.js";
 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");
@@ -36,9 +36,10 @@ export async function build(configPath = DEFAULT_CONFIG_PATH, selectors = [], mo
         ensureDeps(config);
     }
     const pkgRunner = getPkgRunner();
-    const inputPatterns = resolveInputPatterns(config.input, selectors);
+    const sourceInputPatterns = overrides.kind === "fuzz" ? config.fuzz.input : config.input;
+    const inputPatterns = resolveInputPatterns(sourceInputPatterns, selectors);
     const inputFiles = (await glob(inputPatterns)).sort((a, b) => a.localeCompare(b));
-    const duplicateSpecBasenames = resolveDuplicateBasenames(inputFiles);
+    await assertNoArtifactCollisions(sourceInputPatterns);
     const coverageEnabled = resolveCoverageEnabled(config.coverage, featureToggles.coverage);
     const buildEnv = {
         ...mode.env,
@@ -50,7 +51,7 @@ 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 outFile = path.join(config.outDir, resolveArtifactPath(file, sourceInputPatterns));
             const invocation = getBuildCommand(config, pkgRunner, file, outFile, modeName, featureToggles);
             await pool.buildFileMode({
                 configPath,
@@ -64,7 +65,8 @@ export async function build(configPath = DEFAULT_CONFIG_PATH, selectors = [], mo
         return;
     }
     for (const file of inputFiles) {
-        const outFile = `${config.outDir}/${resolveArtifactFileName(file, config.buildOptions.target, modeName, duplicateSpecBasenames)}`;
+        const outFile = path.join(config.outDir, resolveArtifactPath(file, sourceInputPatterns));
+        mkdirSync(path.dirname(outFile), { recursive: true });
         const invocation = getBuildCommand(config, pkgRunner, file, outFile, modeName, featureToggles);
         try {
             await buildFile(invocation, buildEnv);
@@ -79,6 +81,7 @@ export async function build(configPath = DEFAULT_CONFIG_PATH, selectors = [], mo
                 kind,
                 stage: "build",
                 file,
+                entryKey: resolveSpecRelativePath(file, sourceInputPatterns).replace(/\.ts$/i, ""),
                 mode: modeLabel,
                 cwd: process.cwd(),
                 buildCommand,
@@ -127,8 +130,8 @@ export async function getBuildInvocationPreview(configPath = DEFAULT_CONFIG_PATH
     if (overrides.args?.length) {
         config.buildOptions.args = [...config.buildOptions.args, ...overrides.args];
     }
-    const duplicateSpecBasenames = resolveDuplicateBasenames([file]);
-    const outFile = `${config.outDir}/${resolveArtifactFileName(file, config.buildOptions.target, modeName, duplicateSpecBasenames)}`;
+    const sourceInputPatterns = overrides.kind === "fuzz" ? config.fuzz.input : config.input;
+    const outFile = path.join(config.outDir, resolveArtifactPath(file, sourceInputPatterns));
     return getBuildCommand(config, getPkgRunner(), file, outFile, modeName, featureToggles);
 }
 export async function getBuildReuseInfo(configPath = DEFAULT_CONFIG_PATH, file, modeName, featureToggles = {}, overrides = {}) {
@@ -145,8 +148,8 @@ export async function getBuildReuseInfo(configPath = DEFAULT_CONFIG_PATH, file,
     if (hasCustomBuildCommand(config)) {
         return null;
     }
-    const duplicateSpecBasenames = resolveDuplicateBasenames([file]);
-    const outFile = `${config.outDir}/${resolveArtifactFileName(file, config.buildOptions.target, modeName, duplicateSpecBasenames)}`;
+    const sourceInputPatterns = overrides.kind === "fuzz" ? config.fuzz.input : config.input;
+    const outFile = path.join(config.outDir, resolveArtifactPath(file, sourceInputPatterns));
     const invocation = getBuildCommand(config, getPkgRunner(), file, outFile, modeName, featureToggles);
     const coverageEnabled = resolveCoverageEnabled(config.coverage, featureToggles.coverage);
     const buildEnv = {
@@ -245,46 +248,21 @@ function expandBuildCommand(template, file, outFile, target, modeName) {
         .replace(/<target>/g, target)
         .replace(/<mode>/g, modeName ?? "");
 }
-function resolveArtifactFileName(file, target, modeName, duplicateSpecBasenames = new Set()) {
-    const base = path
-        .basename(file)
-        .replace(/\.spec\.ts$/, "")
-        .replace(/\.ts$/, "");
-    const legacy = !modeName
-        ? `${path.basename(file).replace(".ts", ".wasm")}`
-        : `${base}.${modeName}.${target}.wasm`;
-    if (!duplicateSpecBasenames.has(path.basename(file))) {
-        return legacy;
-    }
-    const disambiguator = resolveDisambiguator(file);
-    if (!disambiguator.length) {
-        return legacy;
-    }
-    const ext = path.extname(legacy);
-    const stem = ext.length ? legacy.slice(0, -ext.length) : legacy;
-    return `${stem}.${disambiguator}${ext}`;
-}
-function resolveDuplicateBasenames(files) {
-    const counts = new Map();
+async function assertNoArtifactCollisions(configured) {
+    const patterns = Array.isArray(configured) ? configured : [configured];
+    const files = await glob(patterns);
+    const seen = new Map();
     for (const file of files) {
-        const base = path.basename(file);
-        counts.set(base, (counts.get(base) ?? 0) + 1);
-    }
-    const duplicates = new Set();
-    for (const [base, count] of counts) {
-        if (count > 1)
-            duplicates.add(base);
-    }
-    return duplicates;
-}
-function resolveDisambiguator(file) {
-    const relDir = path.dirname(path.relative(process.cwd(), file));
-    if (!relDir.length || relDir == ".")
-        return "";
-    return relDir
-        .replace(/[\\/]+/g, "__")
-        .replace(/[^A-Za-z0-9._-]/g, "_")
-        .replace(/^_+|_+$/g, "");
+        const artifact = resolveArtifactPath(file, patterns);
+        const prev = seen.get(artifact);
+        if (prev != null && prev !== file) {
+            throw new Error(`Two input files resolve to the same artifact path "${artifact}":\n` +
+                `  - ${prev}\n` +
+                `  - ${file}\n` +
+                `Rename one of them or narrow the input patterns to disambiguate.`);
+        }
+        seen.set(artifact, file);
+    }
 }
 function resolveInputPatterns(configured, selectors) {
     const configuredInputs = Array.isArray(configured)

package/bin/commands/fuzz-core.js

@@ -3,7 +3,7 @@ import * as path from "path";
 import { pathToFileURL } from "url";
 import { glob } from "glob";
 import { build } from "./build-core.js";
-import { applyMode, loadConfig } from "../util.js";
+import { applyMode, loadConfig, resolveArtifactPath, resolveSpecRelativePath, } from "../util.js";
 import { persistCrashRecord } from "../crash-store.js";
 const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
 const MAGIC = Buffer.from("WIPC");
@@ -19,14 +19,13 @@ export async function fuzz(configPath = DEFAULT_CONFIG_PATH, selectors = [], mod
     if (!inputFiles.length) {
         throw new Error(`No fuzz files matched: ${selectors.length ? selectors.join(", ") : "configured input patterns"}`);
     }
-    const duplicateBasenames = resolveDuplicateBasenames(inputFiles);
     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" }, loadedConfig);
         const buildFinishedAt = Date.now();
         const buildTime = buildFinishedAt - buildStartedAt;
-        results.push(await runFuzzTarget(file, activeConfig.outDir, duplicateBasenames, config, fuzzerSelectors, buildStartedAt, buildFinishedAt, buildTime, modeName));
+        results.push(await runFuzzTarget(file, activeConfig.outDir, config, fuzzerSelectors, buildStartedAt, buildFinishedAt, buildTime, modeName));
     }
     return results;
 }
@@ -70,9 +69,9 @@ function encodeRunsOverrideKind(kind) {
             return 4;
     }
 }
-async function runFuzzTarget(file, outDir, duplicateBasenames, config, fuzzerSelectors, buildStartedAt, buildFinishedAt, buildTime, modeName) {
+async function runFuzzTarget(file, outDir, config, fuzzerSelectors, buildStartedAt, buildFinishedAt, buildTime, modeName) {
     const startedAt = Date.now();
-    const artifact = resolveArtifactFileName(file, duplicateBasenames, modeName);
+    const artifact = resolveArtifactPath(file, config.input);
     const wasmPath = path.resolve(process.cwd(), outDir, artifact);
     const jsPath = resolveBindingsHelperPath(wasmPath);
     const helper = await import(pathToFileURL(jsPath).href + `?t=${Date.now()}`);
@@ -140,7 +139,7 @@ async function runFuzzTarget(file, outDir, duplicateBasenames, config, fuzzerSel
         const crash = persistCrashRecord(config.crashDir, {
             kind: "fuzz",
             file,
-            entryKey: buildFuzzCrashEntryKey(file, modeName ?? "default"),
+            entryKey: buildFuzzCrashEntryKey(file, config.input, modeName ?? "default"),
             mode: modeName ?? "default",
             seed: config.seed,
             error: crashMessage,
@@ -188,7 +187,7 @@ async function runFuzzTarget(file, outDir, duplicateBasenames, config, fuzzerSel
         const crash = persistCrashRecord(config.crashDir, {
             kind: "fuzz",
             file,
-            entryKey: buildFuzzCrashEntryKey(file, modeName ?? "default"),
+            entryKey: buildFuzzCrashEntryKey(file, config.input, modeName ?? "default"),
             mode: modeName ?? "default",
             seed: config.seed,
             error: `${reportParseError ? `invalid fuzz report payload: ${reportParseError}` : `missing fuzz report payload from ${path.basename(file)}`} (${diagnostics})`,
@@ -223,7 +222,7 @@ async function runFuzzTarget(file, outDir, duplicateBasenames, config, fuzzerSel
         const crash = persistCrashRecord(config.crashDir, {
             kind: "fuzz",
             file,
-            entryKey: buildFuzzFailureEntryKey(file, fuzzer.name, modeName ?? "default"),
+            entryKey: buildFuzzFailureEntryKey(file, config.input, fuzzer.name, modeName ?? "default"),
             mode: modeName ?? "default",
             seed: firstFailureSeed,
             reproCommand: buildFuzzReproCommand(file, firstFailureSeed, modeName ?? "default", fuzzer.selector, 1),
@@ -285,11 +284,13 @@ function buildFuzzReproCommand(file, seed, modeName, fuzzer, runs) {
     const runsArg = typeof runs == "number" ? ` --runs ${runs}` : "";
     return `ast fuzz ${file}${modeArg}${fuzzerArg} --seed ${seed}${runsArg}`;
 }
-function buildFuzzFailureEntryKey(file, name, modeName) {
-    return `${path.basename(file).replace(/\.ts$/, "")}.${sanitizeEntryName(modeName)}.${sanitizeEntryName(name)}`;
+function buildFuzzFailureEntryKey(file, inputPatterns, name, modeName) {
+    const stem = resolveSpecRelativePath(file, inputPatterns).replace(/\.ts$/i, "");
+    return `${stem}.${sanitizeEntryName(modeName)}.${sanitizeEntryName(name)}`;
 }
-function buildFuzzCrashEntryKey(file, modeName) {
-    return `${path.basename(file).replace(/\.ts$/, "")}.${sanitizeEntryName(modeName)}`;
+function buildFuzzCrashEntryKey(file, inputPatterns, modeName) {
+    const stem = resolveSpecRelativePath(file, inputPatterns).replace(/\.ts$/i, "");
+    return `${stem}.${sanitizeEntryName(modeName)}`;
 }
 function sanitizeEntryName(name) {
     return (name
@@ -398,47 +399,6 @@ function resolveFuzzInputPatterns(configured, selectors) {
     }
     return [...patterns];
 }
-function resolveArtifactFileName(file, duplicateBasenames, modeName) {
-    const base = path
-        .basename(file)
-        .replace(/\.spec\.ts$/, "")
-        .replace(/\.ts$/, "");
-    const legacy = !modeName
-        ? `${path.basename(file).replace(".ts", ".wasm")}`
-        : `${base}.${modeName}.bindings.wasm`;
-    if (!duplicateBasenames.has(path.basename(file))) {
-        return legacy;
-    }
-    const disambiguator = resolveDisambiguator(file);
-    if (!disambiguator.length) {
-        return legacy;
-    }
-    const ext = path.extname(legacy);
-    const stem = ext.length ? legacy.slice(0, -ext.length) : legacy;
-    return `${stem}.${disambiguator}${ext}`;
-}
-function resolveDuplicateBasenames(files) {
-    const counts = new Map();
-    for (const file of files) {
-        const base = path.basename(file);
-        counts.set(base, (counts.get(base) ?? 0) + 1);
-    }
-    const duplicates = new Set();
-    for (const [base, count] of counts) {
-        if (count > 1)
-            duplicates.add(base);
-    }
-    return duplicates;
-}
-function resolveDisambiguator(file) {
-    const relDir = path.dirname(path.relative(process.cwd(), file));
-    if (!relDir.length || relDir == ".")
-        return "";
-    return relDir
-        .replace(/[\\/]+/g, "__")
-        .replace(/[^A-Za-z0-9._-]/g, "_")
-        .replace(/^_+|_+$/g, "");
-}
 function resolveBindingsHelperPath(wasmPath) {
     const bindingsPath = wasmPath.replace(/\.wasm$/, ".bindings.js");
     if (existsSync(bindingsPath))

package/bin/commands/run-core.js

@@ -2,7 +2,7 @@ import chalk from "chalk";
 import { spawn } from "child_process";
 import { glob } from "glob";
 import { Channel, MessageType } from "../wipc.js";
-import { applyMode, formatSpecDisplayPath, formatTime, getExec, loadConfig, tokenizeCommand, } from "../util.js";
+import { applyMode, formatSpecDisplayPath, formatTime, getExec, loadConfig, resolveArtifactPath, resolveSpecRelativePath, tokenizeCommand, } from "../util.js";
 import * as path from "path";
 import { pathToFileURL } from "url";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -16,7 +16,7 @@ import { persistCrashRecord } from "../crash-store.js";
 import { describeCoveragePoint } from "../coverage-points.js";
 const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
 class SnapshotStore {
-    constructor(specFile, snapshotDir, duplicateSpecBasenames = new Set()) {
+    constructor(specFile, snapshotDir, inputPatterns) {
         this.dirty = false;
         this.created = 0;
         this.updated = 0;
@@ -25,16 +25,16 @@ class SnapshotStore {
         this.warnedMissing = new Set();
         this.specBasename = path.basename(specFile);
         const dir = path.join(process.cwd(), snapshotDir);
-        const relative = resolveArtifactRelativePath(specFile, "__tests__").replace(/\.ts$/, ".snap");
+        const relative = resolveSpecRelativePath(specFile, inputPatterns).replace(/\.ts$/i, ".snap");
         this.filePath = path.join(dir, relative);
-        const sourcePath = resolveSnapshotSourcePath(specFile, dir, duplicateSpecBasenames, this.filePath) ?? null;
+        const sourcePath = existsSync(this.filePath) ? this.filePath : null;
         const loaded = sourcePath
             ? readSnapshotFile(sourcePath, specFile)
             : { data: {}, normalized: false, preamble: "" };
         this.data = loaded.data;
         this.preamble = loaded.preamble;
-        this.existed = Boolean(sourcePath && existsSync(sourcePath));
-        this.dirty = Boolean((sourcePath && sourcePath != this.filePath) || loaded.normalized);
+        this.existed = Boolean(sourcePath);
+        this.dirty = Boolean(loaded.normalized);
     }
     assert(key, actual, allowSnapshot, createSnapshots, overwriteSnapshots) {
         key = canonicalizeSnapshotKey(key);
@@ -81,21 +81,6 @@ class SnapshotStore {
         writeFileSync(this.filePath, formatSnapshotFile(this.data, this.filePath, this.existed ? this.preamble : defaultSnapshotPreamble()));
     }
 }
-function resolveSnapshotSourcePath(specFile, snapshotDir, duplicateSpecBasenames, preferredPath) {
-    if (existsSync(preferredPath))
-        return preferredPath;
-    const base = path.basename(specFile, ".ts");
-    const legacyFlat = path.join(snapshotDir, `${base}.snap.json`);
-    if (existsSync(legacyFlat))
-        return legacyFlat;
-    const disambiguator = resolveDisambiguator(specFile, duplicateSpecBasenames);
-    if (disambiguator.length) {
-        const legacyDisambiguated = path.join(snapshotDir, `${base}.${disambiguator}.snap.json`);
-        if (existsSync(legacyDisambiguated))
-            return legacyDisambiguated;
-    }
-    return null;
-}
 function readSnapshotFile(filePath, specFile) {
     const raw = readFileSync(filePath, "utf8");
     if (filePath.endsWith(".json")) {
@@ -247,16 +232,11 @@ function trimSnapshotPreamble(lines) {
         end--;
     return lines.slice(0, end).join("\n");
 }
+// Only the basename of the returned path matters — callers feed this into
+// `path.basename(...)` to localize snapshot keys (strip the "${basename}::"
+// prefix). The full path is therefore synthetic but stable.
 function resolveSnapshotSpecFile(filePath) {
-    const normalized = filePath.replace(/\\/g, "/");
-    const marker = "/snapshots/";
-    const markerIndex = normalized.lastIndexOf(marker);
-    const suffix = markerIndex >= 0
-        ? normalized.slice(markerIndex + marker.length)
-        : path.basename(normalized);
-    const withoutMode = suffix.replace(/^default\//, "");
-    const relative = withoutMode.replace(/\.snap$/, ".ts");
-    return `assembly/__tests__/${relative}`;
+    return path.basename(filePath).replace(/\.snap$/, ".ts");
 }
 function localizeSnapshotKey(specFile, key) {
     const prefix = `${path.basename(specFile)}::`;
@@ -297,16 +277,8 @@ function canonicalizeSnapshotLocalKey(localKey) {
     }
     return localKey;
 }
-function resolveArtifactRelativePath(sourceFile, segment) {
-    const normalized = sourceFile.replace(/\\/g, "/");
-    const marker = `/${segment}/`;
-    const index = normalized.lastIndexOf(marker);
-    if (index >= 0)
-        return normalized.slice(index + marker.length);
-    return path.basename(normalized);
-}
-function writeReadableLog(logRoot, file, suites, modeName, buildCommand, runCommand, snapshotSummary) {
-    const relative = resolveArtifactRelativePath(file, "__tests__").replace(/\.ts$/, ".log");
+function writeReadableLog(logRoot, file, inputPatterns, suites, modeName, buildCommand, runCommand, snapshotSummary) {
+    const relative = resolveSpecRelativePath(file, inputPatterns).replace(/\.ts$/i, ".log");
     const filePath = path.join(logRoot, relative);
     const dir = path.dirname(filePath);
     if (!existsSync(dir))
@@ -562,7 +534,6 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
     const config = mode.config;
     const inputPatterns = resolveInputPatterns(config.input, selectors);
     const inputFiles = (await glob(inputPatterns)).sort((a, b) => a.localeCompare(b));
-    const duplicateSpecBasenames = await resolveDuplicateSpecBasenames(config.input);
     const snapshotEnabled = flags.snapshot !== false;
     const createSnapshots = Boolean(flags.createSnapshots);
     const overwriteSnapshots = Boolean(flags.overwriteSnapshots);
@@ -623,7 +594,7 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
     try {
         for (let i = 0; i < inputFiles.length; i++) {
             const file = inputFiles[i];
-            const outFile = path.join(config.outDir, resolveArtifactFileName(file, config.buildOptions.target, options.modeName, duplicateSpecBasenames));
+            const outFile = path.join(config.outDir, resolveArtifactPath(file, config.input));
             if (!existsSync(outFile)) {
                 const buildStartedAt = Date.now();
                 await build(resolvedConfigPath, [file], options.modeName, { coverage: flags.coverage }, {}, loadedConfig);
@@ -642,7 +613,7 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
                     .map((token) => token.replace(/<name>/g, fileBase).replace(/<file>/g, fileToken)),
             };
             const runCommandForLog = formatInvocation(invocation);
-            const snapshotStore = new SnapshotStore(file, config.snapshotDir, duplicateSpecBasenames);
+            const snapshotStore = new SnapshotStore(file, config.snapshotDir, config.input);
             let report;
             try {
                 const runtimeEnv = {
@@ -655,9 +626,10 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
                             ? { BROWSER: config.runOptions.runtime.browser.trim() }
                             : {}),
                 };
+                const crashEntryKey = resolveSpecRelativePath(file, config.input).replace(/\.ts$/i, "");
                 report = webSession
-                    ? await runWebSessionProcess(webSession, file, config.fuzz.crashDir, options.modeName, snapshotStore, snapshotEnabled, createSnapshots, overwriteSnapshots, reporter, reporterKind == "tap", runtimeEnv)
-                    : await runProcess(invocation, file, config.fuzz.crashDir, options.modeName, snapshotStore, snapshotEnabled, createSnapshots, overwriteSnapshots, reporter, reporterKind == "tap", runtimeEnv);
+                    ? await runWebSessionProcess(webSession, file, config.fuzz.crashDir, crashEntryKey, options.modeName, snapshotStore, snapshotEnabled, createSnapshots, overwriteSnapshots, reporter, reporterKind == "tap", runtimeEnv)
+                    : await runProcess(invocation, file, config.fuzz.crashDir, crashEntryKey, options.modeName, snapshotStore, snapshotEnabled, createSnapshots, overwriteSnapshots, reporter, reporterKind == "tap", runtimeEnv);
             }
             catch (error) {
                 const modeLabel = options.modeName ?? "default";
@@ -698,7 +670,7 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
             mkdirSync(logRoot, { recursive: true });
         }
         for (const report of reports) {
-            writeReadableLog(logRoot, report.file, report.suites, options.modeName, options.buildCommandsByFile?.[report.file] ??
+            writeReadableLog(logRoot, report.file, config.input, report.suites, options.modeName, options.buildCommandsByFile?.[report.file] ??
                 options.buildCommand ??
                 "", report.runCommand, report.snapshotSummary);
         }
@@ -713,10 +685,9 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
         coverageDir != "none" &&
         coverageSummary.files.length > 0) {
         const resolvedCoverageDir = path.join(process.cwd(), coverageDir);
-        if (!existsSync(resolvedCoverageDir)) {
-            mkdirSync(resolvedCoverageDir, { recursive: true });
-        }
-        writeFileSync(path.join(resolvedCoverageDir, options.coverageFileName ?? "coverage.log.json"), JSON.stringify(coverageSummary, null, 2));
+        const coverageFilePath = path.join(resolvedCoverageDir, options.coverageFileName ?? "coverage.log.json");
+        mkdirSync(path.dirname(coverageFilePath), { recursive: true });
+        writeFileSync(coverageFilePath, JSON.stringify(coverageSummary, null, 2));
     }
     if (options.emitRunComplete !== false) {
         const totalModes = Math.max(options.modeSummaryTotal ?? 1, 1);
@@ -937,51 +908,6 @@ instantiate(imports)
     }
     return null;
 }
-function resolveArtifactFileName(file, target, modeName, duplicateSpecBasenames = new Set()) {
-    const base = path
-        .basename(file)
-        .replace(/\.spec\.ts$/, "")
-        .replace(/\.ts$/, "");
-    const legacy = !modeName
-        ? `${path.basename(file).replace(".ts", ".wasm")}`
-        : `${base}.${modeName}.${target}.wasm`;
-    if (!duplicateSpecBasenames.has(path.basename(file))) {
-        return legacy;
-    }
-    const disambiguator = resolveDisambiguator(file, duplicateSpecBasenames);
-    if (!disambiguator.length) {
-        return legacy;
-    }
-    const ext = path.extname(legacy);
-    const stem = ext.length ? legacy.slice(0, -ext.length) : legacy;
-    return `${stem}.${disambiguator}${ext}`;
-}
-async function resolveDuplicateSpecBasenames(configured) {
-    const patterns = Array.isArray(configured) ? configured : [configured];
-    const files = await glob(patterns);
-    const counts = new Map();
-    for (const file of files) {
-        const base = path.basename(file);
-        counts.set(base, (counts.get(base) ?? 0) + 1);
-    }
-    const duplicates = new Set();
-    for (const [base, count] of counts) {
-        if (count > 1)
-            duplicates.add(base);
-    }
-    return duplicates;
-}
-function resolveDisambiguator(file, duplicateSpecBasenames) {
-    if (!duplicateSpecBasenames.has(path.basename(file)))
-        return "";
-    const relDir = path.dirname(path.relative(process.cwd(), file));
-    if (!relDir.length || relDir == ".")
-        return "";
-    return relDir
-        .replace(/[\\/]+/g, "__")
-        .replace(/[^A-Za-z0-9._-]/g, "_")
-        .replace(/^_+|_+$/g, "");
-}
 function resolveRuntimeTargetEnv(target, wasmPath) {
     if (target == "bindings") {
         return resolveBindingsRuntimeEnv(wasmPath);
@@ -1602,7 +1528,7 @@ function compareCoveragePoints(a, b) {
         return a.type.localeCompare(b.type);
     return a.hash.localeCompare(b.hash);
 }
-async function runProcess(invocation, specFile, crashDir, modeName, snapshots, snapshotEnabled, createSnapshots, overwriteSnapshots, reporter, tapMode = false, env = process.env) {
+async function runProcess(invocation, specFile, crashDir, crashEntryKey, modeName, snapshots, snapshotEnabled, createSnapshots, overwriteSnapshots, reporter, tapMode = false, env = process.env) {
     const child = spawn(invocation.command, invocation.args, {
         stdio: ["pipe", "pipe", "pipe"],
         shell: false,
@@ -1803,6 +1729,7 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
         persistCrashRecord(crashDir, {
             kind: "test",
             file: specFile,
+            entryKey: crashEntryKey,
             mode: modeName ?? "default",
             error: errorText,
             stdout: stdoutBuffer,
@@ -1845,6 +1772,7 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
         persistCrashRecord(crashDir, {
             kind: "test",
             file: specFile,
+            entryKey: crashEntryKey,
             mode: modeName ?? "default",
             error: fullError,
             stdout: stdoutBuffer,
@@ -1873,6 +1801,7 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
                 persistCrashRecord(crashDir, {
                     kind: "test",
                     file: specFile,
+                    entryKey: crashEntryKey,
                     mode: modeName ?? "default",
                     error: errorText || "runtime reported an unknown error",
                     stdout: stdoutBuffer,
@@ -1890,6 +1819,7 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
         persistCrashRecord(crashDir, {
             kind: "test",
             file: specFile,
+            entryKey: crashEntryKey,
             mode: modeName ?? "default",
             error: fullError,
             stdout: stdoutBuffer,
@@ -1910,6 +1840,7 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
         persistCrashRecord(crashDir, {
             kind: "test",
             file: specFile,
+            entryKey: crashEntryKey,
             mode: modeName ?? "default",
             error: errorText || "runtime reported an unknown error",
             stdout: stdoutBuffer,
@@ -1921,7 +1852,7 @@ async function runProcess(invocation, specFile, crashDir, modeName, snapshots, s
     }
     return report;
 }
-async function runWebSessionProcess(session, specFile, crashDir, modeName, snapshots, snapshotEnabled, createSnapshots, overwriteSnapshots, reporter, tapMode = false, env = process.env) {
+async function runWebSessionProcess(session, specFile, crashDir, crashEntryKey, modeName, snapshots, snapshotEnabled, createSnapshots, overwriteSnapshots, reporter, tapMode = false, env = process.env) {
     const input = new PassThrough();
     const output = new PassThrough();
     let report = null;
@@ -2145,6 +2076,7 @@ async function runWebSessionProcess(session, specFile, crashDir, modeName, snaps
         persistCrashRecord(crashDir, {
             kind: "test",
             file: specFile,
+            entryKey: crashEntryKey,
             mode: modeName ?? "default",
             error: fullError,
             stdout: stdoutBuffer,
@@ -2179,6 +2111,7 @@ async function runWebSessionProcess(session, specFile, crashDir, modeName, snaps
         persistCrashRecord(crashDir, {
             kind: "test",
             file: specFile,
+            entryKey: crashEntryKey,
             mode: modeName ?? "default",
             error: fullError,
             stdout: stdoutBuffer,

package/bin/commands/web-session.js

@@ -56,6 +56,10 @@ export class PersistentWebSessionHost {
             ? env.AS_TEST_HELPER_PATH
             : null;
         const jobId = String(this.nextJobId++);
+        // URL paths use only the basename — that is safe because each job has
+        // exactly one wasm and one helper, scoped by the jobId path component.
+        // Nested directory artifacts (e.g. nested/array.spec.wasm) are read
+        // from disk via `wasmPath`/`helperPath`, not via these URLs.
         const browserEnv = {
             ...env,
             AS_TEST_WASM_PATH: `/job/${jobId}/${path.basename(wasmPath)}`,

package/bin/crash-store.js

@@ -5,9 +5,9 @@ export function persistCrashRecord(rootDir, record) {
         ? record.entryKey
         : crashEntryKey(record.file);
     const dir = path.resolve(process.cwd(), rootDir);
-    mkdirSync(dir, { recursive: true });
     const jsonPath = path.join(dir, `${entry}.json`);
     const logPath = path.join(dir, `${entry}.log`);
+    mkdirSync(path.dirname(jsonPath), { recursive: true });
     const payload = {
         timestamp: new Date().toISOString(),
         ...record,

package/bin/index.js

@@ -10,7 +10,7 @@ import { executeInitCommand } from "./commands/init.js";
 import { executeDoctorCommand } from "./commands/doctor.js";
 import { executeCleanCommand } from "./commands/clean.js";
 import { fuzz } from "./commands/fuzz-core.js";
-import { applyMode, formatTime, formatSpecDisplayPath, getDefaultModeNames, getCliVersion, loadConfig, resolveModeNames, } from "./util.js";
+import { applyMode, formatTime, formatSpecDisplayPath, getDefaultModeNames, getCliVersion, loadConfig, resolveArtifactPath, resolveModeNames, resolveSpecRelativePath, } from "./util.js";
 import * as path from "path";
 import { spawnSync } from "child_process";
 import { glob } from "glob";
@@ -1140,7 +1140,7 @@ async function runTestSequential(runFlags, configPath, selectors, suiteSelectors
     const results = [];
     let failed = false;
     const buildIntervals = [];
-    const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
+    const inputPatterns = await loadInputPatterns(configPath);
     for (const file of files) {
         const buildStartedAt = Date.now();
         let result;
@@ -1148,7 +1148,7 @@ async function runTestSequential(runFlags, configPath, selectors, suiteSelectors
             await build(configPath, [file], modeName, buildFeatureToggles);
             buildIntervals.push({ start: buildStartedAt, end: Date.now() });
             const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, buildFeatureToggles);
-            const artifactKey = resolvePerFileArtifactKey(file, duplicateSpecBasenames);
+            const artifactKey = resolveArtifactStem(file, inputPatterns);
             result = await run(runFlags, configPath, [file], false, {
                 reporter,
                 webSession,
@@ -1156,7 +1156,7 @@ async function runTestSequential(runFlags, configPath, selectors, suiteSelectors
                 emitRunStart: false,
                 emitRunComplete: false,
                 logFileName: `test.${artifactKey}.log.json`,
-                coverageFileName: `coverage.${artifactKey}.log.json`,
+                coverageFileName: `${artifactKey}.log.json`,
                 buildCommand: formatBuildInvocation(buildInvocation),
                 modeName,
             });
@@ -1351,7 +1351,7 @@ async function runRuntimeMatrix(runFlags, configPath, selectors, suiteSelectors,
         failed: false,
         passed: false,
     }));
-    const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
+    const inputPatterns = await loadInputPatterns(configPath);
     const buildIntervals = [];
     for (let fileIndex = 0; fileIndex < files.length; fileIndex++) {
         const file = files[fileIndex];
@@ -1365,7 +1365,7 @@ async function runRuntimeMatrix(runFlags, configPath, selectors, suiteSelectors,
             const modeName = modes[i];
             try {
                 const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, {});
-                const artifactKey = resolvePerFileArtifactKey(file, duplicateSpecBasenames);
+                const artifactKey = resolveArtifactStem(file, inputPatterns);
                 const result = await run(runFlags, configPath, [file], false, {
                     reporter: silentReporter,
                     reporterKind: "default",
@@ -1373,7 +1373,7 @@ async function runRuntimeMatrix(runFlags, configPath, selectors, suiteSelectors,
                     emitRunStart: false,
                     emitRunComplete: false,
                     logFileName: `run.${artifactKey}.log.json`,
-                    coverageFileName: `coverage.${artifactKey}.log.json`,
+                    coverageFileName: `${artifactKey}.log.json`,
                     buildCommand: formatBuildInvocation(buildInvocation),
                     modeName,
                 });
@@ -1531,7 +1531,7 @@ async function runTestMatrix(runFlags, configPath, selectors, suiteSelectors, fu
         failed: false,
         passed: false,
     }));
-    const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
+    const inputPatterns = await loadInputPatterns(configPath);
     const buildIntervals = [];
     for (let fileIndex = 0; fileIndex < files.length; fileIndex++) {
         const file = files[fileIndex];
@@ -1554,14 +1554,14 @@ async function runTestMatrix(runFlags, configPath, selectors, suiteSelectors, fu
                 });
                 buildIntervals.push({ start: buildStartedAt, end: Date.now() });
                 const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, buildFeatureToggles);
-                const artifactKey = resolvePerFileArtifactKey(file, duplicateSpecBasenames);
+                const artifactKey = resolveArtifactStem(file, inputPatterns);
                 result = await run(runFlags, configPath, [file], false, {
                     reporter: silentReporter,
                     reporterKind: "default",
                     emitRunStart: false,
                     emitRunComplete: false,
                     logFileName: `test.${artifactKey}.log.json`,
-                    coverageFileName: `coverage.${artifactKey}.log.json`,
+                    coverageFileName: `${artifactKey}.log.json`,
                     buildCommand: formatBuildInvocation(buildInvocation),
                     modeName,
                 });
@@ -1740,7 +1740,7 @@ async function runRuntimeMatrixParallel(runFlags, configPath, selectors, suiteSe
     const silentReporter = {};
     const modeLabels = modes.map((modeName) => modeName ?? "default");
     const showPerModeTimes = Boolean(runFlags.verbose);
-    const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
+    const inputPatterns = await loadInputPatterns(configPath);
     const ordered = new Array(files.length);
     const useQueueDisplay = reporterSession.reporterKind == "default";
     const queueDisplay = new ParallelQueueDisplay(useQueueDisplay && !runFlags.clean);
@@ -1769,7 +1769,7 @@ async function runRuntimeMatrixParallel(runFlags, configPath, selectors, suiteSe
                     });
                     buildIntervals.push({ start: buildStartedAt, end: Date.now() });
                     const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, {});
-                    const artifactKey = resolvePerFileArtifactKey(file, duplicateSpecBasenames);
+                    const artifactKey = resolveArtifactStem(file, inputPatterns);
                     result = await run(runFlags, configPath, [file], false, {
                         reporter: silentReporter,
                         reporterKind: "default",
@@ -1777,7 +1777,7 @@ async function runRuntimeMatrixParallel(runFlags, configPath, selectors, suiteSe
                         emitRunStart: false,
                         emitRunComplete: false,
                         logFileName: `run.${artifactKey}.log.json`,
-                        coverageFileName: `coverage.${artifactKey}.log.json`,
+                        coverageFileName: `${artifactKey}.log.json`,
                         buildCommand: formatBuildInvocation(buildInvocation),
                         modeName,
                     });
@@ -1853,7 +1853,7 @@ async function runTestSingleParallel(runFlags, configPath, selectors, suiteSelec
         snapshotEnabled,
         createSnapshots: runFlags.createSnapshots,
     });
-    const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
+    const inputPatterns = await loadInputPatterns(configPath);
     const results = new Array(files.length);
     const useQueueDisplay = reporterSession.reporterKind == "default";
     const queueDisplay = new ParallelQueueDisplay(useQueueDisplay && !runFlags.clean);
@@ -1881,14 +1881,14 @@ async function runTestSingleParallel(runFlags, configPath, selectors, suiteSelec
                     });
                     buildIntervals.push({ start: buildStartedAt, end: Date.now() });
                     const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, buildFeatureToggles);
-                    const artifactKey = resolvePerFileArtifactKey(file, duplicateSpecBasenames);
+                    const artifactKey = resolveArtifactStem(file, inputPatterns);
                     result = await run({ ...runFlags, clean: true }, configPath, [file], false, {
                         reporter: buffered?.reporter,
                         reporterKind: buffered?.reporterKind,
                         suiteSelectors,
                         emitRunComplete: false,
                         logFileName: `test.${artifactKey}.log.json`,
-                        coverageFileName: `coverage.${artifactKey}.log.json`,
+                        coverageFileName: `${artifactKey}.log.json`,
                         buildCommand: formatBuildInvocation(buildInvocation),
                         modeName,
                     });
@@ -1967,7 +1967,7 @@ async function runTestMatrixParallel(runFlags, configPath, selectors, suiteSelec
     const silentReporter = {};
     const modeLabels = modes.map((modeName) => modeName ?? "default");
     const showPerModeTimes = Boolean(runFlags.verbose);
-    const duplicateSpecBasenames = resolveDuplicateSpecBasenames(files);
+    const inputPatterns = await loadInputPatterns(configPath);
     const ordered = new Array(files.length);
     const useQueueDisplay = reporterSession.reporterKind == "default";
     const queueDisplay = new ParallelQueueDisplay(useQueueDisplay && !runFlags.clean);
@@ -1996,7 +1996,7 @@ async function runTestMatrixParallel(runFlags, configPath, selectors, suiteSelec
                     });
                     buildIntervals.push({ start: buildStartedAt, end: Date.now() });
                     const buildInvocation = await getBuildInvocationPreview(configPath, file, modeName, buildFeatureToggles);
-                    const artifactKey = resolvePerFileArtifactKey(file, duplicateSpecBasenames);
+                    const artifactKey = resolveArtifactStem(file, inputPatterns);
                     result = await run(runFlags, configPath, [file], false, {
                         reporter: silentReporter,
                         reporterKind: "default",
@@ -2004,7 +2004,7 @@ async function runTestMatrixParallel(runFlags, configPath, selectors, suiteSelec
                         emitRunStart: false,
                         emitRunComplete: false,
                         logFileName: `test.${artifactKey}.log.json`,
-                        coverageFileName: `coverage.${artifactKey}.log.json`,
+                        coverageFileName: `${artifactKey}.log.json`,
                         buildCommand: formatBuildInvocation(buildInvocation),
                         modeName,
                     });
@@ -2707,57 +2707,19 @@ function isBareSuiteSelector(selector) {
 function stripSuiteSuffix(selector) {
     return selector.replace(/\.spec\.ts$/, "").replace(/\.ts$/, "");
 }
-function resolveDuplicateSpecBasenames(files) {
-    const counts = new Map();
-    for (const file of files) {
-        const base = path.basename(file);
-        counts.set(base, (counts.get(base) ?? 0) + 1);
-    }
-    const duplicates = new Set();
-    for (const [base, count] of counts) {
-        if (count > 1)
-            duplicates.add(base);
-    }
-    return duplicates;
-}
-function resolvePerFileArtifactKey(file, duplicateSpecBasenames) {
-    const base = path.basename(file);
-    let raw = base;
-    if (duplicateSpecBasenames.has(base)) {
-        const disambiguator = resolvePerFileDisambiguator(file);
-        if (disambiguator.length) {
-            raw = `${base}.${disambiguator}`;
-        }
-    }
-    return raw.replace(/[^a-zA-Z0-9._-]/g, "_");
-}
-function resolvePerFileDisambiguator(file) {
-    const relDir = path.dirname(path.relative(process.cwd(), file));
-    if (!relDir.length || relDir == ".")
-        return "";
-    return relDir
-        .replace(/[\\/]+/g, "__")
-        .replace(/[^A-Za-z0-9._-]/g, "_")
-        .replace(/^_+|_+$/g, "");
-}
-function resolveArtifactFileNameForPreview(file, target, modeName, duplicateSpecBasenames) {
-    const base = path
-        .basename(file)
-        .replace(/\.spec\.ts$/, "")
-        .replace(/\.ts$/, "");
-    const legacy = !modeName
-        ? `${path.basename(file).replace(".ts", ".wasm")}`
-        : `${base}.${modeName}.${target}.wasm`;
-    if (!duplicateSpecBasenames.has(path.basename(file))) {
-        return legacy;
-    }
-    const disambiguator = resolvePerFileDisambiguator(file);
-    if (!disambiguator.length) {
-        return legacy;
-    }
-    const ext = path.extname(legacy);
-    const stem = ext.length ? legacy.slice(0, -ext.length) : legacy;
-    return `${stem}.${disambiguator}${ext}`;
+// Returns the spec relative path (under the configured input base) with the
+// trailing ".ts" stripped, suitable for use as a stable per-file key for
+// coverage and log filenames.
+function resolveArtifactStem(file, inputPatterns) {
+    return resolveSpecRelativePath(file, inputPatterns).replace(/\.ts$/i, "");
+}
+async function loadInputPatterns(configPath) {
+    const resolvedConfigPath = configPath ?? path.join(process.cwd(), "./as-test.config.json");
+    return loadConfig(resolvedConfigPath, false).input;
+}
+async function loadFuzzInputPatterns(configPath) {
+    const resolvedConfigPath = configPath ?? path.join(process.cwd(), "./as-test.config.json");
+    return loadConfig(resolvedConfigPath, false).fuzz.input;
 }
 async function ensureWebBrowsersReady(configPath, modes, browserOverride) {
     const resolvedConfigPath = configPath ?? path.join(process.cwd(), "./as-test.config.json");
@@ -3235,8 +3197,8 @@ async function listExecutionPlan(command, configPath, selectors, modes, listFlag
             ? `No fuzz files matched: ${scope}`
             : `No test files matched: ${scope}`);
     }
-    const duplicateSpecBasenames = resolveDuplicateSpecBasenames(specFiles);
-    const duplicateFuzzBasenames = resolveDuplicateSpecBasenames(fuzzFiles);
+    const inputPatterns = await loadInputPatterns(configPath);
+    const fuzzInputPatterns = await loadFuzzInputPatterns(configPath);
     if (specFiles.length) {
         process.stdout.write(chalk.bold("Resolved files:\n"));
         for (const file of specFiles) {
@@ -3284,21 +3246,21 @@ async function listExecutionPlan(command, configPath, selectors, modes, listFlag
         if (specFiles.length) {
             process.stdout.write("  artifacts:\n");
             for (const file of specFiles) {
-                const artifactName = resolveArtifactFileNameForPreview(file, active.buildOptions.target, modeName, duplicateSpecBasenames);
+                const artifactName = resolveArtifactPath(file, inputPatterns);
                 process.stdout.write(`    - ${path.join(active.outDir, artifactName)}\n`);
             }
         }
         if (fuzzFiles.length && command == "test") {
             process.stdout.write("  fuzz artifacts:\n");
             for (const file of fuzzFiles) {
-                const artifactName = resolveArtifactFileNameForPreview(file, "bindings", modeName, duplicateFuzzBasenames);
+                const artifactName = resolveArtifactPath(file, fuzzInputPatterns);
                 process.stdout.write(`    - ${path.join(active.outDir, artifactName)}\n`);
             }
         }
         else if (command == "fuzz") {
             process.stdout.write("  artifacts:\n");
             for (const file of fuzzFiles) {
-                const artifactName = resolveArtifactFileNameForPreview(file, "bindings", modeName, duplicateFuzzBasenames);
+                const artifactName = resolveArtifactPath(file, fuzzInputPatterns);
                 process.stdout.write(`    - ${path.join(active.outDir, artifactName)}\n`);
             }
         }

package/bin/util.js

@@ -1398,3 +1398,83 @@ export function resolveProjectModule(specifier) {
     }
     return null;
 }
+// picomatch-compatible glob metacharacters; first occurrence marks the start
+// of the dynamic part of a pattern and everything before it is the static base.
+const GLOB_META_RE = /[*?[\](){}!|+@]/;
+// Longest non-glob prefix of a single pattern, returned with native separators.
+// Examples:
+//   "assembly/__tests__/**/*.spec.ts" -> "assembly/__tests__"
+//   "**/*.spec.ts"                    -> ""
+//   "assembly/foo.spec.ts"            -> "assembly" (no glob → use dirname)
+//   "/abs/path/**/*.ts"               -> "/abs/path"
+export function resolveGlobBase(pattern) {
+    const normalized = pattern.replace(/\\/g, "/");
+    const metaIdx = normalized.search(GLOB_META_RE);
+    let base;
+    if (metaIdx < 0) {
+        const dir = dirname(normalized);
+        base = dir == "." ? "" : dir;
+    }
+    else {
+        const slice = normalized.slice(0, metaIdx);
+        const lastSlash = slice.lastIndexOf("/");
+        base = lastSlash < 0 ? "" : slice.slice(0, lastSlash);
+    }
+    if (!base.length)
+        return "";
+    return base.split("/").join(sep);
+}
+// Strip the most-specific matching configured input base off `file`, returning
+// the path relative to that base (with native separators). If no base matches,
+// returns the basename of the file. Comparison is component-wise — so
+// "assembly/__tests" is not a prefix of "assembly/__tests__/foo.spec.ts".
+export function resolveSpecRelativePath(file, inputPatterns) {
+    const patterns = Array.isArray(inputPatterns)
+        ? inputPatterns
+        : [inputPatterns];
+    const absFile = resolve(process.cwd(), file);
+    const fileComponents = toComponents(absFile);
+    let bestBaseAbs = null;
+    let bestLength = -1;
+    for (const pattern of patterns) {
+        const base = resolveGlobBase(pattern);
+        const absBase = base.length
+            ? resolve(process.cwd(), base)
+            : resolve(process.cwd());
+        const baseComponents = toComponents(absBase);
+        if (!isComponentPrefix(baseComponents, fileComponents))
+            continue;
+        if (baseComponents.length > bestLength) {
+            bestBaseAbs = absBase;
+            bestLength = baseComponents.length;
+        }
+    }
+    if (bestBaseAbs == null)
+        return basename(file);
+    const rel = relative(bestBaseAbs, absFile);
+    return rel.length ? rel : basename(file);
+}
+// Compute the artifact path (relative to outDir) for a given spec/fuzz source
+// file. Strips ".ts" only, keeping ".spec" / ".fuzz" suffixes so spec and
+// fuzz artifacts can coexist in the same outDir.
+//   assembly/__tests__/array.spec.ts        -> "array.spec.wasm"
+//   assembly/__tests__/nested/array.spec.ts -> "nested/array.spec.wasm"
+//   assembly/__fuzz__/nested/array.fuzz.ts  -> "nested/array.fuzz.wasm"
+export function resolveArtifactPath(file, inputPatterns) {
+    const rel = resolveSpecRelativePath(file, inputPatterns);
+    return rel.replace(/\.ts$/i, ".wasm");
+}
+function toComponents(absPath) {
+    return absPath
+        .split(/[\\/]+/)
+        .filter((segment, idx) => segment.length || idx == 0);
+}
+function isComponentPrefix(prefix, full) {
+    if (prefix.length > full.length)
+        return false;
+    for (let i = 0; i < prefix.length; i++) {
+        if (prefix[i] !== full[i])
+            return false;
+    }
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.1.5",
+  "version": "1.1.6-patch.1",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",

package/transform/lib/coverage.js

@@ -298,10 +298,8 @@ export class CoverageTransform extends Visitor {
                     node.body.statements.unshift(coverStmt);
                 }
                 else if (node.body instanceof ExpressionStatement) {
-                    const expression = node.body.expression;
-                    node.body = Node.createBlockStatement([Node.createReturnStatement(expression, expression.range)], expression.range);
-                    const bodyBlock = node.body;
-                    bodyBlock.statements.unshift(coverStmt);
+                    const exprBody = node.body;
+                    exprBody.expression = createCoverExpression(point.hash, exprBody.expression, node);
                 }
                 this.withScope(point, () => {
                     this.visit(node.name, node);
@@ -445,6 +443,8 @@ export class CoverageTransform extends Visitor {
         super.visitReturnStatement(node);
         if (!node.value || isBuiltinCallExpression(node.value))
             return;
+        if (node.value.kind === NodeKind.This)
+            return;
         const path = node.range.source.normalizedPath;
         const point = this.createPoint(path, node.value, "Return");
         const replacer = new RangeTransform(node);