as-test 0.4.4 → 0.5.1

package/bin/run.js

@@ -1,236 +1,924 @@
 import chalk from "chalk";
-import { exec } from "child_process";
+import { spawn } from "child_process";
 import { glob } from "glob";
-import { formatTime, getExec, loadConfig } from "./util.js";
+import { getExec, loadConfig } from "./util.js";
 import * as path from "path";
-import { existsSync, mkdirSync, writeFileSync } from "fs";
-import { diff } from "typer-diff";
-import gradient from "gradient-string";
-const CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
-const version = "0.4.0";
-export async function run() {
+import { pathToFileURL } from "url";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { createReporter as createDefaultReporter } from "./reporters/default.js";
+const DEFAULT_CONFIG_PATH = path.join(process.cwd(), "./as-test.config.json");
+var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["OPEN"] = 0] = "OPEN";
+    MessageType[MessageType["CLOSE"] = 1] = "CLOSE";
+    MessageType[MessageType["CALL"] = 2] = "CALL";
+    MessageType[MessageType["DATA"] = 3] = "DATA";
+})(MessageType || (MessageType = {}));
+class Channel {
+    constructor(input, output) {
+        this.input = input;
+        this.output = output;
+        this.buffer = Buffer.alloc(0);
+        this.input.on("data", (chunk) => this.onData(chunk));
+    }
+    send(type, payload) {
+        const body = payload ?? Buffer.alloc(0);
+        const header = Buffer.alloc(Channel.HEADER_SIZE);
+        Channel.MAGIC.copy(header, 0);
+        header.writeUInt8(type, 4);
+        header.writeUInt32LE(body.length, 5);
+        this.output.write(Buffer.concat([header, body]));
+    }
+    sendJSON(type, msg) {
+        this.send(type, Buffer.from(JSON.stringify(msg), "utf8"));
+    }
+    onData(chunk) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        while (true) {
+            if (this.buffer.length === 0)
+                return;
+            const idx = this.buffer.indexOf(Channel.MAGIC);
+            if (idx === -1) {
+                this.onPassthrough(this.buffer);
+                this.buffer = Buffer.alloc(0);
+                return;
+            }
+            if (idx > 0) {
+                this.onPassthrough(this.buffer.subarray(0, idx));
+                this.buffer = this.buffer.subarray(idx);
+            }
+            if (this.buffer.length < Channel.HEADER_SIZE)
+                return;
+            const type = this.buffer.readUInt8(4);
+            const length = this.buffer.readUInt32LE(5);
+            const frameSize = Channel.HEADER_SIZE + length;
+            if (this.buffer.length < frameSize)
+                return;
+            const payload = this.buffer.subarray(Channel.HEADER_SIZE, frameSize);
+            this.buffer = this.buffer.subarray(frameSize);
+            this.handleFrame(type, payload);
+        }
+    }
+    handleFrame(type, payload) {
+        switch (type) {
+            case MessageType.OPEN:
+                this.onOpen();
+                break;
+            case MessageType.CLOSE:
+                this.onClose();
+                break;
+            case MessageType.CALL:
+                this.onCall(JSON.parse(payload.toString("utf8")));
+                break;
+            case MessageType.DATA:
+                this.onDataMessage(payload);
+                break;
+            default:
+                this.onPassthrough(payload);
+        }
+    }
+    onPassthrough(_data) { }
+    onOpen() { }
+    onClose() { }
+    onCall(_msg) { }
+    onDataMessage(_data) { }
+}
+Channel.MAGIC = Buffer.from("WIPC");
+Channel.HEADER_SIZE = 9;
+class SnapshotStore {
+    constructor(specFile, snapshotDir) {
+        this.dirty = false;
+        this.created = 0;
+        this.updated = 0;
+        this.matched = 0;
+        this.failed = 0;
+        this.warnedMissing = new Set();
+        const base = path.basename(specFile, ".ts");
+        const dir = path.join(process.cwd(), snapshotDir);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        this.filePath = path.join(dir, `${base}.snap.json`);
+        this.data = existsSync(this.filePath)
+            ? JSON.parse(readFileSync(this.filePath, "utf8"))
+            : {};
+    }
+    assert(key, actual, allowSnapshot, updateSnapshots) {
+        if (!allowSnapshot)
+            return { ok: true, expected: actual, warnMissing: false };
+        if (!(key in this.data)) {
+            if (!updateSnapshots) {
+                this.failed++;
+                const warnMissing = !this.warnedMissing.has(key);
+                if (warnMissing)
+                    this.warnedMissing.add(key);
+                return {
+                    ok: false,
+                    expected: JSON.stringify("<missing snapshot>"),
+                    warnMissing,
+                };
+            }
+            this.created++;
+            this.dirty = true;
+            this.data[key] = actual;
+            return { ok: true, expected: actual, warnMissing: false };
+        }
+        const expected = this.data[key];
+        if (expected === actual) {
+            this.matched++;
+            return { ok: true, expected, warnMissing: false };
+        }
+        if (!updateSnapshots) {
+            this.failed++;
+            return { ok: false, expected, warnMissing: false };
+        }
+        this.updated++;
+        this.dirty = true;
+        this.data[key] = actual;
+        return { ok: true, expected: actual, warnMissing: false };
+    }
+    flush() {
+        if (!this.dirty)
+            return;
+        writeFileSync(this.filePath, JSON.stringify(this.data, null, 2));
+    }
+}
+export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selectors = [], shouldExit = true, options = {}) {
+    const resolvedConfigPath = configPath ?? DEFAULT_CONFIG_PATH;
     const reports = [];
-    const config = loadConfig(CONFIG_PATH);
-    const inputFiles = await glob(config.input);
-    console.log(chalk.dim("Running tests using " + config.runOptions.runtime.name + ""));
-    const command = config.runOptions.runtime.run.split(" ")[0];
-    let execPath = getExec(command);
+    const config = loadConfig(resolvedConfigPath);
+    const inputPatterns = resolveInputPatterns(config.input, selectors);
+    const inputFiles = await glob(inputPatterns);
+    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);
+    const coverageEnabled = coverage.enabled;
+    const coverageDir = config.coverageDir ?? "./.as-test/coverage";
+    const runtimeCommand = resolveRuntimeCommand(getConfiguredRuntimeCmd(config), config.buildOptions.target);
+    const reporter = options.reporter ??
+        (await loadReporter(config.runOptions.reporter, resolvedConfigPath, {
+            stdout: process.stdout,
+            stderr: process.stderr,
+        }));
+    const command = runtimeCommand.split(" ")[0];
+    const execPath = getExec(command);
     if (!execPath) {
-        console.log(`${chalk.bgRed(" ERROR ")}${chalk.dim(":")} could not locate ${command} in PATH variable!`);
-        process.exit(0);
-    }
-    if (inputFiles.length) {
-        console.log("\n" +
-            gradient(["#87afff", "#3a5fcd"])
-                .multiline(` █████  ███████       ████████ ███████ ███████ ████████ 
-██   ██ ██               ██    ██      ██         ██    
-███████ ███████ █████    ██    █████   ███████    ██    
-██   ██      ██          ██    ██           ██    ██    
-██   ██ ███████          ██    ███████ ███████    ██    `));
-        console.log(chalk.dim(`\n----------------------- v${version} -----------------------\n`));
-    }
-    for (const plugin of Object.keys(config.plugins)) {
-        if (!config.plugins[plugin])
-            continue;
-        console.log(chalk.bgBlueBright(" PLUGIN ") +
-            " " +
-            chalk.dim("Using " + plugin.slice(0, 1).toUpperCase() + plugin.slice(1)) +
-            "\n");
+        const message = `${chalk.bgRed(" ERROR ")}${chalk.dim(":")} could not locate ${command} in PATH variable!`;
+        if (shouldExit) {
+            console.log(message);
+            process.exit(1);
+        }
+        throw new Error(message);
+    }
+    if (options.emitRunStart !== false) {
+        reporter.onRunStart?.({
+            runtimeName: runtimeNameFromCommand(runtimeCommand),
+            clean: cleanOutput,
+            verbose: Boolean(flags.verbose),
+            snapshotEnabled,
+            updateSnapshots,
+        });
     }
