as-test 0.5.1 → 0.5.3

package/bin/run.js

@@ -1,11 +1,12 @@
 import chalk from "chalk";
 import { spawn } from "child_process";
 import { glob } from "glob";
-import { getExec, loadConfig } from "./util.js";
+import { applyMode, getExec, loadConfig } from "./util.js";
 import * as path from "path";
 import { pathToFileURL } from "url";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { createReporter as createDefaultReporter } from "./reporters/default.js";
+import { createTapReporter } from "./reporters/tap.js";
 const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
 var MessageType;
 (function (MessageType) {
@@ -145,19 +146,26 @@ class SnapshotStore {
 export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selectors = [], shouldExit = true, options = {}) {
     const resolvedConfigPath = configPath ?? DEFAULT_CONFIG_PATH;
     const reports = [];
-    const config = loadConfig(resolvedConfigPath);
+    const loadedConfig = loadConfig(resolvedConfigPath);
+    const mode = applyMode(loadedConfig, options.modeName);
+    const config = mode.config;
     const inputPatterns = resolveInputPatterns(config.input, selectors);
-    const inputFiles = await glob(inputPatterns);
+    const inputFiles = (await glob(inputPatterns)).sort((a, b) => a.localeCompare(b));
     const snapshotEnabled = flags.snapshot !== false;
     const updateSnapshots = Boolean(flags.updateSnapshots);
     const cleanOutput = Boolean(flags.clean);
     const showCoverage = Boolean(flags.showCoverage);
     const coverage = resolveCoverageOptions(config.coverage);
+    if (flags.coverage != undefined) {
+        coverage.enabled = Boolean(flags.coverage);
+    }
     const coverageEnabled = coverage.enabled;
     const coverageDir = config.coverageDir ?? "./.as-test/coverage";
     const runtimeCommand = resolveRuntimeCommand(getConfiguredRuntimeCmd(config), config.buildOptions.target);
+    const reporterSelection = resolveReporterSelection(options.reporterPath, config.runOptions.reporter);
+    const reporterKind = options.reporterKind ?? reporterSelection.kind;
     const reporter = options.reporter ??
-        (await loadReporter(config.runOptions.reporter, resolvedConfigPath, {
+        (await loadReporter(reporterSelection, resolvedConfigPath, {
             stdout: process.stdout,
             stderr: process.stderr,
         }));
@@ -191,7 +199,7 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
     };
     for (let i = 0; i < inputFiles.length; i++) {
         const file = inputFiles[i];
-        const outFile = path.join(config.outDir, file.slice(file.lastIndexOf("/") + 1).replace(".ts", ".wasm"));
+        const outFile = path.join(config.outDir, resolveArtifactFileName(file, config.buildOptions.target, options.modeName));
         const fileBase = file
             .slice(file.lastIndexOf("/") + 1)
             .replace(".ts", "")
@@ -199,16 +207,21 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
         let cmd = runtimeCommand.replace(command, execPath);
         cmd = cmd.replace("<name>", fileBase);
         if (config.buildOptions.target == "bindings" && !cmd.includes("<file>")) {
-            cmd = cmd.replace("<file>", outFile
-                .replace("build", "tests")
-                .replace(".spec", "")
-                .replace(".wasm", ".run.js"));
+            cmd = cmd.replace("<file>", resolveBindingsHelperPath(outFile));
         }
         else {
             cmd = cmd.replace("<file>", outFile);
         }
         const snapshotStore = new SnapshotStore(file, config.snapshotDir);
-        const report = await runProcess(cmd, snapshotStore, snapshotEnabled, updateSnapshots, reporter);
+        let report;
+        try {
+            report = await runProcess(cmd, snapshotStore, snapshotEnabled, updateSnapshots, reporter, reporterKind == "tap", mode.env);
+        }
+        catch (error) {
+            const modeLabel = options.modeName ?? "default";
+            const details = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to run ${path.basename(file)} in mode ${modeLabel} with ${details}`);
+        }
         const normalized = normalizeReport(report);
         snapshotStore.flush();
         snapshotSummary.matched += snapshotStore.matched;
@@ -232,6 +245,9 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
         writeFileSync(path.join(process.cwd(), config.logs, options.logFileName ?? "test.log.json"), JSON.stringify(logReports, null, 2));
     }
     const stats = collectRunStats(reports.map((report) => report.suites));
+    if (options.fileSummaryTotal != undefined) {
+        applyConfiguredFileTotalToStats(stats, options.fileSummaryTotal);
+    }
     const coverageSummary = collectCoverageSummary(reports, coverageEnabled, showCoverage, coverage);
     if (coverageEnabled &&
         coverageDir &&
@@ -244,6 +260,10 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
         writeFileSync(path.join(resolvedCoverageDir, options.coverageFileName ?? "coverage.log.json"), JSON.stringify(coverageSummary, null, 2));
     }
     if (options.emitRunComplete !== false) {
+        const totalModes = Math.max(options.modeSummaryTotal ?? 1, 1);
+        const executedModes = Math.min(Math.max(options.modeSummaryExecuted ?? 1, 1), totalModes);
+        const unexecutedModes = Math.max(0, totalModes - executedModes);
+        const modeFailed = Boolean(stats.failedFiles || snapshotSummary.failed);
         reporter.onRunComplete?.({
             clean: cleanOutput,
             snapshotEnabled,
@@ -252,6 +272,11 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
             coverageSummary,
             stats,
             reports,
+            modeSummary: {
+                failed: modeFailed ? 1 : 0,
+                skipped: unexecutedModes + (modeFailed || stats.passedFiles > 0 ? 0 : 1),
+                total: totalModes,
+            },
         });
     }
     const failed = Boolean(stats.failedFiles || snapshotSummary.failed);
@@ -266,35 +291,59 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
         reports,
     };
 }
+function applyConfiguredFileTotalToStats(stats, fileSummaryTotal) {
+    const total = Math.max(fileSummaryTotal, 0);
+    const executed = stats.failedFiles + stats.passedFiles + stats.skippedFiles;
+    const unexecuted = Math.max(0, total - executed);
+    stats.skippedFiles += unexecuted;
+}
 function resolveRuntimeCommand(runtimeRun, target, emitWarnings = true) {
-    const normalized = resolveLegacyWasiRuntime(runtimeRun, target, emitWarnings);
+    const normalized = resolveLegacyRuntime(runtimeRun, target, emitWarnings);
     return fallbackToDefaultRuntime(normalized, target, emitWarnings);
 }
-function resolveLegacyWasiRuntime(runtimeRun, target, emitWarnings) {
-    if (target != "wasi")
-        return runtimeRun;
-    const preferredPath = "./.as-test/runners/default.wasi.js";
-    const legacyPaths = ["./bin/wasi-run.js", "./.as-test/wasi/wasi.run.js"];
-    if (runtimeRun.includes(preferredPath)) {
-        const resolvedPreferredPath = path.join(process.cwd(), preferredPath);
-        if (existsSync(resolvedPreferredPath))
+function resolveLegacyRuntime(runtimeRun, target, emitWarnings) {
+    if (target == "wasi") {
+        const preferredPath = "./.as-test/runners/default.wasi.js";
+        const legacyPaths = ["./bin/wasi-run.js", "./.as-test/wasi/wasi.run.js"];
+        if (runtimeRun.includes(preferredPath)) {
+            ensureDefaultRuntimeRunner("wasi", emitWarnings);
             return runtimeRun;
-        throw new Error(`could not locate WASI runner at ${preferredPath}. Run "ast init --target wasi --force --yes" to scaffold the local runner.`);
+        }
+        for (const legacyPath of legacyPaths) {
+            if (!runtimeRun.includes(legacyPath))
+                continue;
+            const resolvedLegacyPath = path.join(process.cwd(), legacyPath);
+            if (existsSync(resolvedLegacyPath))
+                return runtimeRun;
+            ensureDefaultRuntimeRunner("wasi", emitWarnings);
+            if (emitWarnings) {
+                process.stderr.write(chalk.dim(`legacy WASI runtime path detected (${legacyPath}); using ${preferredPath}\n`));
+            }
+            return runtimeRun.replace(legacyPath, preferredPath);
+        }
+        return runtimeRun;
     }
-    for (const legacyPath of legacyPaths) {
-        if (!runtimeRun.includes(legacyPath))
-            continue;
-        const resolvedLegacyPath = path.join(process.cwd(), legacyPath);
-        if (existsSync(resolvedLegacyPath))
+    if (target == "bindings") {
+        const preferredPath = "./.as-test/runners/default.bindings.js";
+        const legacyPath = "./.as-test/runners/default.run.js";
+        if (runtimeRun.includes(preferredPath)) {
+            ensureDefaultRuntimeRunner("bindings", emitWarnings);
             return runtimeRun;
-        const resolvedPreferredPath = path.join(process.cwd(), preferredPath);
-        if (existsSync(resolvedPreferredPath)) {
+        }
+        if (runtimeRun.includes(legacyPath)) {
+            const resolvedLegacyPath = path.join(process.cwd(), legacyPath);
+            if (existsSync(resolvedLegacyPath)) {
+                if (emitWarnings) {
+                    process.stderr.write(chalk.dim(`deprecated runtime script (${legacyPath}) detected; prefer ${preferredPath}\n`));
+                }
+                return runtimeRun;
+            }
+            ensureDefaultRuntimeRunner("bindings", emitWarnings);
             if (emitWarnings) {
-                process.stderr.write(chalk.dim(`legacy WASI runtime path detected (${legacyPath}); using ${preferredPath}\n`));
+                process.stderr.write(chalk.dim(`legacy bindings runtime path detected (${legacyPath}); using ${preferredPath}\n`));
             }
             return runtimeRun.replace(legacyPath, preferredPath);
         }
-        throw new Error(`could not locate WASI runner. Expected ${legacyPath} or ${preferredPath}. Run "ast init --target wasi --force --yes" to scaffold the local runner.`);
     }
     return runtimeRun;
 }
@@ -307,15 +356,12 @@ function fallbackToDefaultRuntime(runtimeRun, target, emitWarnings) {
         : path.join(process.cwd(), scriptPath);
     if (existsSync(resolvedScriptPath))
         return runtimeRun;
-    const fallback = getDefaultRuntimeFallback(target);
+    const fallback = ensureDefaultRuntimeRunner(target, emitWarnings);
     if (!fallback)
         return runtimeRun;
     const resolvedFallbackPath = path.join(process.cwd(), fallback.scriptPath);
-    if (!existsSync(resolvedFallbackPath)) {
-        if (scriptPath == fallback.scriptPath) {
-            throw new Error(`could not locate runtime script at ${fallback.scriptPath}. Run "ast init --target ${target} --force --yes" to scaffold the local runner.`);
-        }
-        throw new Error(`could not locate runtime script at ${scriptPath}. Default runner ${fallback.scriptPath} is also missing. Run "ast init --target ${target} --force --yes" to scaffold it.`);
+    if (resolvedScriptPath == resolvedFallbackPath || scriptPath == fallback.scriptPath) {
+        return runtimeRun;
     }
     if (emitWarnings) {
         process.stderr.write(chalk.dim(`runtime script not found (${scriptPath}); using ${fallback.scriptPath}\n`));
@@ -331,12 +377,169 @@ function getDefaultRuntimeFallback(target) {
     }
     if (target == "bindings") {
         return {
-            command: "node ./.as-test/runners/default.run.js <file>",
-            scriptPath: "./.as-test/runners/default.run.js",
+            command: "node ./.as-test/runners/default.bindings.js <file>",
+            scriptPath: "./.as-test/runners/default.bindings.js",
         };
     }
     return null;
 }
+function ensureDefaultRuntimeRunner(target, emitWarnings) {
+    const fallback = getDefaultRuntimeFallback(target);
+    if (!fallback)
+        return null;
+    const resolvedScriptPath = path.join(process.cwd(), fallback.scriptPath);
+    if (existsSync(resolvedScriptPath))
+        return fallback;
+    const source = getDefaultRuntimeRunnerSource(target);
+    if (!source)
+        return fallback;
+    if (!existsSync(path.dirname(resolvedScriptPath))) {
+        mkdirSync(path.dirname(resolvedScriptPath), { recursive: true });
+    }
+    writeFileSync(resolvedScriptPath, source);
+    if (emitWarnings) {
+        process.stderr.write(chalk.dim(`runtime script missing; created ${fallback.scriptPath}\n`));
+    }
+    return fallback;
+}
+function getDefaultRuntimeRunnerSource(target) {
+    if (target == "wasi") {
+        return `import { readFileSync } from "fs";
+import { WASI } from "wasi";
+
+const originalEmitWarning = process.emitWarning.bind(process);
+process.emitWarning = ((warning, ...args) => {
+  const type = typeof args[0] == "string" ? args[0] : "";
+  const name = typeof warning?.name == "string" ? warning.name : type;
+  const message =
+    typeof warning == "string" ? warning : String(warning?.message ?? "");
+  if (
+    name == "ExperimentalWarning" &&
+    message.includes("WASI is an experimental feature")
+  ) {
+    return;
+  }
+  return originalEmitWarning(warning, ...args);
+});
+
+const wasmPath = process.argv[2];
+if (!wasmPath) {
+  process.stderr.write("usage: node ./.as-test/runners/default.wasi.js <file.wasm>\\n");
+  process.exit(1);
+}
+
+try {
+  const wasi = new WASI({
+    version: "preview1",
+    args: [wasmPath],
+    env: process.env,
+    preopens: {},
+  });
+
+  const binary = readFileSync(wasmPath);
+  const module = new WebAssembly.Module(binary);
+  const instance = new WebAssembly.Instance(module, {
+    wasi_snapshot_preview1: wasi.wasiImport,
+  });
+  wasi.start(instance);
+} catch (error) {
+  process.stderr.write("failed to run WASI module: " + String(error) + "\\n");
+  process.exit(1);
+}
+`;
+    }
+    if (target == "bindings") {
+        return `import fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+
+let patched = false;
+
+function readExact(length) {
+  const out = Buffer.alloc(length);
+  let offset = 0;
+  while (offset < length) {
+    let read = 0;
+    try {
+      read = fs.readSync(0, out, offset, length - offset, null);
+    } catch (error) {
+      if (error && error.code === "EAGAIN") {
+        continue;
+      }
+      throw error;
+    }
+    if (!read) break;
+    offset += read;
+  }
+  const view = out.subarray(0, offset);
+  return view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
+}
+
+function writeRaw(data) {
+  const view = Buffer.from(data);
+  fs.writeSync(1, view);
+}
+
+function withNodeIo(imports = {}) {
+  if (!patched) {
+    patched = true;
+    const originalWrite = process.stdout.write.bind(process.stdout);
+    process.stdout.write = (chunk, ...args) => {
+      if (chunk instanceof ArrayBuffer) {
+        writeRaw(chunk);
+        return true;
+      }
+      return originalWrite(chunk, ...args);
+    };
+    process.stdin.read = (size) => readExact(Number(size ?? 0));
+  }
+  return imports;
+}
+
+const wasmPathArg = process.argv[2];
+if (!wasmPathArg) {
+  process.stderr.write("usage: node ./.as-test/runners/default.bindings.js <file.wasm>\\n");
+  process.exit(1);
+}
+
+const wasmPath = path.resolve(process.cwd(), wasmPathArg);
+const jsPath = wasmPath.replace(/\\.wasm$/, ".js");
+
+try {
+  const binary = fs.readFileSync(wasmPath);
+  const module = new WebAssembly.Module(binary);
+  const mod = await import(pathToFileURL(jsPath).href);
+  if (typeof mod.instantiate !== "function") {
+    throw new Error("bindings helper missing instantiate export");
+  }
+  mod.instantiate(module, withNodeIo({}));
+} catch (error) {
+  process.stderr.write("failed to run bindings module: " + String(error) + "\\n");
+  process.exit(1);
+}
+`;
+    }
+    return null;
+}
+function resolveArtifactFileName(file, target, modeName) {
+    const base = path
+        .basename(file)
+        .replace(/\.spec\.ts$/, "")
+        .replace(/\.ts$/, "");
+    if (!modeName) {
+        return `${path.basename(file).replace(".ts", ".wasm")}`;
+    }
+    return `${base}.${modeName}.${target}.wasm`;
+}
+function resolveBindingsHelperPath(wasmPath) {
+    const bindingsPath = wasmPath.replace(/\.wasm$/, ".bindings.js");
+    if (existsSync(bindingsPath))
+        return bindingsPath;
+    const legacyRunPath = wasmPath.replace(/\.wasm$/, ".run.js");
+    if (existsSync(legacyRunPath))
+        return legacyRunPath;
+    return bindingsPath;
+}
 function extractRuntimeScriptPath(runtimeRun) {
     const tokens = runtimeRun.trim().split(/\s+/).filter((token) => token.length > 0);
     if (tokens.length < 2)
@@ -415,7 +618,7 @@ function resolveInputPatterns(configured, selectors) {
     if (!selectors.length)
         return configuredInputs;
     const patterns = new Set();
-    for (const selector of selectors) {
+    for (const selector of expandSelectors(selectors)) {
         if (!selector)
             continue;
         if (isBareSuiteSelector(selector)) {
@@ -429,6 +632,30 @@ function resolveInputPatterns(configured, selectors) {
     }
     return [...patterns];
 }
+function expandSelectors(selectors) {
+    const expanded = [];
+    for (const selector of selectors) {
+        if (!selector)
+            continue;
+        if (!shouldSplitSelector(selector)) {
+            expanded.push(selector);
+            continue;
+        }
+        for (const token of selector.split(",")) {
+            const trimmed = token.trim();
+            if (!trimmed.length)
+                continue;
+            expanded.push(trimmed);
+        }
+    }
+    return expanded;
+}
+function shouldSplitSelector(selector) {
+    return (selector.includes(",") &&
+        !selector.includes("/") &&
+        !selector.includes("\\") &&
+        !/[*?[\]{}]/.test(selector));
+}
 function isBareSuiteSelector(selector) {
     return (!selector.includes("/") &&
         !selector.includes("\\") &&
@@ -644,10 +871,11 @@ function compareCoveragePoints(a, b) {
         return a.type.localeCompare(b.type);
     return a.hash.localeCompare(b.hash);
 }
-async function runProcess(cmd, snapshots, snapshotEnabled, updateSnapshots, reporter) {
+async function runProcess(cmd, snapshots, snapshotEnabled, updateSnapshots, reporter, tapMode = false, env = process.env) {
     const child = spawn(cmd, {
         stdio: ["pipe", "pipe", "pipe"],
         shell: true,
+        env,
     });
     let report = null;
     let parseError = null;
@@ -671,7 +899,12 @@ async function runProcess(cmd, snapshots, snapshotEnabled, updateSnapshots, repo
     });
     class TestChannel extends Channel {
         onPassthrough(data) {
-            process.stdout.write(data);
+            if (tapMode) {
+                process.stderr.write(data);
+            }
+            else {
+                process.stdout.write(data);
+            }
         }
         onCall(msg) {
             const event = msg;
@@ -871,21 +1104,32 @@ function mergeVerdict(current, next) {
         return "skip";
     return "none";
 }
-export async function createRunReporter(configPath = DEFAULT_CONFIG_PATH) {
+export async function createRunReporter(configPath = DEFAULT_CONFIG_PATH, reporterPath, modeName) {
     const resolvedConfigPath = configPath ?? DEFAULT_CONFIG_PATH;
-    const config = loadConfig(resolvedConfigPath);
-    const reporter = await loadReporter(config.runOptions.reporter, resolvedConfigPath, {
+    const loadedConfig = loadConfig(resolvedConfigPath);
+    const mode = applyMode(loadedConfig, modeName);
+    const config = mode.config;
+    const selection = resolveReporterSelection(reporterPath, config.runOptions.reporter);
+    const reporter = await loadReporter(selection, resolvedConfigPath, {
         stdout: process.stdout,
         stderr: process.stderr,
     });
     const runtimeCommand = resolveRuntimeCommand(getConfiguredRuntimeCmd(config), config.buildOptions.target, false);
     return {
         reporter,
+        reporterKind: selection.kind,
         runtimeName: runtimeNameFromCommand(runtimeCommand),
         resolvedConfigPath,
     };
 }
-async function loadReporter(reporterPath, configPath, context) {
+async function loadReporter(selection, configPath, context) {
+    if (selection.kind == "default") {
+        return createDefaultReporter(context);
+    }
+    if (selection.kind == "tap") {
+        return createTapReporter(context, selection.tap);
+    }
+    const reporterPath = selection.reporterPath;
     if (!reporterPath) {
         return createDefaultReporter(context);
     }
@@ -903,6 +1147,86 @@ async function loadReporter(reporterPath, configPath, context) {
         throw reporterError;
     }
 }
+function resolveReporterSelection(cliValue, configValue) {
+    const parsed = parseReporterConfig(configValue);
+    const raw = resolveCliReporter(process.argv.slice(2), cliValue ?? parsed.name);
+    const normalized = raw.trim();
+    const canonical = normalized.toLowerCase();
+    if (!normalized.length || canonical == "default") {
+        return { kind: "default", reporterPath: "", tap: parsed.tap };
+    }
+    if (canonical == "tap" || canonical == "tap13") {
+        return { kind: "tap", reporterPath: "", tap: parsed.tap };
+    }
+    return { kind: "custom", reporterPath: normalized, tap: parsed.tap };
+}
+function resolveCliReporter(argv, fallback) {
+    let resolved = fallback;
+    for (let i = 0; i < argv.length; i++) {
+        const token = argv[i];
+        if (token == "--tap") {
+            resolved = "tap";
+            continue;
+        }
+        if (token == "--reporter") {
+            const value = argv[i + 1];
+            if (!value || value.startsWith("-")) {
+                throw new Error(`--reporter requires a value`);
+            }
+            resolved = value;
+            i++;
+            continue;
+        }
+        if (token.startsWith("--reporter=")) {
+            const value = token.slice("--reporter=".length);
+            if (!value.length) {
+                throw new Error(`--reporter requires a value`);
+            }
+            resolved = value;
+            continue;
+        }
+    }
+    return resolved;
+}
+function parseReporterConfig(value) {
+    const tap = {
+        mode: "single-file",
+        outDir: "./.as-test/reports",
+        outFile: "./.as-test/reports/report.tap",
+    };
+    if (typeof value == "string") {
+        return { name: value, tap };
+    }
+    if (!value || typeof value != "object") {
+        return { name: "", tap };
+    }
+    const config = value;
+    const name = typeof config.name == "string" ? config.name : "";
+    if (typeof config.outDir == "string" && config.outDir.trim().length) {
+        tap.outDir = config.outDir.trim();
+    }
+    if (typeof config.outFile == "string" && config.outFile.trim().length) {
+        tap.outFile = config.outFile.trim();
+    }
+    else if (tap.outDir && tap.outDir.length) {
+        tap.outFile = path.join(tap.outDir, "report.tap");
+    }
+    if (Array.isArray(config.options)) {
+        const options = config.options
+            .filter((option) => typeof option == "string")
+            .map((option) => option.toLowerCase());
+        if (options.includes("per-file")) {
+            tap.mode = "per-file";
+            if (!config.outFile && tap.outDir && tap.outDir.length) {
+                tap.outFile = path.join(tap.outDir, "report.tap");
+            }
+        }
+        else {
+            tap.mode = "single-file";
+        }
+    }
+    return { name, tap };
+}
 function resolveReporterFactory(mod) {
     const fromNamed = mod.createReporter;
     if (typeof fromNamed == "function") {

package/bin/types.js

@@ -8,8 +8,10 @@ export class Config {
         this.snapshotDir = "./.as-test/snapshots";
         this.config = "none";
         this.coverage = true;
+        this.env = {};
         this.buildOptions = new BuildOptions();
         this.runOptions = new RunOptions();
+        this.modes = {};
     }
 }
 export class CoverageOptions {
@@ -25,6 +27,7 @@ export class Suite {
 }
 export class BuildOptions {
     constructor() {
+        this.cmd = "";
         this.args = [];
         this.target = "wasi";
     }
@@ -40,3 +43,18 @@ export class Runtime {
         this.cmd = "node ./.as-test/runners/default.wasi.js <file>";
     }
 }
+export class ModeConfig {
+    constructor() {
+        this.buildOptions = {};
+        this.runOptions = {};
+        this.env = {};
+    }
+}
+export class ReporterConfig {
+    constructor() {
+        this.name = "";
+        this.options = [];
+        this.outDir = "";
+        this.outFile = "";
+    }
+}