dungbeetle 0.1.1

package/dist/lifecycle.js

@@ -0,0 +1,190 @@
+import { spawn } from "node:child_process";
+export async function runLifecycleCommands(lifecycle, cwd = process.cwd()) {
+    const runs = [];
+    for (const command of lifecycle.setup) {
+        runs.push(await runLifecycleCommand("setup", command, cwd));
+    }
+    for (const command of lifecycle.start) {
+        runs.push(await runLifecycleCommand("start", command, cwd));
+    }
+    if (lifecycle.wait.command) {
+        runs.push(await runLifecycleCommand("wait", lifecycle.wait.command, cwd));
+    }
+    for (const command of lifecycle.teardown) {
+        runs.push(await runLifecycleCommand("teardown", command, cwd));
+    }
+    return runs;
+}
+export async function startManagedLifecycle(lifecycle, cwd = process.cwd()) {
+    const runs = [];
+    const startedProcesses = [];
+    for (const command of lifecycle.setup) {
+        runs.push(await runLifecycleCommand("setup", command, cwd));
+    }
+    for (const command of lifecycle.start) {
+        const started = startLifecycleProcess(command, cwd);
+        const run = {
+            phase: "start",
+            command,
+            exitCode: null,
+            durationMs: 0,
+            pid: started.pid
+        };
+        startedProcesses.push({ process: started, run });
+        runs.push(run);
+    }
+    if (lifecycle.wait.command) {
+        runs.push(await waitForCommand(lifecycle.wait.command, cwd, lifecycle.wait.timeoutMs));
+    }
+    else if (lifecycle.wait.url) {
+        runs.push(await waitForUrl(lifecycle.wait.url, lifecycle.wait.timeoutMs));
+    }
+    return {
+        runs,
+        stop: async () => {
+            const stopRuns = [];
+            // Snapshot start-process exit state before we tear anything down. A start
+            // command that exited on its own (e.g. a server that crashed on boot) is
+            // recorded with its real exit code so the run can fail instead of being
+            // treated as a still-running background process.
+            for (const { process, run } of startedProcesses) {
+                const exit = process.exitStatus();
+                if (exit.exited) {
+                    run.exitCode = exit.exitCode ?? 1;
+                }
+            }
+            for (const command of lifecycle.teardown) {
+                stopRuns.push(await runLifecycleCommand("teardown", command, cwd));
+            }
+            for (const { process } of startedProcesses.reverse()) {
+                await process.stop();
+            }
+            return stopRuns;
+        }
+    };
+}
+function runLifecycleCommand(phase, command, cwd) {
+    return new Promise((resolve, reject) => {
+        const startedAt = performance.now();
+        const child = spawn(command, {
+            cwd,
+            shell: true,
+            stdio: "inherit"
+        });
+        child.on("error", reject);
+        child.on("close", (exitCode) => {
+            resolve({
+                phase,
+                command,
+                exitCode,
+                durationMs: Math.round(performance.now() - startedAt)
+            });
+        });
+    });
+}
+function startLifecycleProcess(command, cwd) {
+    const child = spawn(command, {
+        cwd,
+        detached: process.platform !== "win32",
+        shell: true,
+        stdio: "ignore"
+    });
+    child.unref();
+    let exited = false;
+    let exitCode = null;
+    child.once("exit", (code) => {
+        exited = true;
+        exitCode = code;
+    });
+    const closed = new Promise((resolve) => {
+        child.once("close", () => {
+            resolve();
+        });
+    });
+    return {
+        command,
+        pid: child.pid,
+        exitStatus: () => ({ exited, exitCode }),
+        stop: async () => {
+            if (child.killed) {
+                return;
+            }
+            if (process.platform === "win32") {
+                if (child.pid) {
+                    await new Promise((resolve) => {
+                        const taskkill = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+                            stdio: "ignore"
+                        });
+                        taskkill.once("close", () => {
+                            resolve();
+                        });
+                    });
+                }
+                else {
+                    child.kill();
+                }
+            }
+            else if (child.pid) {
+                try {
+                    process.kill(-child.pid, "SIGTERM");
+                }
+                catch {
+                    child.kill("SIGTERM");
+                }
+            }
+            await Promise.race([closed, delay(1_000)]);
+        }
+    };
+}
+async function waitForCommand(command, cwd, timeoutMs) {
+    const startedAt = performance.now();
+    let lastExitCode = null;
+    while (performance.now() - startedAt <= timeoutMs) {
+        const result = await runLifecycleCommand("wait", command, cwd);
+        if (result.exitCode === 0) {
+            return {
+                ...result,
+                durationMs: Math.round(performance.now() - startedAt)
+            };
+        }
+        lastExitCode = result.exitCode;
+        await delay(250);
+    }
+    return {
+        phase: "wait",
+        command,
+        exitCode: lastExitCode ?? 1,
+        durationMs: Math.round(performance.now() - startedAt)
+    };
+}
+async function waitForUrl(url, timeoutMs) {
+    const startedAt = performance.now();
+    while (performance.now() - startedAt <= timeoutMs) {
+        try {
+            const response = await fetch(url);
+            if (response.ok) {
+                return {
+                    phase: "wait",
+                    command: `GET ${url}`,
+                    exitCode: 0,
+                    durationMs: Math.round(performance.now() - startedAt)
+                };
+            }
+        }
+        catch {
+            // Keep polling until timeout.
+        }
+        await delay(250);
+    }
+    return {
+        phase: "wait",
+        command: `GET ${url}`,
+        exitCode: 1,
+        durationMs: Math.round(performance.now() - startedAt)
+    };
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

package/dist/normalization.d.ts

@@ -0,0 +1,4 @@
+import type { MaskRule } from "./config.js";
+export declare function applyMaskRules(value: string, rules: MaskRule[]): string;
+export declare function normalizeLineEndings(value: string): string;
+export declare function collapseWhitespace(value: string): string;

package/dist/normalization.js

@@ -0,0 +1,27 @@
+// `applyMaskRules` runs once per text node, attribute, and terminal segment, so
+// recompiling each rule's RegExp every call cost thousands of compilations per
+// snapshot. Compile once per rules array and cache it — keyed by the array
+// identity, which is the stable `config.normalization.masks` reference for a run.
+// Reusing a global RegExp across `String.replace` calls is safe (replace doesn't
+// carry `lastIndex` between calls).
+const compiledCache = new WeakMap();
+function compileMasks(rules) {
+    let compiled = compiledCache.get(rules);
+    if (!compiled) {
+        compiled = rules.map((rule) => ({
+            regex: new RegExp(rule.pattern, "g"),
+            replacement: rule.replacement
+        }));
+        compiledCache.set(rules, compiled);
+    }
+    return compiled;
+}
+export function applyMaskRules(value, rules) {
+    return compileMasks(rules).reduce((current, mask) => current.replace(mask.regex, mask.replacement), value);
+}
+export function normalizeLineEndings(value) {
+    return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+export function collapseWhitespace(value) {
+    return value.replace(/\s+/g, " ").trim();
+}

package/dist/perf/ab.d.ts

@@ -0,0 +1,6 @@
+import type { PerformanceSnapshot } from "./k6.js";
+import type { PerfParser } from "./parsers.js";
+export declare function normalizeAbOutput(output: string, options?: {
+    metrics?: string[];
+}): PerformanceSnapshot;
+export declare const ab: PerfParser;

package/dist/perf/ab.js

@@ -0,0 +1,89 @@
+// Apache Benchmark (ab) parser for the performance kind.
+//
+// ab writes a plain-text summary to stdout; this normalizes it into the same
+// `{kind: "performance", tool, metrics}` shape as k6 so comparison, tolerance,
+// and rendering stay uniform. A target either runs `command` ("ab -n 200 -c 10
+// <url>") or ingests a saved output via `summary`.
+import { readToolOutput } from "./toolOutput.js";
+function round3(value) {
+    return Math.round(value * 1000) / 1000;
+}
+export function normalizeAbOutput(output, options = {}) {
+    const line = (pattern) => {
+        const match = pattern.exec(output);
+        return match ? Number(match[1]) : undefined;
+    };
+    const complete = line(/^Complete requests:\s+([\d.]+)/m);
+    if (complete === undefined) {
+        throw new Error('Invalid ab output: expected a "Complete requests" line.');
+    }
+    const metrics = {
+        requests: {
+            complete,
+            failed: line(/^Failed requests:\s+([\d.]+)/m) ?? 0,
+            per_second: line(/^Requests per second:\s+([\d.]+)/m) ?? 0
+        },
+        duration_ms: {
+            mean: line(/^Time per request:\s+([\d.]+) \[ms\] \(mean\)/m) ?? 0,
+            mean_concurrent: line(/^Time per request:\s+([\d.]+) \[ms\] \(mean, across/m) ?? 0
+        }
+    };
+    const documentLength = line(/^Document Length:\s+([\d.]+)/m);
+    if (documentLength !== undefined) {
+        // Response size is signal: a changed document length means the page changed.
+        metrics.document = { length_bytes: documentLength };
+    }
+    // Connection Times table: min mean [+/-sd] median max per phase.
+    for (const row of output.matchAll(/^(Connect|Processing|Waiting|Total):\s+([\d.]+)\s+([\d.]+)\s+([\d.]+)\s+([\d.]+)\s+([\d.]+)$/gm)) {
+        metrics[`${row[1].toLowerCase()}_ms`] = {
+            min: Number(row[2]),
+            mean: Number(row[3]),
+            sd: Number(row[4]),
+            median: Number(row[5]),
+            max: Number(row[6])
+        };
+    }
+    // Percentile table: "  95%      2".
+    const percentiles = {};
+    for (const row of output.matchAll(/^\s*(\d+)%\s+(\d+)/gm)) {
+        percentiles[`p${row[1]}`] = Number(row[2]);
+    }
+    if (Object.keys(percentiles).length > 0) {
+        metrics.percentiles_ms = percentiles;
+    }
+    const allow = options.metrics ? new Set(options.metrics) : undefined;
+    const filtered = {};
+    for (const [name, stats] of Object.entries(metrics)) {
+        if (allow && !allow.has(name)) {
+            continue;
+        }
+        filtered[name] = Object.fromEntries(Object.entries(stats).map(([stat, value]) => [stat, round3(value)]));
+    }
+    return { kind: "performance", tool: "ab", metrics: filtered };
+}
+export const ab = {
+    tool: "ab",
+    async capture(target, options) {
+        return normalizeAbOutput(await readToolOutput(target, options), { metrics: target.metrics });
+    },
+    validate(target) {
+        return target.command || target.summary ? [] : [`must set "command" or "summary".`];
+    },
+    doctorChecks(target) {
+        return [
+            target.command || target.summary
+                ? {
+                    name: "performance-target",
+                    severity: "pass",
+                    target: target.name,
+                    message: `Performance target "${target.name}" has an ${target.command ? "ab command" : "output file"}.`
+                }
+                : {
+                    name: "performance-target",
+                    severity: "fail",
+                    target: target.name,
+                    message: `Performance target "${target.name}" must set "command" or "summary".`
+                }
+        ];
+    }
+};

package/dist/perf/autocannon.d.ts

@@ -0,0 +1,6 @@
+import type { PerformanceSnapshot } from "./k6.js";
+import type { PerfParser } from "./parsers.js";
+export declare function normalizeAutocannonSummary(summary: unknown, options?: {
+    metrics?: string[];
+}): PerformanceSnapshot;
+export declare const autocannon: PerfParser;

package/dist/perf/autocannon.js

@@ -0,0 +1,101 @@
+// autocannon parser for the performance kind.
+//
+// `autocannon --json <url>` writes a structured summary to stdout: latency /
+// requests / throughput stat groups (mean, stddev, min, max, percentiles) plus
+// top-level error and status-class counters. This normalizes it into the same
+// `{kind: "performance", tool, metrics}` shape as k6 and ab.
+import { isRecord } from "../guards.js";
+import { parseJsonFile } from "../json.js";
+import { readToolOutput } from "./toolOutput.js";
+function round3(value) {
+    return Math.round(value * 1000) / 1000;
+}
+export function normalizeAutocannonSummary(summary, options = {}) {
+    if (!isRecord(summary) || !isRecord(summary.latency) || !isRecord(summary.requests)) {
+        throw new Error("Invalid autocannon output: expected `latency` and `requests` objects.");
+    }
+    const metrics = {};
+    // Stat groups, verbatim (keys like p97_5 are already path-friendly).
+    for (const group of ["latency", "requests", "throughput"]) {
+        const raw = summary[group];
+        if (!isRecord(raw)) {
+            continue;
+        }
+        const stats = {};
+        for (const [key, value] of Object.entries(raw)) {
+            if (typeof value === "number" && Number.isFinite(value)) {
+                stats[key] = round3(value);
+            }
+        }
+        if (Object.keys(stats).length > 0) {
+            metrics[group] = stats;
+        }
+    }
+    // Error/status counters: a regression here is signal even when timing holds.
+    const counts = {};
+    for (const key of [
+        "errors",
+        "timeouts",
+        "mismatches",
+        "non2xx",
+        "resets",
+        "1xx",
+        "2xx",
+        "3xx",
+        "4xx",
+        "5xx"
+    ]) {
+        const value = summary[key];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            counts[key] = value;
+        }
+    }
+    if (Object.keys(counts).length > 0) {
+        metrics.counts = counts;
+    }
+    // Benchmark shape: changing duration/connections means a different test.
+    const run = {};
+    for (const key of ["duration", "connections", "pipelining"]) {
+        const value = summary[key];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            run[key] = value;
+        }
+    }
+    if (Object.keys(run).length > 0) {
+        metrics.run = run;
+    }
+    const allow = options.metrics ? new Set(options.metrics) : undefined;
+    const filtered = allow
+        ? Object.fromEntries(Object.entries(metrics).filter(([name]) => allow.has(name)))
+        : metrics;
+    return { kind: "performance", tool: "autocannon", metrics: filtered };
+}
+export const autocannon = {
+    tool: "autocannon",
+    async capture(target, options) {
+        const output = await readToolOutput(target, options);
+        return normalizeAutocannonSummary(parseJsonFile(output, target.summary ?? target.command ?? "autocannon"), {
+            metrics: target.metrics
+        });
+    },
+    validate(target) {
+        return target.command || target.summary ? [] : [`must set "command" or "summary".`];
+    },
+    doctorChecks(target) {
+        return [
+            target.command || target.summary
+                ? {
+                    name: "performance-target",
+                    severity: "pass",
+                    target: target.name,
+                    message: `Performance target "${target.name}" has an ${target.command ? "autocannon command" : "output file"}.`
+                }
+                : {
+                    name: "performance-target",
+                    severity: "fail",
+                    target: target.name,
+                    message: `Performance target "${target.name}" must set "command" or "summary".`
+                }
+        ];
+    }
+};

package/dist/perf/capture.d.ts

@@ -0,0 +1,7 @@
+import type { CaptureTarget } from "../config.js";
+import type { PerformanceSnapshot } from "./k6.js";
+import { type PerfCaptureOptions } from "./parsers.js";
+export type PerformanceTarget = Extract<CaptureTarget, {
+    kind: "performance";
+}>;
+export declare function capturePerformance(target: PerformanceTarget, options: PerfCaptureOptions): Promise<PerformanceSnapshot>;

package/dist/perf/capture.js

@@ -0,0 +1,6 @@
+import { perfParserFor } from "./parsers.js";
+// Capture a performance snapshot via the target's tool parser (`tool`,
+// default "k6") — see src/perf/parsers.ts for the registry.
+export async function capturePerformance(target, options) {
+    return perfParserFor(target).capture(target, options);
+}

package/dist/perf/k6.d.ts

@@ -0,0 +1,9 @@
+export type PerformanceSnapshot = {
+    kind: "performance";
+    tool: string;
+    metrics: Record<string, Record<string, number>>;
+};
+export type NormalizeOptions = {
+    metrics?: string[];
+};
+export declare function normalizeK6Summary(summary: unknown, options?: NormalizeOptions): PerformanceSnapshot;

package/dist/perf/k6.js

@@ -0,0 +1,44 @@
+// Performance snapshot model for k6.
+//
+// k6's `--summary-export` writes an end-of-test JSON summary whose `metrics`
+// map holds one flat object of statistics per metric (avg, min, med, max,
+// percentiles, count, rate, …). We normalize that into a stable, diffable
+// shape. Because performance numbers vary run to run, comparison relies on the
+// existing numeric-tolerance engine — perf targets should set a relative
+// `numericTolerance` rather than expecting exact equality.
+import { isRecord } from "../guards.js";
+// Map k6's raw stat keys to stable, JSON-path-friendly names.
+function normalizeStatKey(key) {
+    const percentile = /^p\((\d+(?:\.\d+)?)\)$/.exec(key);
+    return percentile ? `p${percentile[1]}` : key;
+}
+export function normalizeK6Summary(summary, options = {}) {
+    if (!isRecord(summary) || !isRecord(summary.metrics)) {
+        throw new Error("Invalid k6 summary: expected a `metrics` object.");
+    }
+    const allow = options.metrics ? new Set(options.metrics) : undefined;
+    const metrics = {};
+    for (const [name, raw] of Object.entries(summary.metrics)) {
+        if (allow && !allow.has(name)) {
+            continue;
+        }
+        if (!isRecord(raw)) {
+            continue;
+        }
+        const stats = {};
+        for (const [statKey, statValue] of Object.entries(raw)) {
+            if (typeof statValue === "number" && Number.isFinite(statValue)) {
+                // Round to 3 decimals to keep baselines readable; the tolerance engine
+                // absorbs the meaningful run-to-run variance.
+                stats[normalizeStatKey(statKey)] = round3(statValue);
+            }
+        }
+        if (Object.keys(stats).length > 0) {
+            metrics[name] = stats;
+        }
+    }
+    return { kind: "performance", tool: "k6", metrics };
+}
+function round3(value) {
+    return Math.round(value * 1000) / 1000;
+}

package/dist/perf/parsers.d.ts

@@ -0,0 +1,15 @@
+import type { DoctorCheck } from "../doctor.js";
+import { type PerformanceSnapshot } from "./k6.js";
+import type { PerformanceTarget } from "./capture.js";
+export type PerfCaptureOptions = {
+    cwd: string;
+    timeoutMs: number;
+};
+export interface PerfParser {
+    tool: string;
+    capture(target: PerformanceTarget, options: PerfCaptureOptions): Promise<PerformanceSnapshot>;
+    validate(target: PerformanceTarget): string[];
+    doctorChecks(target: PerformanceTarget): DoctorCheck[];
+}
+export declare const perfParsers: Record<string, PerfParser>;
+export declare function perfParserFor(target: PerformanceTarget): PerfParser;

package/dist/perf/parsers.js

@@ -0,0 +1,69 @@
+// Tool-parser registry for the performance kind.
+//
+// One capture kind can host several tool parsers: each parser owns how to
+// obtain one tool's raw output and normalize it into the shared
+// `{kind: "performance", tool, metrics}` shape, so comparison, tolerance, and
+// rendering stay uniform across tools. A target selects its parser via
+// `tool` (default "k6"). Adding a tool is one parser object plus one registry
+// line here — the capture/validate/doctor dispatchers in
+// `src/captures/performance.ts` route through this registry.
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { parseJsonFile } from "../json.js";
+import { ab } from "./ab.js";
+import { autocannon } from "./autocannon.js";
+import { normalizeK6Summary } from "./k6.js";
+import { runK6 } from "./run.js";
+const k6 = {
+    tool: "k6",
+    async capture(target, options) {
+        let summary;
+        if (target.summary) {
+            const summaryPath = path.resolve(options.cwd, target.summary);
+            summary = parseJsonFile(await readFile(summaryPath, "utf8"), summaryPath);
+        }
+        else if (target.script) {
+            summary = await runK6({
+                script: path.resolve(options.cwd, target.script),
+                k6Path: target.k6Path,
+                cwd: options.cwd,
+                env: target.env,
+                timeoutMs: target.timeoutMs ?? options.timeoutMs
+            });
+        }
+        else {
+            throw new Error(`Performance target "${target.name}" must provide a "script" or "summary".`);
+        }
+        return normalizeK6Summary(summary, { metrics: target.metrics });
+    },
+    validate(target) {
+        return target.script || target.summary ? [] : [`must set "script" or "summary".`];
+    },
+    doctorChecks(target) {
+        return [
+            target.script || target.summary
+                ? {
+                    name: "performance-target",
+                    severity: "pass",
+                    target: target.name,
+                    message: `Performance target "${target.name}" has a ${target.script ? "k6 script" : "summary file"}.`
+                }
+                : {
+                    name: "performance-target",
+                    severity: "fail",
+                    target: target.name,
+                    message: `Performance target "${target.name}" must set "script" or "summary".`
+                }
+        ];
+    }
+};
+export const perfParsers = { k6, ab, autocannon };
+export function perfParserFor(target) {
+    const tool = target.tool ?? "k6";
+    const parser = perfParsers[tool];
+    if (!parser) {
+        throw new Error(`Performance target "${target.name}" uses unknown tool "${tool}". ` +
+            `Available: ${Object.keys(perfParsers).join(", ")}.`);
+    }
+    return parser;
+}

package/dist/perf/run.d.ts

@@ -0,0 +1,8 @@
+export type RunK6Options = {
+    script: string;
+    k6Path?: string;
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+};
+export declare function runK6(options: RunK6Options): Promise<unknown>;

package/dist/perf/run.js

@@ -0,0 +1,45 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { isErrno } from "../guards.js";
+import { parseJsonFile } from "../json.js";
+const execFileAsync = promisify(execFile);
+// Run a k6 script and return its parsed summary-export JSON. k6 must be
+// installed and on PATH (like the optional Playwright browser); it is not a
+// bundled dependency.
+export async function runK6(options) {
+    const bin = options.k6Path ?? "k6";
+    const dir = await mkdtemp(path.join(tmpdir(), "dungbeetle-k6-"));
+    const summaryPath = path.join(dir, "summary.json");
+    try {
+        try {
+            await execFileAsync(bin, ["run", "--summary-export", summaryPath, options.script], {
+                cwd: options.cwd,
+                env: { ...process.env, ...options.env },
+                timeout: options.timeoutMs ?? 0,
+                maxBuffer: 16 * 1024 * 1024
+            });
+        }
+        catch (error) {
+            if (isErrno(error, "ENOENT")) {
+                throw new Error(`Could not run k6 ("${bin}"); is it installed and on PATH?`);
+            }
+            // k6 exits non-zero when a threshold is breached but still writes the
+            // summary. We snapshot metrics rather than enforce k6 thresholds, so only
+            // a missing summary (handled below) is fatal.
+        }
+        let raw;
+        try {
+            raw = await readFile(summaryPath, "utf8");
+        }
+        catch {
+            throw new Error(`k6 did not produce a summary for ${options.script}.`);
+        }
+        return parseJsonFile(raw, summaryPath);
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+}

package/dist/perf/toolOutput.d.ts

@@ -0,0 +1,3 @@
+import type { PerformanceTarget } from "./capture.js";
+import type { PerfCaptureOptions } from "./parsers.js";
+export declare function readToolOutput(target: PerformanceTarget, options: PerfCaptureOptions): Promise<string>;

package/dist/perf/toolOutput.js

@@ -0,0 +1,24 @@
+// Shared run-or-ingest for command-driven performance tools (ab, autocannon):
+// read a saved output file via `summary`, or run `command` and return stdout.
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { runShellCommand } from "../terminal/capture.js";
+export async function readToolOutput(target, options) {
+    if (target.summary) {
+        return readFile(path.resolve(options.cwd, target.summary), "utf8");
+    }
+    if (!target.command) {
+        throw new Error(`Performance target "${target.name}" must provide a "command" or "summary".`);
+    }
+    const result = await runShellCommand({
+        command: target.command,
+        cwd: options.cwd,
+        timeoutMs: target.timeoutMs ?? options.timeoutMs
+    });
+    if (result.exitCode !== 0) {
+        const detail = result.stderr.trim();
+        throw new Error(`Performance target "${target.name}": \`${target.command}\` exited with ` +
+            `${result.exitCode ?? `signal ${String(result.signal)}`}${detail ? `:\n${detail}` : "."}`);
+    }
+    return result.stdout;
+}