+    if (showCoverage && !coverageEnabled) {
+        process.stderr.write(chalk.dim("coverage point output requested with --show-coverage, but coverage is disabled\n"));
+    }
+    const snapshotSummary = {
+        matched: 0,
+        created: 0,
+        updated: 0,
+        failed: 0,
+    };
     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"));
-        let cmd = config.runOptions.runtime.run.replace(command, execPath);
-        if (config.buildOptions.target == "bindings") {
-            cmd = config.runOptions.runtime.run.replace(command, execPath);
-            if (cmd.includes("<name>")) {
-                cmd = cmd.replace("<name>", file
-                    .slice(file.lastIndexOf("/") + 1)
-                    .replace(".ts", "")
-                    .replace(".spec", ""));
-            }
-            else {
-                cmd = cmd.replace("<file>", outFile
-                    .replace("build", "tests")
-                    .replace(".spec", "")
-                    .replace(".wasm", ".run.js"));
-            }
+        const fileBase = file
+            .slice(file.lastIndexOf("/") + 1)
+            .replace(".ts", "")
+            .replace(".spec", "");
+        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"));
         }
         else {
             cmd = cmd.replace("<file>", outFile);
         }
-        const report = JSON.parse(await (() => {
-            return new Promise((res, _) => {
-                let stdout = "";
-                const io = exec(cmd);
-                io.stdout.pipe(process.stdout);
-                io.stderr.pipe(process.stderr);
-                io.stdout.on("data", (data) => {
-                    stdout += readData(data);
-                });
-                io.stdout.on("close", () => {
-                    res(stdout);
-                });
-            });
-        })());
-        reports.push(report);
+        const snapshotStore = new SnapshotStore(file, config.snapshotDir);
+        const report = await runProcess(cmd, snapshotStore, snapshotEnabled, updateSnapshots, reporter);
+        const normalized = normalizeReport(report);
+        snapshotStore.flush();
+        snapshotSummary.matched += snapshotStore.matched;
+        snapshotSummary.created += snapshotStore.created;
+        snapshotSummary.updated += snapshotStore.updated;
+        snapshotSummary.failed += snapshotStore.failed;
+        reports.push({
+            file,
+            suites: normalized.suites,
+            coverage: normalized.coverage,
+        });
     }
     if (config.logs && config.logs != "none") {
         if (!existsSync(path.join(process.cwd(), config.logs))) {
-            mkdirSync(path.join(process.cwd(), config.logs));
-        }
-        writeFileSync(path.join(process.cwd(), config.logs, "test.log.json"), JSON.stringify(reports, null, 2));
-    }
-    const reporter = new Reporter(reports);
-    if (reporter.failed.length) {
-        console.log(chalk.dim("----------------- [FAILED] -------------------\n"));
-        for (const failed of reporter.failed) {
-            console.log(`${chalk.bgRed(" FAIL ")} ${chalk.dim(failed.description)}\n`);
-            for (const test of failed.tests) {
-                const diffResult = diff(JSON.stringify(test.left), JSON.stringify(test.right));
-                let expected = "";
-                let received = chalk.dim(JSON.stringify(test.left));
-                for (const res of diffResult.diff) {
-                    switch (res.type) {
-                        case "correct": {
-                            expected += chalk.dim(res.value);
-                            continue;
-                        }
-                        case "extra": {
-                            expected += chalk.red.strikethrough(res.value);
-                            continue;
-                        }
-                        case "missing": {
-                            expected += chalk.bgBlack(res.value);
-                            continue;
-                        }
-                        case "wrong": {
-                            expected += chalk.bgRed(res.value);
-                            continue;
-                        }
-                        case "untouched": {
-                            //received += chalk.bgBlackBright(res.value);
-                            continue;
-                        }
-                        case "spacer": {
-                            //received += chalk.bgBlackBright(res.value);
-                            continue;
-                        }
-                    }
-                }
-                if (test.verdict == "fail") {
-                    console.log(`${chalk.dim("(expected) ->")} ${expected}`);
-                    console.log(`${chalk.dim("(received) ->")} ${received}\n`);
-                }
+            mkdirSync(path.join(process.cwd(), config.logs), { recursive: true });
+        }
+        const logReports = reports.map((report) => ({
+            file: report.file,
+            suites: report.suites,
+        }));
+        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));
+    const coverageSummary = collectCoverageSummary(reports, coverageEnabled, showCoverage, coverage);
+    if (coverageEnabled &&
+        coverageDir &&
+        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));
+    }
+    if (options.emitRunComplete !== false) {
+        reporter.onRunComplete?.({
+            clean: cleanOutput,
+            snapshotEnabled,
+            showCoverage,
+            snapshotSummary,
+            coverageSummary,
+            stats,
+            reports,
+        });
+    }
+    const failed = Boolean(stats.failedFiles || snapshotSummary.failed);
+    if (shouldExit) {
+        process.exit(failed ? 1 : 0);
+    }
+    return {
+        failed,
+        stats,
+        snapshotSummary,
+        coverageSummary,
+        reports,
+    };
+}
+function resolveRuntimeCommand(runtimeRun, target, emitWarnings = true) {
+    const normalized = resolveLegacyWasiRuntime(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))
+            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;
+        const resolvedPreferredPath = path.join(process.cwd(), preferredPath);
+        if (existsSync(resolvedPreferredPath)) {
+            if (emitWarnings) {
+                process.stderr.write(chalk.dim(`legacy WASI 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.`);
     }
-    console.log(chalk.dim("----------------- [RESULTS] ------------------\n"));
-    process.stdout.write(chalk.bold("Files:  "));
-    if (reporter.failedFiles) {
-        process.stdout.write(chalk.bold.red(reporter.failedFiles + " failed"));
+    return runtimeRun;
+}
+function fallbackToDefaultRuntime(runtimeRun, target, emitWarnings) {
+    const scriptPath = extractRuntimeScriptPath(runtimeRun);
+    if (!scriptPath)
+        return runtimeRun;
+    const resolvedScriptPath = path.isAbsolute(scriptPath)
+        ? scriptPath
+        : path.join(process.cwd(), scriptPath);
+    if (existsSync(resolvedScriptPath))
+        return runtimeRun;
+    const fallback = getDefaultRuntimeFallback(target);
+    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.`);
     }
-    else {
-        process.stdout.write(chalk.bold.greenBright("0 failed"));
+    if (emitWarnings) {
+        process.stderr.write(chalk.dim(`runtime script not found (${scriptPath}); using ${fallback.scriptPath}\n`));
     }
-    process.stdout.write(", " + (reporter.failedFiles + reporter.passedFiles) + " total\n");
-    process.stdout.write(chalk.bold("Suites: "));
-    if (reporter.failedSuites) {
-        process.stdout.write(chalk.bold.red(reporter.failedSuites + " failed"));
+    return fallback.command;
+}
+function getDefaultRuntimeFallback(target) {
+    if (target == "wasi") {
+        return {
+            command: "node ./.as-test/runners/default.wasi.js <file>",
+            scriptPath: "./.as-test/runners/default.wasi.js",
+        };
     }
-    else {
-        process.stdout.write(chalk.bold.greenBright("0 failed"));
+    if (target == "bindings") {
+        return {
+            command: "node ./.as-test/runners/default.run.js <file>",
+            scriptPath: "./.as-test/runners/default.run.js",
+        };
     }
-    process.stdout.write(", " + (reporter.failedSuites + reporter.passedSuites) + " total\n");
-    process.stdout.write(chalk.bold("Tests:  "));
-    if (reporter.failedTests) {
-        process.stdout.write(chalk.bold.red(reporter.failedTests + " failed"));
+    return null;
+}
+function extractRuntimeScriptPath(runtimeRun) {
+    const tokens = runtimeRun.trim().split(/\s+/).filter((token) => token.length > 0);
+    if (tokens.length < 2)
+        return null;
+    const execToken = path.basename(tokens[0]).toLowerCase();
+    if (!isScriptHostRuntime(execToken))
+        return null;
+    for (let i = 1; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token == "--") {
+            const next = tokens[i + 1];
+            if (next && isLikelyRuntimeScriptPath(next))
+                return next;
+            return null;
+        }
+        if (token.startsWith("-"))
+            continue;
+        if (isLikelyRuntimeScriptPath(token))
+            return token;
+        return null;
     }
-    else {
-        process.stdout.write(chalk.bold.greenBright("0 failed"));
-    }
-    process.stdout.write(", " + (reporter.failedTests + reporter.passedTests) + " total\n");
-    process.stdout.write(chalk.bold("Time:   ") + formatTime(reporter.time) + "\n");
-    if (reporter.failedFiles)
-        process.exit(1);
-    process.exit(0);
-}
-class Reporter {
-    constructor(reports) {
-        this.passedFiles = 0;
-        this.failedFiles = 0;
-        this.passedSuites = 0;
-        this.failedSuites = 0;
-        this.passedTests = 0;
-        this.failedTests = 0;
-        this.failed = [];
-        this.time = 0.0;
-        this.readReports(reports);
-    }
-    readReports(reports) {
-        for (const file of reports) {
-            this.readFile(file);
-        }
-    }
-    readFile(file) {
-        let failed = false;
-        for (const suite of file) {
-            if (suite.verdict == "fail") {
-                failed = true;
-                this.failedSuites++;
+    return null;
+}
+function isScriptHostRuntime(execToken) {
+    return (execToken == "node" ||
+        execToken == "node.exe" ||
+        execToken == "node.cmd" ||
+        execToken == "bun" ||
+        execToken == "bun.exe" ||
+        execToken == "bun.cmd" ||
+        execToken == "deno" ||
+        execToken == "deno.exe" ||
+        execToken == "deno.cmd" ||
+        execToken == "tsx" ||
+        execToken == "tsx.cmd" ||
+        execToken == "ts-node" ||
+        execToken == "ts-node.cmd");
+}
+function isLikelyRuntimeScriptPath(token) {
+    if (!token.length)
+        return false;
+    if (token == "<file>" || token == "<name>")
+        return false;
+    if (token.includes("://"))
+        return false;
+    if (token.startsWith("-"))
+        return false;
+    if (token.startsWith("./"))
+        return true;
+    if (token.startsWith("../"))
+        return true;
+    if (token.startsWith("/"))
+        return true;
+    if (token.startsWith(".\\"))
+        return true;
+    if (token.startsWith("..\\"))
+        return true;
+    if (/^[A-Za-z]:[\\/]/.test(token))
+        return true;
+    return /\.(mjs|cjs|js|ts)$/.test(token);
+}
+function getConfiguredRuntimeCmd(config) {
+    const runtime = config.runOptions.runtime;
+    if (runtime.cmd && runtime.cmd.length)
+        return runtime.cmd;
+    if (runtime.run && runtime.run.length)
+        return runtime.run;
+    throw new Error(`runtime command is missing. Set "runOptions.runtime.cmd" in as-test.config.json`);
+}
+function runtimeNameFromCommand(command) {
+    const token = command.trim().split(/\s+/)[0];
+    return token && token.length ? token : "runtime";
+}
+function resolveInputPatterns(configured, selectors) {
+    const configuredInputs = Array.isArray(configured) ? configured : [configured];
+    if (!selectors.length)
+        return configuredInputs;
+    const patterns = new Set();
+    for (const selector of selectors) {
+        if (!selector)
+            continue;
+        if (isBareSuiteSelector(selector)) {
+            const base = stripSuiteSuffix(selector);
+            for (const configuredInput of configuredInputs) {
+                patterns.add(path.join(path.dirname(configuredInput), `${base}.spec.ts`));
             }
-            else {
-                this.passedSuites++;
+            continue;
+        }
+        patterns.add(selector);
+    }
+    return [...patterns];
+}
+function isBareSuiteSelector(selector) {
+    return (!selector.includes("/") &&
+        !selector.includes("\\") &&
+        !/[*?[\]{}]/.test(selector));
+}
+function stripSuiteSuffix(selector) {
+    return selector.replace(/\.spec\.ts$/, "").replace(/\.ts$/, "");
+}
+function normalizeReport(raw) {
+    if (Array.isArray(raw)) {
+        return {
+            suites: raw,
+            coverage: {
+                total: 0,
+                covered: 0,
+                uncovered: 0,
+                percent: 100,
+                points: [],
+            },
+        };
+    }
+    const value = raw;
+    if (!value) {
+        return {
+            suites: [],
+            coverage: {
+                total: 0,
+                covered: 0,
+                uncovered: 0,
+                percent: 100,
+                points: [],
+            },
+        };
+    }
+    const suites = Array.isArray(value.suites) ? value.suites : [];
+    const coverage = normalizeCoverage(value.coverage);
+    return { suites, coverage };
+}
+function normalizeCoverage(value) {
+    const raw = value;
+    const total = Number(raw?.total ?? 0);
+    const uncovered = Number(raw?.uncovered ?? 0);
+    const covered = raw?.covered != null ? Number(raw.covered) : Math.max(total - uncovered, 0);
+    const percent = raw?.percent != null
+        ? Number(raw.percent)
+        : total
+            ? (covered * 100) / total
+            : 100;
+    const pointsRaw = Array.isArray(raw?.points)
+        ? raw?.points
+        : [];
+    const points = pointsRaw
+        .map((point) => {
+        const p = point;
+        return {
+            hash: String(p.hash ?? ""),
+            file: String(p.file ?? ""),
+            line: Number(p.line ?? 0),
+            column: Number(p.column ?? 0),
+            type: String(p.type ?? ""),
+            executed: Boolean(p.executed),
+        };
+    })
+        .filter((point) => point.file.length > 0);
+    return {
+        total,
+        covered,
+        uncovered,
+        percent,
+        points,
+    };
+}
+function collectCoverageSummary(reports, enabled, showPoints, coverage) {
+    const summary = {
+        enabled,
+        showPoints,
+        total: 0,
+        covered: 0,
+        uncovered: 0,
+        percent: 100,
+        files: [],
+    };
+    const uniquePoints = new Map();
+    const hasDetailedPoints = reports.some((report) => report.coverage.points.length > 0);
+    for (const report of reports) {
+        for (const point of report.coverage.points) {
+            if (isIgnoredCoverageFile(point.file, coverage))
+                continue;
+            const key = `${point.file}::${point.hash}`;
+            const existing = uniquePoints.get(key);
+            if (!existing) {
+                uniquePoints.set(key, { ...point });
             }
-            this.time += suite.time.end - suite.time.start;
-            for (const subSuite of suite.suites) {
-                this.readSuite(subSuite);
+            else if (point.executed) {
+                existing.executed = true;
             }
-            for (const test of suite.tests) {
-                if (test.verdict == "fail")
-                    this.failed.push(suite);
-                this.readTest(test);
+        }
+    }
+    if (uniquePoints.size > 0) {
+        const byFile = new Map();
+        for (const point of uniquePoints.values()) {
+            if (!byFile.has(point.file))
+                byFile.set(point.file, []);
+            byFile.get(point.file).push(point);
+            summary.total++;
+            if (point.executed)
+                summary.covered++;
+            else
+                summary.uncovered++;
+        }
+        const sortedFiles = [...byFile.keys()].sort((a, b) => a.localeCompare(b));
+        for (const file of sortedFiles) {
+            const points = byFile.get(file);
+            points.sort(compareCoveragePoints);
+            let covered = 0;
+            for (const point of points) {
+                if (point.executed)
+                    covered++;
             }
+            const total = points.length;
+            if (!total)
+                continue;
+            const uncovered = total - covered;
+            summary.files.push({
+                file,
+                total,
+                covered,
+                uncovered,
+                percent: total ? (covered * 100) / total : 100,
+                points,
+            });
         }
-        if (failed)
-            this.failedFiles++;
-        else
-            this.passedFiles++;
     }
-    readSuite(suite) {
-        if (suite.verdict == "fail") {
-            this.failedSuites++;
+    else if (!hasDetailedPoints) {
+        // Compatibility fallback for reports without detailed point payloads.
+        for (const report of reports) {
+            if (isIgnoredCoverageFile(report.file, coverage))
+                continue;
+            if (report.coverage.total <= 0)
+                continue;
+            summary.total += report.coverage.total;
+            summary.covered += report.coverage.covered;
+            summary.uncovered += report.coverage.uncovered;
+            summary.files.push({
+                file: report.file,
+                total: report.coverage.total,
+                covered: report.coverage.covered,
+                uncovered: report.coverage.uncovered,
+                percent: report.coverage.percent,
+                points: report.coverage.points,
+            });
         }
-        else {
-            this.passedSuites++;
+    }
+    summary.percent = summary.total
+        ? (summary.covered * 100) / summary.total
+        : 100;
+    return summary;
+}
+function isIgnoredCoverageFile(file, coverage) {
+    const normalized = file.replace(/\\/g, "/");
+    if (!isAllowedCoverageSourceFile(normalized))
+        return true;
+    if (normalized.startsWith("node_modules/"))
+        return true;
+    if (normalized.includes("/node_modules/"))
+        return true;
+    if (isAssemblyScriptStdlibFile(normalized))
+        return true;
+    if (!coverage.includeSpecs && normalized.endsWith(".spec.ts"))
+        return true;
+    return false;
+}
+function isAllowedCoverageSourceFile(file) {
+    const lower = file.toLowerCase();
+    return lower.endsWith(".ts") || lower.endsWith(".as");
+}
+function isAssemblyScriptStdlibFile(file) {
+    if (file.startsWith("~lib/"))
+        return true;
+    if (file.includes("/~lib/"))
+        return true;
+    if (file.startsWith("assemblyscript/std/"))
+        return true;
+    if (file.includes("/assemblyscript/std/"))
+        return true;
+    return false;
+}
+function resolveCoverageOptions(raw) {
+    if (typeof raw == "boolean") {
+        return {
+            enabled: raw,
+            includeSpecs: false,
+        };
+    }
+    if (raw && typeof raw == "object") {
+        const obj = raw;
+        return {
+            enabled: obj.enabled == null ? true : Boolean(obj.enabled),
+            includeSpecs: Boolean(obj.includeSpecs),
+        };
+    }
+    return {
+        enabled: false,
+        includeSpecs: false,
+    };
+}
+function compareCoveragePoints(a, b) {
+    if (a.line !== b.line)
+        return a.line - b.line;
+    if (a.column !== b.column)
+        return a.column - b.column;
+    if (a.type !== b.type)
+        return a.type.localeCompare(b.type);
+    return a.hash.localeCompare(b.hash);
+}
+async function runProcess(cmd, snapshots, snapshotEnabled, updateSnapshots, reporter) {
+    const child = spawn(cmd, {
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: true,
+    });
+    let report = null;
+    let parseError = null;
+    let stderrBuffer = "";
+    let suppressTraceWarningLine = false;
+    child.stderr.on("data", (chunk) => {
+        stderrBuffer += chunk.toString("utf8");
+        let newline = stderrBuffer.indexOf("\n");
+        while (newline >= 0) {
+            const line = stderrBuffer.slice(0, newline + 1);
+            stderrBuffer = stderrBuffer.slice(newline + 1);
+            if (shouldSuppressWasiWarningLine(line, suppressTraceWarningLine)) {
+                suppressTraceWarningLine = true;
+            }
+            else {
+                suppressTraceWarningLine = false;
+                process.stderr.write(line);
+            }
+            newline = stderrBuffer.indexOf("\n");
+        }
+    });
+    class TestChannel extends Channel {
+        onPassthrough(data) {
+            process.stdout.write(data);
+        }
+        onCall(msg) {
+            const event = msg;
+            const kind = String(event.kind ?? "");
+            if (kind === "event:assert-fail") {
+                reporter.onAssertionFail?.({
+                    key: String(event.key ?? ""),
+                    instr: String(event.instr ?? ""),
+                    left: String(event.left ?? ""),
+                    right: String(event.right ?? ""),
+                    message: String(event.message ?? ""),
+                });
+                return;
+            }
+            if (kind === "event:file-start") {
+                reporter.onFileStart?.({
+                    file: String(event.file ?? "unknown"),
+                    depth: 0,
+                    suiteKind: "file",
+                    description: String(event.file ?? "unknown"),
+                });
+                return;
+            }
+            if (kind === "event:file-end") {
+                reporter.onFileEnd?.({
+                    file: String(event.file ?? "unknown"),
+                    depth: 0,
+                    suiteKind: "file",
+                    description: String(event.file ?? "unknown"),
+                    verdict: String(event.verdict ?? "none"),
+                    time: String(event.time ?? ""),
+                });
+                return;
+            }
+            if (kind === "event:suite-start") {
+                reporter.onSuiteStart?.({
+                    file: String(event.file ?? "unknown"),
+                    depth: Number(event.depth ?? 0),
+                    suiteKind: String(event.suiteKind ?? ""),
+                    description: String(event.description ?? ""),
+                });
+                return;
+            }
+            if (kind === "event:suite-end") {
+                reporter.onSuiteEnd?.({
+                    file: String(event.file ?? "unknown"),
+                    depth: Number(event.depth ?? 0),
+                    suiteKind: String(event.suiteKind ?? ""),
+                    description: String(event.description ?? ""),
+                    verdict: String(event.verdict ?? "none"),
+                });
+                return;
+            }
+            if (kind === "snapshot:assert") {
+                const key = String(event.key ?? "");
+                const actual = String(event.actual ?? "");
+                const result = snapshots.assert(key, actual, snapshotEnabled, updateSnapshots);
+                if (result.warnMissing) {
+                    reporter.onSnapshotMissing?.({ key });
+                }
+                this.send(MessageType.CALL, Buffer.from(`${result.ok ? "1" : "0"}\n${result.expected}`, "utf8"));
+                return;
+            }
+            this.sendJSON(MessageType.CALL, { ok: true, expected: "" });
         }
-        this.time += suite.time.end - suite.time.start;
-        for (const subSuite of suite.suites) {
-            this.readSuite(subSuite);
+        onDataMessage(data) {
+            try {
+                report = JSON.parse(data.toString("utf8"));
+            }
+            catch (error) {
+                parseError = String(error);
+            }
         }
-        for (const test of suite.tests) {
-            if (test.verdict == "fail")
-                this.failed.push(suite);
-            this.readTest(test);
+    }
+    const _channel = new TestChannel(child.stdout, child.stdin);
+    const code = await new Promise((resolve) => {
+        child.on("close", (exitCode) => resolve(exitCode ?? 1));
+    });
+    if (stderrBuffer.length) {
+        if (!shouldSuppressWasiWarningLine(stderrBuffer, suppressTraceWarningLine)) {
+            process.stderr.write(stderrBuffer);
         }
     }
-    readTest(test) {
-        if (test.verdict == "fail") {
-            this.failedTests++;
+    if (parseError) {
+        throw new Error(`could not parse report payload: ${parseError}`);
+    }
+    if (!report) {
+        throw new Error("missing report payload from test runtime");
+    }
+    if (code !== 0) {
+        // Let report determine failure counts, but keep non-zero child exits visible.
+        process.stderr.write(chalk.dim(`child process exited with code ${code}\n`));
+    }
+    return report;
+}
+function shouldSuppressWasiWarningLine(line, suppressTraceWarningLine) {
+    if (line.includes("ExperimentalWarning: WASI is an experimental feature")) {
+        return true;
+    }
+    if (suppressTraceWarningLine && line.includes("--trace-warnings")) {
+        return true;
+    }
+    return false;
+}
+function collectRunStats(reports) {
+    const stats = {
+        passedFiles: 0,
+        failedFiles: 0,
+        skippedFiles: 0,
+        passedSuites: 0,
+        failedSuites: 0,
+        skippedSuites: 0,
+        passedTests: 0,
+        failedTests: 0,
+        skippedTests: 0,
+        time: 0.0,
+        failedEntries: [],
+    };
+    for (const fileReport of reports) {
+        readFileReport(stats, fileReport);
+    }
+    return stats;
+}
+function readFileReport(stats, fileReport) {
+    const suites = Array.isArray(fileReport) ? fileReport : [];
+    let fileVerdict = "none";
+    for (const suite of suites) {
+        fileVerdict = mergeVerdict(fileVerdict, readSuite(stats, suite));
+    }
+    if (fileVerdict == "fail") {
+        stats.failedFiles++;
+    }
+    else if (fileVerdict == "ok") {
+        stats.passedFiles++;
+    }
+    else {
+        stats.skippedFiles++;
+    }
+}
+function readSuite(stats, suite) {
+    const suiteAny = suite;
+    let verdict = normalizeVerdict(suiteAny.verdict);
+    const time = suiteAny.time;
+    const start = Number(time?.start ?? 0);
+    const end = Number(time?.end ?? 0);
+    stats.time += end - start;
+    const subSuites = Array.isArray(suiteAny.suites)
+        ? suiteAny.suites
+        : [];
+    for (const subSuite of subSuites) {
+        verdict = mergeVerdict(verdict, readSuite(stats, subSuite));
+    }
+    const tests = Array.isArray(suiteAny.tests)
+        ? suiteAny.tests
+        : [];
+    for (const test of tests) {
+        const testVerdict = normalizeVerdict(test.verdict);
+        verdict = mergeVerdict(verdict, testVerdict);
+        if (testVerdict == "fail") {
+            stats.failedTests++;
+        }
+        else if (testVerdict == "ok") {
+            stats.passedTests++;
         }
         else {
-            this.passedTests++;
+            stats.skippedTests++;
         }
     }
+    if (verdict == "fail") {
+        stats.failedSuites++;
+        stats.failedEntries.push(suite);
+    }
+    else if (verdict == "ok") {
+        stats.passedSuites++;
+    }
+    else {
+        stats.skippedSuites++;
+    }
+    return verdict;
+}
+function normalizeVerdict(value) {
+    const verdict = String(value ?? "none");
+    if (verdict == "fail")
+        return "fail";
+    if (verdict == "ok")
+        return "ok";
+    if (verdict == "skip")
+        return "skip";
+    return "none";
+}
+function mergeVerdict(current, next) {
+    if (current == "fail" || next == "fail")
+        return "fail";
+    if (current == "ok" || next == "ok")
+        return "ok";
+    if (current == "skip" || next == "skip")
+        return "skip";
+    return "none";
+}
+export async function createRunReporter(configPath = DEFAULT_CONFIG_PATH) {
+    const resolvedConfigPath = configPath ?? DEFAULT_CONFIG_PATH;
+    const config = loadConfig(resolvedConfigPath);
+    const reporter = await loadReporter(config.runOptions.reporter, resolvedConfigPath, {
+        stdout: process.stdout,
+        stderr: process.stderr,
+    });
+    const runtimeCommand = resolveRuntimeCommand(getConfiguredRuntimeCmd(config), config.buildOptions.target, false);
+    return {
+        reporter,
+        runtimeName: runtimeNameFromCommand(runtimeCommand),
+        resolvedConfigPath,
+    };
+}
+async function loadReporter(reporterPath, configPath, context) {
+    if (!reporterPath) {
+        return createDefaultReporter(context);
+    }
+    const resolved = path.isAbsolute(reporterPath)
+        ? reporterPath
+        : path.resolve(path.dirname(configPath), reporterPath);
+    try {
+        const mod = (await import(pathToFileURL(resolved).href));
+        const factory = resolveReporterFactory(mod);
+        return factory(context);
+    }
+    catch (error) {
+        const reporterError = new Error(`could not load reporter "${reporterPath}": ${String(error)}`);
+        reporterError.cause = error;
+        throw reporterError;
+    }
 }
-function readData(data) {
-    let out = "";
-    const start = data.indexOf("READ_LINE");
-    if (start >= 0) {
-        const slice = data.slice(start + 9);
-        const end = slice.indexOf("END_LINE");
-        out += slice.slice(0, end);
-        out += readData(slice);
+function resolveReporterFactory(mod) {
+    const fromNamed = mod.createReporter;
+    if (typeof fromNamed == "function") {
+        return fromNamed;
+    }
+    const fromDefault = mod.default;
+    if (typeof fromDefault == "function") {
+        return fromDefault;
+    }
+    if (fromDefault &&
+        typeof fromDefault == "object" &&
+        "createReporter" in fromDefault) {
+        const nested = fromDefault.createReporter;
+        if (typeof nested == "function") {
+            return nested;
+        }
     }
-    return out;
+    throw new Error(`reporter module must export a factory as "createReporter" or default`);
 }