as-test 1.1.1 → 1.1.2

package/bin/reporters/default.js

@@ -2,7 +2,7 @@ import chalk from "chalk";
 import { diff } from "typer-diff";
 import { readFileSync } from "fs";
 import * as path from "path";
-import { formatTime } from "../util.js";
+import { formatSpecDisplayPath, formatTime } from "../util.js";
 import { describeCoveragePoint, readCoverageSourceLine, resolveCoverageHighlightSpan, } from "../coverage-points.js";
 export const createReporter = (context) => {
     return new DefaultReporter(context);
@@ -55,7 +55,9 @@ class DefaultReporter {
     renderLiveState() {
         if (!this.canRewriteLine() || !this.currentFile)
             return;
-        const lines = [`${this.badgeRunning()} ${this.currentFile}`];
+        const lines = [
+            `${this.badgeRunning()} ${formatSpecDisplayPath(this.currentFile)}`,
+        ];
         for (const suite of this.openSuites) {
             lines.push(`${"  ".repeat(suite.depth + 1)}${this.badgeRunning()} ${suite.description}`);
         }
@@ -67,7 +69,7 @@ class DefaultReporter {
         const lines = [
             fileEnd
                 ? this.renderFileResult(fileEnd)
-                : `${this.badgeRunning()} ${this.currentFile}`,
+                : `${this.badgeRunning()} ${formatSpecDisplayPath(this.currentFile)}`,
         ];
         for (const suite of this.verboseSuites) {
             const badge = suite.verdict == "running"
@@ -112,13 +114,14 @@ class DefaultReporter {
     renderFileResult(event) {
         const verdict = event.verdict ?? "none";
         const time = event.time ? ` ${chalk.dim(event.time)}` : "";
+        const file = formatSpecDisplayPath(event.file);
         if (verdict == "fail")
-            return `${chalk.bgRed.white(" FAIL ")} ${event.file}${time}`;
+            return `${chalk.bgRed.white(" FAIL ")} ${file}${time}`;
         if (this.fileHasWarning)
-            return `${chalk.bgYellow.black(" WARN ")} ${event.file}${time}`;
+            return `${chalk.bgYellow.black(" WARN ")} ${file}${time}`;
         if (verdict == "ok")
-            return `${chalk.bgGreenBright.black(" PASS ")} ${event.file}${time}`;
-        return `${chalk.bgBlackBright.white(" SKIP ")} ${event.file}${time}`;
+            return `${chalk.bgGreenBright.black(" PASS ")} ${file}${time}`;
+        return `${chalk.bgBlackBright.white(" SKIP ")} ${file}${time}`;
     }
     onRunStart(event) {
         this.verboseMode = Boolean(event.verbose);
@@ -139,16 +142,16 @@ class DefaultReporter {
         }
         if (!this.verboseMode) {
             if (!this.canRewriteLine()) {
-                this.context.stdout.write(`${this.badgeRunning()} ${event.file}\n`);
+                this.context.stdout.write(`${this.badgeRunning()} ${formatSpecDisplayPath(event.file)}\n`);
                 return;
             }
             this.clearRenderedBlock();
-            this.context.stdout.write(`${this.badgeRunning()} ${event.file}`);
+            this.context.stdout.write(`${this.badgeRunning()} ${formatSpecDisplayPath(event.file)}`);
             this.renderedLines = 1;
             return;
         }
         if (!this.canRewriteLine()) {
-            this.context.stdout.write(`${this.badgeRunning()} ${event.file}\n`);
+            this.context.stdout.write(`${this.badgeRunning()} ${formatSpecDisplayPath(event.file)}\n`);
             return;
         }
         this.renderLiveState();
@@ -315,7 +318,7 @@ function renderFuzzFileSummary(context, results) {
     const detail = formatTime(averageFuzzModeTime(results));
     const crashFile = firstFuzzCrashFile(results);
     const crashSuffix = crashFile != null ? ` ${chalk.dim(`-> ${crashFile}`)}` : "";
-    context.stdout.write(`${itemBadge} ${path.basename(file)} ${chalk.dim(detail)}${crashSuffix}\n`);
+    context.stdout.write(`${itemBadge} ${formatSpecDisplayPath(file)} ${chalk.dim(detail)}${crashSuffix}\n`);
     renderFailedFuzzers(groupFuzzResultsByFile(results));
 }
 function renderFuzzSummary(context, event, hasRenderedTestFiles) {
@@ -335,7 +338,7 @@ function renderFailedFuzzers(results) {
                     console.log("");
                     rendered = true;
                 }
-                console.log(`${chalk.bgRed(" FAIL ")} ${chalk.dim(path.basename(modeResult.file))} ${chalk.dim("(crash)")}`);
+                console.log(`${chalk.bgRed(" FAIL ")} ${chalk.dim(formatSpecDisplayPath(modeResult.file))} ${chalk.dim("(crash)")}`);
                 console.log(chalk.dim(`Mode: ${modeResult.modeName}`));
                 console.log(chalk.dim(`Runs: ${modeResult.runs} configured`));
                 console.log(chalk.dim(`Repro: ${repro}`));
@@ -413,7 +416,9 @@ function buildFuzzReproCommand(file, seed, modeName, fuzzer, runs) {
     return `ast fuzz ${file}${modeArg}${fuzzerArg} --seed ${seed}${runsArg}`;
 }
 function formatFailingSeeds(fuzzer) {
-    return (fuzzer.failures ?? []).map((failure) => String(failure.seed)).join(", ");
+    return (fuzzer.failures ?? [])
+        .map((failure) => String(failure.seed))
+        .join(", ");
 }
 function toRelativeResultPath(file) {
     const relative = path.relative(process.cwd(), path.resolve(process.cwd(), file));
@@ -422,8 +427,8 @@ function toRelativeResultPath(file) {
 function formatFuzzFailureTitle(file, name) {
     const location = findFuzzLocation(file, name);
     const suffix = location
-        ? ` (${path.basename(file)}:${location})`
-        : ` (${path.basename(file)})`;
+        ? ` (${formatSpecDisplayPath(file)}:${location})`
+        : ` (${formatSpecDisplayPath(file)})`;
     return `${chalk.dim(name)}${chalk.dim(suffix)}`;
 }
 function findFuzzLocation(file, name) {
@@ -460,19 +465,24 @@ function renderFailedSuites(failedEntries) {
     if (!failedEntries.length)
         return;
     console.log("");
-    const printed = new Set();
+    const grouped = new Map();
     for (const failed of failedEntries) {
         const failedAny = failed;
         if (!failedAny?.file)
             continue;
         const file = String(failedAny.file);
-        collectSuiteFailures(failed, file, [], printed);
+        collectSuiteFailures(failed, file, [], grouped);
+    }
+    for (const failure of grouped.values()) {
+        renderCollectedFailure(failure);
     }
 }
-function collectSuiteFailures(suite, file, path, printed, inheritedModeName = "") {
+function collectSuiteFailures(suite, file, path, grouped, inheritedModeName = "") {
     const suiteAny = suite;
     const nextPath = [...path, String(suiteAny.description ?? "unknown")];
     const modeName = String(suiteAny.modeName ?? inheritedModeName);
+    const isRuntimeErrorSuite = String(suiteAny.kind ?? "") == "runtime-error";
+    const isBuildErrorSuite = String(suiteAny.kind ?? "") == "build-error";
     const tests = Array.isArray(suiteAny.tests)
         ? suiteAny.tests
         : [];
@@ -486,30 +496,159 @@ function collectSuiteFailures(suite, file, path, printed, inheritedModeName = ""
         const where = loc.length ? `${file}:${loc}` : file;
         const suitePath = String(suiteAny.path ?? "");
         const message = String(test.message ?? "");
-        const dedupeKey = `${file}::${modeName}::${title}::${String(test.left)}::${String(test.right)}::${message}`;
-        if (printed.has(dedupeKey))
-            continue;
-        printed.add(dedupeKey);
-        console.log(`${chalk.bgRed(" FAIL ")} ${chalk.dim(title)} ${chalk.dim("(" + where + ")")}`);
+        const left = test.left;
+        const right = test.right;
+        const dedupeKey = `${file}::${title}::${String(left)}::${String(right)}::${message}`;
+        let failure = grouped.get(dedupeKey);
+        if (!failure) {
+            failure = {
+                title,
+                where,
+                file,
+                suitePath,
+                left,
+                right,
+                message,
+                isRuntimeError: isRuntimeErrorSuite || String(test.type ?? "") == "runtime-error",
+                isBuildError: isBuildErrorSuite || String(test.type ?? "") == "build-error",
+                modes: new Set(),
+                runCommands: new Map(),
+                buildCommands: new Map(),
+            };
+            grouped.set(dedupeKey, failure);
+        }
         if (modeName.length) {
-            console.log(chalk.dim(`Mode: ${modeName}`));
+            failure.modes.add(modeName);
+        }
+        const runCommand = String(suiteAny.runCommand ?? "");
+        if (modeName.length && runCommand.length) {
+            failure.runCommands.set(modeName, runCommand);
         }
-        if (suitePath.length) {
-            console.log(chalk.dim(`Repro: ${buildSuiteReproCommand(toRelativeResultPath(file), suitePath, modeName)}`));
+        const buildCommand = String(suiteAny.buildCommand ?? "");
+        if (modeName.length && buildCommand.length) {
+            failure.buildCommands.set(modeName, buildCommand);
         }
-        renderAssertionFailureDetails(test.left, test.right, message);
     }
     const suites = Array.isArray(suiteAny.suites)
         ? suiteAny.suites
         : [];
     for (const sub of suites) {
-        collectSuiteFailures(sub, file, nextPath, printed, modeName);
+        collectSuiteFailures(sub, file, nextPath, grouped, modeName);
+    }
+}
+function renderCollectedFailure(failure) {
+    console.log(`${chalk.bgRed(" FAIL ")} ${chalk.dim(failure.title)} ${chalk.dim("(" + failure.where + ")")}`);
+    const modes = [...failure.modes].filter(Boolean).sort();
+    if (failure.isBuildError) {
+        renderBuildFailureDetails(failure, modes);
+    }
+    else if (failure.isRuntimeError) {
+        renderRuntimeFailureDetails(failure, modes);
+    }
+    else {
+        if (modes.length == 1) {
+            console.log(chalk.dim(`Mode: ${modes[0]}`));
+        }
+        else if (modes.length > 1) {
+            console.log(chalk.dim(`Modes: ${modes.join(", ")}`));
+        }
+        const relativeFile = toRelativeResultPath(failure.file);
+        const repro = failure.suitePath.length && modes.length == 1
+            ? buildSuiteReproCommand(relativeFile, failure.suitePath, modes[0])
+            : buildFileReproCommand(relativeFile, modes);
+        console.log(chalk.dim(`Repro: ${repro}`));
+        renderModeCommands("Build", failure.buildCommands, modes);
+        renderModeCommands("Run", failure.runCommands, modes);
+    }
+    renderAssertionFailureDetails(failure.left, failure.right, failure.message);
+}
+function renderBuildFailureDetails(failure, modes) {
+    console.log("");
+    console.log(chalk.bold(" Oops! Looks like the test failed to build!"));
+    console.log(chalk.dim(" Here's some details and reproduction instructions if that helps:"));
+    console.log("");
+    console.log(chalk.dim(` Mode(s): ${modes.join(", ") || "default"}`));
+    console.log("");
+    console.log(chalk.dim(" To reproduce, run the following commands:"));
+    for (const mode of modes.length ? modes : ["default"]) {
+        console.log(chalk.dim(` Mode: ${mode}`));
+        const buildCommand = failure.buildCommands.get(mode);
+        if (buildCommand?.length) {
+            console.log(chalk.dim(`  Build: ${buildCommand}`));
+        }
+    }
+    console.log("");
+    console.log(chalk.dim(" Here's a log dump too:"));
+}
+function renderRuntimeFailureDetails(failure, modes) {
+    console.log("");
+    console.log(chalk.bold(" Oops! Looks like the runtime crashed!"));
+    console.log(chalk.dim(" Here's some details and reproduction instructions if that helps:"));
+    console.log("");
+    console.log(chalk.dim(` Mode(s): ${modes.join(", ") || "default"}`));
+    console.log("");
+    console.log(chalk.dim(" To reproduce, run the following commands:"));
+    for (const mode of modes.length ? modes : ["default"]) {
+        console.log(chalk.dim(` Mode: ${mode}`));
+        const buildCommand = failure.buildCommands.get(mode);
+        if (buildCommand?.length) {
+            console.log(chalk.dim(`  Build: ${buildCommand}`));
+        }
+        const runCommand = buildRuntimeReproRunCommand(failure.runCommands.get(mode) ?? "", buildCommand ?? "");
+        if (runCommand.length) {
+            console.log(chalk.dim(`  Run: ${runCommand}`));
+        }
     }
+    console.log("");
+    console.log(chalk.dim(" Here's a log dump too:"));
 }
 function buildSuiteReproCommand(file, suitePath, modeName) {
     const modeArg = modeName && modeName != "default" ? ` --mode ${modeName}` : "";
     return `ast run ${file}${modeArg} --suite ${suitePath}`;
 }
+function buildFileReproCommand(file, modes) {
+    const normalizedModes = modes.filter(Boolean).sort();
+    if (normalizedModes.length == 1 && normalizedModes[0] != "default") {
+        return `ast run ${file} --mode ${normalizedModes[0]}`;
+    }
+    if (normalizedModes.length > 1 &&
+        normalizedModes.every((mode) => mode != "default")) {
+        return `ast run ${file} --mode ${normalizedModes.join(",")}`;
+    }
+    return `ast run ${file}`;
+}
+function renderModeCommands(label, commands, modes) {
+    if (!commands.size)
+        return;
+    const uniqueCommands = new Set([...commands.values()].filter(Boolean));
+    if (uniqueCommands.size == 1) {
+        console.log(chalk.dim(`${label}: ${[...uniqueCommands][0]}`));
+        return;
+    }
+    console.log(chalk.dim(`${label} commands:`));
+    for (const mode of modes) {
+        const command = commands.get(mode);
+        if (!command)
+            continue;
+        console.log(chalk.dim(`  [${mode}] ${command}`));
+    }
+}
+function buildRuntimeReproRunCommand(runCommand, buildCommand) {
+    if (!runCommand.length)
+        return "";
+    const artifactPath = extractBuildArtifactPath(buildCommand);
+    if (!artifactPath) {
+        return runCommand;
+    }
+    if (runCommand.includes(".as-test/runners/default.")) {
+        return `${runCommand} ${artifactPath}`;
+    }
+    return runCommand;
+}
+function extractBuildArtifactPath(buildCommand) {
+    const outMatch = buildCommand.match(/(?:^|\s)(?:-o|--outFile)\s+(?:"([^"]+)"|'([^']+)'|(\S+))/);
+    return outMatch?.[1] ?? outMatch?.[2] ?? outMatch?.[3] ?? null;
+}
 function normalizeFailureMessage(message) {
     return message.replace(/\r\n/g, "\n").trim();
 }
@@ -520,11 +659,13 @@ function renderAssertionFailureDetails(leftRaw, rightRaw, messageRaw) {
     if (left == "null" && right == "null") {
         const normalizedMessage = normalizeFailureMessage(message);
         if (normalizedMessage.length) {
+            console.log("");
             for (const line of normalizedMessage.split("\n")) {
                 console.log(chalk.dim(line));
             }
         }
         else {
+            console.log("");
             console.log(chalk.dim("runtime error"));
         }
         return;
@@ -656,7 +797,9 @@ function renderCoverageSummary(summary, showCoverage) {
     const pct = summary.total
         ? ((summary.covered * 100) / summary.total).toFixed(2)
         : "100.00";
-    const missingLabel = summary.uncovered == 1 ? "1 point missing" : `${summary.uncovered} points missing`;
+    const missingLabel = summary.uncovered == 1
+        ? "1 point missing"
+        : `${summary.uncovered} points missing`;
     const fileLabel = summary.files.length == 1 ? "1 file" : `${summary.files.length} files`;
     const color = Number(pct) >= 90
         ? chalk.greenBright
@@ -681,9 +824,7 @@ function renderCoverageSummary(summary, showCoverage) {
             : Number(filePct) >= 75
                 ? chalk.yellowBright
                 : chalk.redBright;
-        const suffix = file.uncovered > 0
-            ? `${file.uncovered} missing`
-            : "fully covered";
+        const suffix = file.uncovered > 0 ? `${file.uncovered} missing` : "fully covered";
         console.log(`    ${fileColor(filePct.padStart(6) + "%")}  ${toRelativeResultPath(file.file).padEnd(36)} ${chalk.dim(`${file.covered}/${file.total} covered, ${suffix}`)}`);
     }
     if (ranked.length > 8) {
@@ -732,7 +873,8 @@ function renderCoverageBar(percent) {
 function createCoverageGapLayout(points) {
     return {
         typeWidth: Math.max(...points.map((point) => point.displayType.length), 5),
-        locationWidth: Math.max(...points.map((point) => `${toRelativeResultPath(point.file)}:${point.line}:${point.column}`.length), 1),
+        locationWidth: Math.max(...points.map((point) => `${toRelativeResultPath(point.file)}:${point.line}:${point.column}`
+            .length), 1),
     };
 }
 function formatCoverageSnippet(file, line, column) {

package/bin/util.js

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "fs";
 import { BuildOptions, Config, CoverageOptions, CoverageIgnoreOptions, FuzzConfig, ModeConfig, ReporterConfig, RunOptions, Runtime, } from "./types.js";
 import chalk from "chalk";
 import { createRequire } from "module";
-import { delimiter, dirname, join, resolve } from "path";
+import { basename, delimiter, dirname, join, relative, resolve, sep, } from "path";
 import { fileURLToPath } from "url";
 const CONFIG_META = new WeakMap();
 export function formatTime(ms) {
@@ -28,6 +28,19 @@ export function formatTime(ms) {
     }
     return `${us}us`;
 }
+export function formatSpecDisplayPath(file) {
+    const resolved = resolve(file);
+    const parts = resolved.split(/[/\\]+/);
+    const testsIndex = parts.lastIndexOf("__tests__");
+    if (testsIndex >= 0 && testsIndex < parts.length - 1) {
+        return parts.slice(testsIndex + 1).join("/");
+    }
+    const rel = relative(process.cwd(), resolved).split(sep).join("/");
+    if (rel.length && rel != "." && rel != ".." && !rel.startsWith("../")) {
+        return rel;
+    }
+    return basename(resolved);
+}
 export function loadConfig(CONFIG_PATH, warn = false) {
     const resolvedPath = resolve(CONFIG_PATH);
     const raw = readConfigRaw(resolvedPath, warn);
@@ -102,9 +115,7 @@ function parseConfigRaw(raw, configPath) {
         : "";
     const cmd = runtimeRaw && typeof runtimeRaw.cmd == "string" && runtimeRaw.cmd.length
         ? runtimeRaw.cmd
-        : runtimeRaw &&
-            typeof runtimeRaw.run == "string" &&
-            runtimeRaw.run.length
+        : runtimeRaw && typeof runtimeRaw.run == "string" && runtimeRaw.run.length
             ? runtimeRaw.run
             : legacyRun
                 ? legacyRun
@@ -343,7 +354,9 @@ function validateCoverageValue(value, path, issues) {
     validateStringArrayField(obj, "include", path, issues);
     validateStringArrayField(obj, "exclude", path, issues);
     if ("ignore" in obj && obj.ignore != undefined) {
-        if (!obj.ignore || typeof obj.ignore != "object" || Array.isArray(obj.ignore)) {
+        if (!obj.ignore ||
+            typeof obj.ignore != "object" ||
+            Array.isArray(obj.ignore)) {
             issues.push({
                 path: `${path}.ignore`,
                 message: "must be an object",
@@ -967,14 +980,19 @@ function cloneConfig(config) {
     cloned.runOptions = cloneRunOptions(config.runOptions);
     cloned.fuzz = cloneFuzzConfig(config.fuzz);
     cloned.coverage = cloneCoverageOptions(config.coverage);
-    cloned.modes = Object.fromEntries(Object.entries(config.modes).map(([name, mode]) => [name, cloneModeConfig(mode)]));
+    cloned.modes = Object.fromEntries(Object.entries(config.modes).map(([name, mode]) => [
+        name,
+        cloneModeConfig(mode),
+    ]));
     CONFIG_META.set(cloned, getConfigMeta(config));
     return cloned;
 }
 function outputOverridesField(raw, field) {
     if (field in raw)
         return true;
-    if (!raw.output || typeof raw.output != "object" || Array.isArray(raw.output)) {
+    if (!raw.output ||
+        typeof raw.output != "object" ||
+        Array.isArray(raw.output)) {
         return false;
     }
     const output = raw.output;
@@ -1023,7 +1041,9 @@ function mergeCoverageConfig(base, override, raw) {
         mergedBase.include = [...overrideOptions.include];
     if ("exclude" in rawObject)
         mergedBase.exclude = [...overrideOptions.exclude];
-    if (rawObject.ignore && typeof rawObject.ignore == "object" && !Array.isArray(rawObject.ignore)) {
+    if (rawObject.ignore &&
+        typeof rawObject.ignore == "object" &&
+        !Array.isArray(rawObject.ignore)) {
         mergedBase.ignore = mergeCoverageIgnoreOptions(mergedBase.ignore, overrideOptions.ignore, rawObject.ignore);
     }
     return mergedBase;
@@ -1068,7 +1088,8 @@ function mergeRunOptions(base, override, raw) {
     const merged = cloneRunOptions(base);
     if ("runtime" in raw || "run" in raw) {
         const runtimeRaw = raw.runtime;
-        if ("run" in raw || (runtimeRaw && ("cmd" in runtimeRaw || "run" in runtimeRaw))) {
+        if ("run" in raw ||
+            (runtimeRaw && ("cmd" in runtimeRaw || "run" in runtimeRaw))) {
             merged.runtime.cmd = override.runtime.cmd;
         }
         if (runtimeRaw && "browser" in runtimeRaw) {
@@ -1126,10 +1147,14 @@ function mergeRootConfig(base, override) {
     if ("env" in raw) {
         merged.env = { ...override.env };
     }
-    if (raw.buildOptions && typeof raw.buildOptions == "object" && !Array.isArray(raw.buildOptions)) {
+    if (raw.buildOptions &&
+        typeof raw.buildOptions == "object" &&
+        !Array.isArray(raw.buildOptions)) {
         merged.buildOptions = mergeBuildOptions(merged.buildOptions, override.buildOptions, raw.buildOptions);
     }
-    if (raw.runOptions && typeof raw.runOptions == "object" && !Array.isArray(raw.runOptions)) {
+    if (raw.runOptions &&
+        typeof raw.runOptions == "object" &&
+        !Array.isArray(raw.runOptions)) {
         merged.runOptions = mergeRunOptions(merged.runOptions, override.runOptions, raw.runOptions);
     }
     if (raw.fuzz && typeof raw.fuzz == "object" && !Array.isArray(raw.fuzz)) {

package/lib/build/index.js

@@ -5,7 +5,6 @@ import http from "http";
 import os from "os";
 import path from "path";
 import { pathToFileURL } from "url";
-import { WASI } from "wasi";
 import { buildWebRunnerClientSource } from "./web-runner/client.js";
 import { buildWebRunnerHtml } from "./web-runner/html.js";
 import { buildWebRunnerWorkerSource } from "./web-runner/worker.js";
@@ -25,29 +24,81 @@ function withNodeIo(imports) {
 }
 export async function instantiate(imports) {
     validateImports(imports, "instantiate");
-    const wasmPath = process.env.AS_TEST_WASM_PATH;
-    if (!wasmPath || !wasmPath.length) {
-        throw new Error("AS_TEST_WASM_PATH is not set; as-test must resolve the wasm artifact before launching the runner");
-    }
-    const target = (process.env.AS_TEST_RUNTIME_TARGET || "bindings");
+    const wasmPath = resolveWasmPath();
+    const target = resolveRuntimeTarget();
     if (target == "wasi") {
         return instantiateWasiInstance(wasmPath, imports);
     }
     if (target == "web") {
         return instantiateWebInstance(wasmPath, imports);
     }
-    const kind = (process.env.AS_TEST_BINDINGS_KIND || "none");
+    const helperPath = resolveBindingsHelperPath(wasmPath);
+    const kind = resolveBindingsKind(helperPath);
     if (kind == "raw") {
-        return instantiateRawInstance(wasmPath, imports);
+        return instantiateRawInstance(wasmPath, helperPath, imports);
     }
     if (kind == "esm") {
-        return instantiateEsmInstance(wasmPath, imports);
+        return instantiateEsmInstance(wasmPath, helperPath, imports);
     }
     if (kind == "none") {
         return instantiateNoBindingsInstance(wasmPath, imports);
     }
     throw new Error(`unsupported bindings kind "${kind}"`);
 }
+function resolveRuntimeTarget() {
+    const envTarget = process.env.AS_TEST_RUNTIME_TARGET?.trim();
+    if (envTarget == "bindings" || envTarget == "wasi" || envTarget == "web") {
+        return envTarget;
+    }
+    const runnerPath = String(process.argv[1] ?? "");
+    if (runnerPath.includes(".wasi."))
+        return "wasi";
+    if (runnerPath.includes(".web."))
+        return "web";
+    return "bindings";
+}
+function resolveWasmPath() {
+    const envWasmPath = process.env.AS_TEST_WASM_PATH?.trim();
+    if (envWasmPath?.length) {
+        return path.resolve(envWasmPath);
+    }
+    const argWasmPath = process.argv[2]?.trim();
+    if (argWasmPath?.length) {
+        return path.resolve(argWasmPath);
+    }
+    const runnerPath = String(process.argv[1] ?? "");
+    const runnerName = path.basename(runnerPath || "runner.js");
+    throw new Error([
+        "No wasm artifact was provided for this runner.",
+        "",
+        `Direct usage: node .as-test/runners/${runnerName} .as-test/build/<artifact>.wasm`,
+        "Managed usage: bunx ast test --mode <mode>",
+        "",
+        "as-test normally sets AS_TEST_WASM_PATH automatically when it launches the runner.",
+    ].join("\n"));
+}
+function resolveBindingsHelperPath(wasmPath) {
+    const envHelperPath = process.env.AS_TEST_HELPER_PATH?.trim();
+    if (envHelperPath?.length) {
+        return path.resolve(envHelperPath);
+    }
+    const candidate = wasmPath.replace(/\.wasm$/i, ".js");
+    return fs.existsSync(candidate) ? candidate : "";
+}
+function resolveBindingsKind(helperPath) {
+    const envKind = process.env.AS_TEST_BINDINGS_KIND?.trim();
+    if (envKind == "raw" || envKind == "esm" || envKind == "none") {
+        return envKind;
+    }
+    if (!helperPath.length) {
+        return "none";
+    }
+    const source = fs.readFileSync(helperPath, "utf8");
+    if (/\bexport\s+(?:async\s+)?function\s+instantiate\b/.test(source)) {
+        return "raw";
+    }
+    return "esm";
+}
 function validateImports(imports, fnName) {
     if (arguments.length < 1) {
         throw new Error(`${fnName}(imports) requires an imports object; pass {} when unused`);
@@ -135,9 +186,8 @@ function mergeImports(...groups) {
     }
     return out;
 }
-async function instantiateRawInstance(wasmPath, imports) {
+async function instantiateRawInstance(wasmPath, helperPath, imports) {
     validateImports(imports, "instantiateRawInstance");
-    const helperPath = process.env.AS_TEST_HELPER_PATH || "";
     if (!helperPath.length) {
         throw new Error("bindings kind is raw but AS_TEST_HELPER_PATH is not set");
     }
@@ -153,9 +203,8 @@ async function instantiateRawInstance(wasmPath, imports) {
     });
     return decorateInstance(instance, "bindings");
 }
-async function instantiateEsmInstance(wasmPath, imports) {
+async function instantiateEsmInstance(wasmPath, helperPath, imports) {
     validateImports(imports, "instantiateEsmInstance");
-    const helperPath = process.env.AS_TEST_HELPER_PATH || "";
     if (!helperPath.length) {
         throw new Error("bindings kind is esm but AS_TEST_HELPER_PATH is not set");
     }
@@ -175,6 +224,7 @@ async function instantiateNoBindingsInstance(wasmPath, imports) {
 async function instantiateWasiInstance(wasmPath, imports) {
     validateImports(imports, "instantiateWasiInstance");
     suppressExperimentalWasiWarning();
+    const { WASI } = await import("wasi");
     const binary = fs.readFileSync(wasmPath);
     const module = new WebAssembly.Module(binary);
     const wasi = new WASI({
@@ -194,7 +244,8 @@ async function instantiateWebInstance(wasmPath, imports) {
     if (hasUserImports(imports)) {
         throw new Error("web runtime does not support custom imports in the default runner; pass {} or write a custom web runner");
     }
-    const bindingsKind = (process.env.AS_TEST_BINDINGS_KIND || "raw");
+    const bindingsKind = (process.env.AS_TEST_BINDINGS_KIND ||
+        "raw");
     const helperPath = process.env.AS_TEST_HELPER_PATH
         ? path.resolve(process.cwd(), process.env.AS_TEST_HELPER_PATH)
         : wasmPath.replace(/\.wasm$/, ".js");
@@ -420,9 +471,9 @@ async function instantiateWebInstance(wasmPath, imports) {
                     ...headers,
                     "Content-Type": "text/html; charset=utf-8",
                 });
-                res.end(html.replace("</body>", '    <script>window.__AS_TEST_ENV__ = ' +
+                res.end(html.replace("</body>", "    <script>window.__AS_TEST_ENV__ = " +
                     JSON.stringify(webRuntimeEnv) +
-                    ';</script>\n  </body>'));
+                    ";</script>\n  </body>"));
                 return;
             }
             if (url == "/client.js") {
@@ -500,9 +551,7 @@ async function instantiateWebInstance(wasmPath, imports) {
             });
             socket.on("error", (error) => {
                 if (!finished) {
-                    rejectOnce(error instanceof Error
-                        ? error
-                        : new Error(String(error)));
+                    rejectOnce(error instanceof Error ? error : new Error(String(error)));
                 }
             });
             flushPendingFrames();
@@ -600,7 +649,7 @@ function suppressExperimentalWasiWarning() {
         const message = typeof warning == "string"
             ? warning
             : String(warning && typeof warning == "object" && "message" in warning
-                ? warning.message ?? ""
+                ? (warning.message ?? "")
                 : "");
         if (name == "ExperimentalWarning" &&
             message.includes("WASI is an experimental feature")) {
@@ -731,7 +780,7 @@ function openWithReusableBrowserWindow(url) {
 }
 function openWithSystemBrowser(url) {
     if (process.env.BROWSER) {
-        return spawnBrowserCommand(process.env.BROWSER, url, false)?.process ?? null;
+        return (spawnBrowserCommand(process.env.BROWSER, url, false)?.process ?? null);
     }
     if (process.platform == "darwin") {
         if (!hasExecutable("open"))
@@ -788,7 +837,7 @@ function buildMacBrowserOpenScript(appName, url) {
         return [
             `tell application "${escapedApp}"`,
             "activate",
-            'if (count of windows) = 0 then make new window',
+            "if (count of windows) = 0 then make new window",
             `set URL of active tab of front window to "${escapedUrl}"`,
             "end tell",
         ];
@@ -797,7 +846,7 @@ function buildMacBrowserOpenScript(appName, url) {
         return [
             `tell application "${escapedApp}"`,
             "activate",
-            'if (count of windows) = 0 then make new document',
+            "if (count of windows) = 0 then make new document",
             `set URL of front document to "${escapedUrl}"`,
             "end tell",
         ];
@@ -1107,7 +1156,8 @@ async function captureHelperInstance(runHelper) {
         await runHelper();
     }
     finally {
-        WebAssembly.instantiate = originalInstantiate;
+        WebAssembly.instantiate =
+            originalInstantiate;
     }
     if (!instance) {
         throw new Error("bindings helper did not produce a WebAssembly.Instance");