as-test 1.1.4 → 1.1.6-patch.1

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,27 +16,29 @@ 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;
         this.matched = 0;
         this.failed = 0;
         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);
+        key = normalizeSnapshotKeyPrefix(key, this.specBasename);
         if (!allowSnapshot)
             return { ok: true, expected: actual, warnMissing: false };
         if (!(key in this.data)) {
@@ -79,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")) {
@@ -245,21 +232,22 @@ 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)}::`;
     return key.startsWith(prefix) ? key.slice(prefix.length) : key;
 }
+function normalizeSnapshotKeyPrefix(key, specBasename) {
+    const sep = key.indexOf("::");
+    if (sep < 0)
+        return key;
+    return `${specBasename}::${key.slice(sep + 2)}`;
+}
 function qualifySnapshotKey(specFile, key) {
     return `${path.basename(specFile)}::${key}`;
 }
@@ -289,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))
@@ -554,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);
@@ -615,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);
@@ -634,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 = {
@@ -647,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";
@@ -690,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);
         }
@@ -705,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);
@@ -929,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);
@@ -1382,9 +1316,52 @@ function isAllowedCoverageSourceFile(file) {
     const lower = file.toLowerCase();
     return lower.endsWith(".ts") || lower.endsWith(".as");
 }
+// AssemblyScript normalizes node_modules/<pkg>/... to ~lib/<pkg>/... in Source.normalizedPath.
+// This set contains the root names that are actual AS stdlib modules, so we can distinguish
+// real stdlib (~lib/array.ts) from third-party packages (~lib/json-as/assembly/index.ts).
+const AS_STDLIB_ROOT_NAMES = new Set([
+    "array",
+    "arraybuffer",
+    "atomics",
+    "bindings",
+    "builtins",
+    "compat",
+    "console",
+    "crypto",
+    "dataview",
+    "date",
+    "diagnostics",
+    "error",
+    "function",
+    "iterator",
+    "map",
+    "math",
+    "memory",
+    "number",
+    "object",
+    "polyfills",
+    "process",
+    "reference",
+    "regexp",
+    "rt",
+    "set",
+    "shared",
+    "staticarray",
+    "string",
+    "symbol",
+    "table",
+    "typedarray",
+    "uri",
+    "util",
+    "vector",
+]);
 function isAssemblyScriptStdlibFile(file) {
-    if (file.startsWith("~lib/"))
-        return true;
+    if (file.startsWith("~lib/")) {
+        // Extract the first path segment after ~lib/ (strip any file extension)
+        const after = file.slice("~lib/".length);
+        const root = (after.split("/")[0] ?? "").replace(/\.[^.]+$/, "");
+        return AS_STDLIB_ROOT_NAMES.has(root);
+    }
     if (file.includes("/~lib/"))
         return true;
     if (file.startsWith("assemblyscript/std/"))
@@ -1402,6 +1379,21 @@ function classifyCoverageFile(file) {
 }
 function resolveCoverageDependencyPackage(file) {
     const normalized = file.replace(/\\/g, "/");
+    // AssemblyScript normalizes node_modules/<pkg>/... to ~lib/<pkg>/... at compile time.
+    // Handle that path format so coverage.mode and coverage.dependencies work at runtime.
+    if (normalized.startsWith("~lib/")) {
+        const after = normalized.slice("~lib/".length);
+        const segments = after.split("/").filter(Boolean);
+        if (!segments.length)
+            return null;
+        if (segments[0].startsWith("@")) {
+            if (segments.length < 2)
+                return null;
+            return `${segments[0]}/${segments[1]}`;
+        }
+        // Strip file extension for bare module entries like ~lib/json-as.ts (unusual but safe)
+        return segments[0].replace(/\.[^.]+$/, "") || null;
+    }
     const marker = "/node_modules/";
     const prefixed = normalized.startsWith("node_modules/")
         ? `/${normalized}`
@@ -1536,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,
@@ -1737,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,
@@ -1779,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,
@@ -1807,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,
@@ -1824,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,
@@ -1844,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,
@@ -1855,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;
@@ -2079,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,
@@ -2113,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,