@systemfsoftware/stryker-js-mutation-run 1.2.5

package/dist/plugins.d.mts

@@ -0,0 +1,2 @@
+import { a as injection_tokens_d_exports, n as PluginLoader, r as PluginCreator, t as LoadedPlugins } from "./index-CyOSz6LC.mjs";
+export { LoadedPlugins, PluginCreator, PluginLoader, injection_tokens_d_exports as injectionTokens };

package/dist/plugins.mjs

@@ -0,0 +1,2 @@
+import { C as injection_tokens_exports, p as PluginCreator, t as PluginLoader } from "./plugins-Nx86IJQW.mjs";
+export { PluginCreator, PluginLoader, injection_tokens_exports as injectionTokens };

package/dist/rolldown-runtime-D7D4PA-g.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/run-event-CzRz9Gtk.d.mts

@@ -0,0 +1,121 @@
+import { n as OutputMode, t as ModeSignal } from "./output-mode-CfGHDpi5.mjs";
+import { i as VerdictEnvelope } from "./verdict-envelope-CKLZPjxC.mjs";
+import { MutantStatus, schema } from "@systemfsoftware/stryker-js-plugin-api/core";
+//#region src/run-event.d.ts
+/**
+ * What a run emits, as a closed vocabulary (R1, R2, R35).
+ *
+ * Declaration only. Core pushes these into a sink it receives through
+ * `injectionTokens.runEventSink`; how they reach a descriptor — NDJSON framing,
+ * ordering, the terminal-once guarantee, the drain — belongs to whoever
+ * binds the sink, not here. The `kind` tags are the wire contract and are
+ * fixed: a consumer parses on them, so they may be added to but never
+ * renamed.
+ */
+/**
+ * The lifecycle phases of a run (R18), in the order the executor chain emits
+ * them. `prepare` is the first observable moment of the run.
+ */
+type RunPhase = 'prepare' | 'instrument' | 'dry-run' | 'mutation-test';
+/**
+ * Opens the run (R5, R21): carries the stream schema version, the run id
+ * shared with the verdict envelope, and the resolved mode plus the signal
+ * that decided it.
+ */
+interface RunStarted {
+  readonly kind: 'stream';
+  readonly schemaVersion: string;
+  readonly runId: string;
+  readonly mode: OutputMode;
+  readonly signal: ModeSignal;
+}
+/**
+ * A lifecycle phase boundary (R18). `elapsedMs` is time since the run began.
+ */
+interface PhaseEntered {
+  readonly kind: 'phase';
+  readonly phase: RunPhase;
+  readonly elapsedMs: number;
+}
+/**
+ * The mutant-testing plan (R17): emitted once the plan is known, before any
+ * mutant is tested. Names the total a consumer can count `mutant` events
+ * against.
+ */
+interface PlanKnown {
+  readonly kind: 'plan';
+  readonly total: number;
+}
+/**
+ * One tested mutant that passed the R20 actionable filter. Carries the full
+ * survivor re-run matching key — file, location, mutator, replacement — so a
+ * consumer can address the mutant without opening the report file (R11).
+ */
+interface MutantTested {
+  readonly kind: 'mutant';
+  readonly id: string;
+  readonly status: MutantStatus;
+  readonly file: string;
+  readonly location: schema.Location;
+  readonly mutator: string;
+  readonly replacement: string | null;
+  readonly completed: number;
+  readonly total: number;
+}
+/**
+ * The heartbeat (R19), emitted on the tick interval while a phase is in
+ * flight, so a long phase never looks hung. `total` is `null` until the plan
+ * is known — a pre-plan `0` would read as a finished run of zero mutants.
+ */
+interface Heartbeat {
+  readonly kind: 'tick';
+  readonly elapsedMs: number;
+  readonly completed: number;
+  readonly total: number | null;
+}
+type VerdictReached = VerdictEnvelope & {
+  readonly kind: 'verdict';
+};
+/**
+ * The run did not reach a verdict (R7). `code` is the classed exit code (R6).
+ * Terminal.
+ */
+interface RunFailed {
+  readonly kind: 'error';
+  readonly schemaVersion: string;
+  readonly code: number;
+  readonly error: string;
+  readonly remediation: string;
+}
+/**
+ * A `--help` invocation closed with the rendered usage text, so an agent that
+ * reads the last stdout line still gets a tagged event. Terminal.
+ */
+interface HelpRendered {
+  readonly kind: 'help';
+  readonly schemaVersion: string;
+  readonly code: 0;
+  readonly help: string;
+}
+/**
+ * A `--llms` invocation closed with the rendered manifest (R9). Terminal.
+ */
+interface ManifestRendered {
+  readonly kind: 'manifest';
+  readonly schemaVersion: string;
+  readonly code: 0;
+  readonly manifest: string;
+}
+/**
+ * Exactly one of these ends a run (R5): a score, a failure, or a rendered
+ * document closing a non-run command.
+ */
+type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered | ManifestRendered;
+type RunEvent = RunStarted | PhaseEntered | PlanKnown | MutantTested | Heartbeat | RunTerminalEvent;
+/**
+ * Where a run's events go. Synchronous by contract: core pushes from promise
+ * code that cannot suspend, and the callback must never reject.
+ */
+type RunEventSink = (event: RunEvent) => void;
+//#endregion
+export { PhaseEntered as a, RunEventSink as c, RunStarted as d, RunTerminalEvent as f, MutantTested as i, RunFailed as l, HelpRendered as n, PlanKnown as o, VerdictReached as p, ManifestRendered as r, RunEvent as s, Heartbeat as t, RunPhase as u };

package/dist/run-event.d.mts

@@ -0,0 +1,2 @@
+import { a as PhaseEntered, c as RunEventSink, d as RunStarted, f as RunTerminalEvent, i as MutantTested, l as RunFailed, n as HelpRendered, o as PlanKnown, p as VerdictReached, r as ManifestRendered, s as RunEvent, t as Heartbeat, u as RunPhase } from "./run-event-CzRz9Gtk.mjs";
+export { Heartbeat, HelpRendered, ManifestRendered, MutantTested, PhaseEntered, PlanKnown, RunEvent, RunEventSink, RunFailed, RunPhase, RunStarted, RunTerminalEvent, VerdictReached };

package/dist/run-event.mjs

@@ -0,0 +1 @@
+export {};

package/dist/stryker-package-CTcsIZ4S.mjs

@@ -0,0 +1,23 @@
+import { deepFreeze } from "@stryker-mutator/util";
+import fs from "fs";
+import { URL, fileURLToPath } from "url";
+import * as S from "effect/Schema";
+//#region src/stryker-package.schema.ts
+/**
+* The shape of this package's own `package.json` that the public surface
+* exposes (`strykerVersion`, `strykerEngines`). The file is data read from
+* disk, so it is decoded through this schema rather than trusted after
+* `JSON.parse`; every other `package.json` key is ignored.
+*/
+const PackageJsonSchema = S.Struct({
+	version: S.String,
+	engines: S.Struct({ node: S.String })
+});
+//#endregion
+//#region src/stryker-package.ts
+const rawPackageJson = JSON.parse(fs.readFileSync(fileURLToPath(new URL("../package.json", import.meta.url)), "utf-8"));
+const pkg = deepFreeze(S.decodeUnknownSync(PackageJsonSchema)(rawPackageJson));
+const strykerVersion = pkg.version;
+const strykerEngines = pkg.engines;
+//#endregion
+export { strykerVersion as n, strykerEngines as t };

package/dist/stryker-package.d.mts

@@ -0,0 +1,7 @@
+//#region src/stryker-package.d.ts
+declare const strykerVersion: string;
+declare const strykerEngines: import("@stryker-mutator/util").ImmutableObject<{
+  readonly node: string;
+}>;
+//#endregion
+export { strykerEngines, strykerVersion };

package/dist/stryker-package.mjs

@@ -0,0 +1,2 @@
+import { n as strykerVersion, t as strykerEngines } from "./stryker-package-CTcsIZ4S.mjs";
+export { strykerEngines, strykerVersion };

package/dist/timer-BMrE1SQ3.d.mts

@@ -0,0 +1,20 @@
+//#region src/timer.d.ts
+/**
+ * Published as the `./timer` subpath: the mutation-report package's
+ * progress reporters construct a `Timer` from here (KTD7).
+ */
+declare class Timer {
+  private readonly now;
+  private readonly start;
+  private readonly markers;
+  constructor(now?: () => Date);
+  humanReadableElapsed(sinceMarker?: string): string;
+  elapsedSeconds(sinceMarker?: string): number;
+  elapsedMs(sinceMarker?: string): number;
+  mark(name: string): void;
+  private static humanReadableElapsedSeconds;
+  private static humanReadableElapsedMinutes;
+  private static formatTime;
+}
+//#endregion
+export { Timer as t };

package/dist/timer.d.mts

@@ -0,0 +1,2 @@
+import { t as Timer } from "./timer-BMrE1SQ3.mjs";
+export { Timer };

package/dist/timer.mjs

@@ -0,0 +1,48 @@
+//#region src/timer.ts
+/**
+* Published as the `./timer` subpath: the mutation-report package's
+* progress reporters construct a `Timer` from here (KTD7).
+*/
+var Timer = class Timer {
+	now;
+	start;
+	markers = /* @__PURE__ */ new Map();
+	constructor(now = () => /* @__PURE__ */ new Date()) {
+		this.now = now;
+		this.start = this.now();
+	}
+	humanReadableElapsed(sinceMarker) {
+		const elapsedSeconds = this.elapsedSeconds(sinceMarker);
+		return new Intl.ListFormat("en").format([Timer.humanReadableElapsedMinutes(elapsedSeconds), Timer.humanReadableElapsedSeconds(elapsedSeconds)].filter(Boolean));
+	}
+	elapsedSeconds(sinceMarker) {
+		const elapsedMs = this.elapsedMs(sinceMarker);
+		return Math.floor(elapsedMs / 1e3);
+	}
+	elapsedMs(sinceMarker) {
+		const marker = sinceMarker && this.markers.get(sinceMarker);
+		if (marker) return this.now().getTime() - marker.getTime();
+		else return this.now().getTime() - this.start.getTime();
+	}
+	mark(name) {
+		this.markers.set(name, this.now());
+	}
+	static humanReadableElapsedSeconds(elapsedSeconds) {
+		const restSeconds = elapsedSeconds % 60;
+		return this.formatTime("second", restSeconds);
+	}
+	static humanReadableElapsedMinutes(elapsedSeconds) {
+		const elapsedMinutes = Math.floor(elapsedSeconds / 60);
+		if (elapsedMinutes === 0) return "";
+		else return this.formatTime("minute", elapsedMinutes);
+	}
+	static formatTime(word, elapsed) {
+		return elapsed.toLocaleString("en", {
+			unit: word,
+			style: "unit",
+			unitDisplay: "long"
+		});
+	}
+};
+//#endregion
+export { Timer };

package/dist/verdict-envelope-BWc61mHm.mjs

@@ -0,0 +1,229 @@
+import "@systemfsoftware/stryker-js-plugin-api/core";
+import { normalizeFileName } from "@stryker-mutator/util";
+import path from "path";
+import { calculateMutationTestMetrics } from "mutation-testing-metrics";
+import { randomFillSync } from "node:crypto";
+//#region src/test-contribution.ts
+const KILLING_STATUSES = /* @__PURE__ */ new Set(["Killed", "Timeout"]);
+const testFileById = (testFiles) => {
+	const byId = /* @__PURE__ */ new Map();
+	for (const [fileName, testFile] of Object.entries(testFiles)) for (const test of testFile.tests) byId.set(test.id, fileName);
+	return byId;
+};
+const killersOf = (killedBy, fileById) => new Set(killedBy.map((testId) => fileById.get(testId) ?? testId));
+const contributionByTestFile = (report) => {
+	const testFiles = report.testFiles ?? {};
+	const fileById = testFileById(testFiles);
+	const soleKills = /* @__PURE__ */ new Map();
+	const totalKills = /* @__PURE__ */ new Map();
+	const unattributed = /* @__PURE__ */ new Set();
+	for (const file of Object.values(report.files)) for (const mutant of file.mutants) {
+		if (!KILLING_STATUSES.has(mutant.status)) continue;
+		const killers = killersOf(mutant.killedBy ?? [], fileById);
+		if (killers.size === 0) {
+			const covered = mutant.coveredBy;
+			if (covered !== void 0) for (const fileName of killersOf(covered, fileById)) unattributed.add(fileName);
+			continue;
+		}
+		const soleKill = killers.size === 1;
+		for (const fileName of killers) {
+			totalKills.set(fileName, (totalKills.get(fileName) ?? 0) + 1);
+			if (soleKill) soleKills.set(fileName, (soleKills.get(fileName) ?? 0) + 1);
+		}
+	}
+	const byTestFile = /* @__PURE__ */ new Map();
+	for (const fileName of Object.keys(testFiles)) byTestFile.set(fileName, {
+		soleKills: soleKills.get(fileName) ?? 0,
+		totalKills: totalKills.get(fileName) ?? 0,
+		coversUnattributedKill: unattributed.has(fileName)
+	});
+	return byTestFile;
+};
+const toothlessTestFiles = (contribution, { suffixes, everyKillerRecorded }) => {
+	const toothless = [];
+	for (const [fileName, { soleKills, totalKills, coversUnattributedKill }] of contribution) {
+		const defends = everyKillerRecorded ? soleKills > 0 : totalKills > 0;
+		const inScope = suffixes.some((suffix) => fileName.endsWith(suffix));
+		if (!defends && inScope && !coversUnattributedKill) toothless.push(fileName);
+	}
+	return toothless.sort();
+};
+const suffixesToRequire = (value) => {
+	if (!Array.isArray(value)) return void 0;
+	const suffixes = value.filter((entry) => typeof entry === "string");
+	return suffixes.length === 0 ? void 0 : suffixes;
+};
+const PRECISION = "every killing test was recorded";
+const judgeTestContribution = (report, requireTestContribution, everyKillerRecorded) => {
+	const suffixes = suffixesToRequire(requireTestContribution);
+	if (suffixes === void 0) return void 0;
+	const matches = suffixes.join(", ");
+	const contribution = contributionByTestFile(report);
+	const inScope = [...contribution.keys()].filter((fileName) => suffixes.some((suffix) => fileName.endsWith(suffix)));
+	if (inScope.length === 0) return {
+		failed: false,
+		message: `No test file matching ${matches} ran, so none was judged.`
+	};
+	if (!everyKillerRecorded) return {
+		failed: true,
+		message: `This run used Stryker's bail mode, which stops each mutant at its first killing test. A test file's contribution therefore cannot be measured on this evidence. Set \`disableBail: true\` to record every killing test, or remove \`${matches}\` from \`requireTestContribution\` (set it to \`null\` to disable the check) to narrow the gate out of scope for this run.`
+	};
+	if (![...contribution.values()].some(({ totalKills }) => totalKills > 0)) return {
+		failed: true,
+		message: `This run credited no kill to any test file, so no test file's contribution to it can be measured. Until that is fixed the ${inScope.length} file(s) matching ${matches} are unjudged, not cleared.`
+	};
+	const toothless = toothlessTestFiles(contribution, {
+		suffixes,
+		everyKillerRecorded
+	});
+	if (toothless.length === 0) return {
+		failed: false,
+		message: `Every test file matching ${matches} kills a mutant nothing else kills (${PRECISION}).`
+	};
+	const listed = toothless.map((fileName) => `  - ${fileName}`).join("\n");
+	return {
+		failed: true,
+		message: `Deleting these ${toothless.length} test file(s) would leave every mutant just as dead (${PRECISION}):\n${listed}`
+	};
+};
+//#endregion
+//#region src/verdict-envelope.ts
+/**
+* U4 — the verdict envelope (R5, R11, R20): the single JSON document machine
+* mode prints to stdout at the end of a run. Everything an agent needs to
+* act without opening the report file, including the survivor re-run
+* matching key per actionable mutant (R20 bounds the list). All functions
+* here are pure over the report — no I/O side effects, no randomness except
+* inside `generateRunId`.
+*/
+const VERDICT_ENVELOPE_SCHEMA_VERSION = "1.0";
+/**
+* The statuses a `verdict.mutants` entry (and a `mutant` stream line, U7) is
+* recorded for (R20). `Killed`, `Ignored`, and `CompileError` are reported
+* as counts only: the full per-mutant record stays in the report file, and
+* enumerating killed mutants served no consumer while pushing the terminal
+* line past the 64 KB limit of `bufio.Scanner`-class readers. Measured:
+* `oxlint-plugins/effect-workflow` produced a 2164-entry, ~440 KB line with
+* zero actionable entries. This is the single definition of the R20 filter,
+* shared with the progress stream.
+*/
+const ACTIONABLE_STATUSES = [
+	"Survived",
+	"NoCoverage",
+	"Timeout",
+	"RuntimeError"
+];
+/**
+* Whether `status` is actionable (R20) — one of `ACTIONABLE_STATUSES`.
+*/
+function isActionableStatus(status) {
+	return ACTIONABLE_STATUSES.some((actionable) => actionable === status);
+}
+const CROCKFORD_BASE32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+/**
+* A ULID-shaped run identifier: 48 bits of millisecond time followed by 80
+* random bits, Crockford base32-encoded into exactly 26 characters. The time
+* prefix keeps ids roughly sortable; the randomness makes collisions
+* negligible.
+*/
+function generateRunId() {
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	const now = Date.now();
+	bytes[0] = now / 1099511627776 % 256;
+	bytes[1] = now / 4294967296 % 256;
+	bytes[2] = now / 16777216 % 256;
+	bytes[3] = now / 65536 % 256;
+	bytes[4] = now / 256 % 256;
+	bytes[5] = now % 256;
+	randomFillSync(bytes.subarray(6));
+	let chars = "";
+	let value = 0;
+	let bits = 0;
+	for (const byte of bytes) {
+		value = value << 8 | byte;
+		bits += 8;
+		while (bits >= 5) {
+			chars += CROCKFORD_BASE32[value >>> bits - 5 & 31];
+			bits -= 5;
+			value &= (1 << bits) - 1;
+		}
+	}
+	if (bits > 0) chars += CROCKFORD_BASE32[value << 5 - bits & 31];
+	return chars;
+}
+/**
+* The resolved options the report helper embeds as `report.config` (it writes
+* `config: this.options`). Read through `in`-narrowing because the report
+* schema types `config` as `{}`, while the embedded value is our own resolved
+* options with their index signature.
+*/
+function embeddedConfig(report) {
+	const config = report.config;
+	let jsonReporterFileName;
+	let requireTestContribution;
+	let disableBail = false;
+	if (typeof config === "object" && config !== null) {
+		if ("jsonReporter" in config && typeof config.jsonReporter === "object" && config.jsonReporter !== null && "fileName" in config.jsonReporter && typeof config.jsonReporter.fileName === "string") jsonReporterFileName = config.jsonReporter.fileName;
+		if ("requireTestContribution" in config) requireTestContribution = config.requireTestContribution;
+		if ("disableBail" in config && typeof config.disableBail === "boolean") disableBail = config.disableBail;
+	}
+	return {
+		jsonReporterFileName,
+		requireTestContribution,
+		disableBail
+	};
+}
+function breakThreshold(thresholds) {
+	if ("break" in thresholds) {
+		const breakValue = thresholds.break;
+		if (typeof breakValue === "number") return breakValue;
+		if (breakValue === null) return null;
+	}
+	return null;
+}
+function buildVerdictEnvelope(report, mode, signal, runId) {
+	const { jsonReporterFileName, requireTestContribution, disableBail } = embeddedConfig(report);
+	const metrics = calculateMutationTestMetrics(report).systemUnderTestMetrics.metrics;
+	const hasMutants = metrics.totalMutants > 0;
+	const score = hasMutants && Number.isFinite(metrics.mutationScore) ? metrics.mutationScore : null;
+	const reportFile = hasMutants && jsonReporterFileName !== void 0 ? normalizeFileName(path.relative(process.cwd(), jsonReporterFileName)) : null;
+	const mutants = [];
+	for (const [file, fileResult] of Object.entries(report.files)) for (const mutant of fileResult.mutants) {
+		if (!isActionableStatus(mutant.status)) continue;
+		mutants.push({
+			id: mutant.id,
+			file,
+			location: mutant.location,
+			mutator: mutant.mutatorName,
+			replacement: mutant.replacement ?? null,
+			status: mutant.status
+		});
+	}
+	return {
+		schemaVersion: "1.0",
+		runId,
+		mode,
+		signal,
+		score,
+		thresholds: {
+			high: report.thresholds.high,
+			low: report.thresholds.low,
+			break: breakThreshold(report.thresholds)
+		},
+		counts: {
+			killed: metrics.killed,
+			timeout: metrics.timeout,
+			survived: metrics.survived,
+			noCoverage: metrics.noCoverage,
+			runtimeErrors: metrics.runtimeErrors,
+			compileErrors: metrics.compileErrors,
+			ignored: metrics.ignored,
+			pending: metrics.pending
+		},
+		testContribution: judgeTestContribution(report, requireTestContribution, disableBail) ?? null,
+		reportFile,
+		mutants
+	};
+}
+//#endregion
+export { isActionableStatus as a, generateRunId as i, VERDICT_ENVELOPE_SCHEMA_VERSION as n, judgeTestContribution as o, buildVerdictEnvelope as r, ACTIONABLE_STATUSES as t };

package/dist/verdict-envelope-CKLZPjxC.d.mts

@@ -0,0 +1,94 @@
+import { n as OutputMode, t as ModeSignal } from "./output-mode-CfGHDpi5.mjs";
+import { MutantStatus, schema } from "@systemfsoftware/stryker-js-plugin-api/core";
+//#region src/test-contribution.d.ts
+interface TestContributionVerdict {
+  readonly failed: boolean;
+  readonly message: string;
+}
+//#endregion
+//#region src/verdict-envelope.d.ts
+/**
+ * U4 — the verdict envelope (R5, R11, R20): the single JSON document machine
+ * mode prints to stdout at the end of a run. Everything an agent needs to
+ * act without opening the report file, including the survivor re-run
+ * matching key per actionable mutant (R20 bounds the list). All functions
+ * here are pure over the report — no I/O side effects, no randomness except
+ * inside `generateRunId`.
+ */
+declare const VERDICT_ENVELOPE_SCHEMA_VERSION = "1.0";
+/**
+ * The statuses a `verdict.mutants` entry (and a `mutant` stream line, U7) is
+ * recorded for (R20). `Killed`, `Ignored`, and `CompileError` are reported
+ * as counts only: the full per-mutant record stays in the report file, and
+ * enumerating killed mutants served no consumer while pushing the terminal
+ * line past the 64 KB limit of `bufio.Scanner`-class readers. Measured:
+ * `oxlint-plugins/effect-workflow` produced a 2164-entry, ~440 KB line with
+ * zero actionable entries. This is the single definition of the R20 filter,
+ * shared with the progress stream.
+ */
+declare const ACTIONABLE_STATUSES: readonly ['Survived', 'NoCoverage', 'Timeout', 'RuntimeError'];
+/**
+ * Whether `status` is actionable (R20) — one of `ACTIONABLE_STATUSES`.
+ */
+declare function isActionableStatus(status: MutantStatus): boolean;
+/**
+ * One mutant as the envelope reports it. `file` is the report's relative file
+ * key; `location`/`mutator`/`replacement` are exactly the survivor re-run
+ * matching key (R10/R11).
+ */
+interface VerdictMutant {
+  readonly id: string;
+  readonly file: string;
+  readonly location: schema.Location;
+  readonly mutator: string;
+  readonly replacement: string | null;
+  readonly status: MutantStatus;
+}
+/**
+ * The configured thresholds. `break` rides along even though the report
+ * schema does not declare it — it is the threshold the exit code depends on.
+ */
+interface VerdictThresholds {
+  readonly high: number;
+  readonly low: number;
+  readonly break: number | null;
+}
+interface VerdictCounts {
+  readonly killed: number;
+  readonly timeout: number;
+  readonly survived: number;
+  readonly noCoverage: number;
+  readonly runtimeErrors: number;
+  readonly compileErrors: number;
+  readonly ignored: number;
+  readonly pending: number;
+}
+/**
+ * The full verdict document. `score` and `reportFile` are `null` for a run
+ * with zero mutants (AE3): there is no score to report and no report file was
+ * written. `testContribution` is `null` when the check is not configured.
+ * `mutants` is bounded to `ACTIONABLE_STATUSES` (R20) — see that definition
+ * for why the remaining statuses are counts only.
+ */
+interface VerdictEnvelope {
+  readonly schemaVersion: string;
+  readonly runId: string;
+  readonly mode: OutputMode;
+  readonly signal: ModeSignal;
+  readonly score: number | null;
+  readonly thresholds: VerdictThresholds;
+  readonly counts: VerdictCounts;
+  readonly testContribution: TestContributionVerdict | null;
+  readonly reportFile: string | null;
+  readonly mutants: readonly VerdictMutant[];
+}
+/**
+ * A ULID-shaped run identifier: 48 bits of millisecond time followed by 80
+ * random bits, Crockford base32-encoded into exactly 26 characters. The time
+ * prefix keeps ids roughly sortable; the randomness makes collisions
+ * negligible.
+ */
+declare function generateRunId(): string;
+declare function buildVerdictEnvelope(report: schema.MutationTestResult, mode: OutputMode, signal: ModeSignal, runId: string): VerdictEnvelope;
+//#endregion
+export { VerdictMutant as a, generateRunId as c, VerdictEnvelope as i, isActionableStatus as l, VERDICT_ENVELOPE_SCHEMA_VERSION as n, VerdictThresholds as o, VerdictCounts as r, buildVerdictEnvelope as s, ACTIONABLE_STATUSES as t };

package/dist/verdict-envelope.d.mts

@@ -0,0 +1,2 @@
+import { a as VerdictMutant, c as generateRunId, i as VerdictEnvelope, l as isActionableStatus, n as VERDICT_ENVELOPE_SCHEMA_VERSION, o as VerdictThresholds, r as VerdictCounts, s as buildVerdictEnvelope, t as ACTIONABLE_STATUSES } from "./verdict-envelope-CKLZPjxC.mjs";
+export { ACTIONABLE_STATUSES, VERDICT_ENVELOPE_SCHEMA_VERSION, VerdictCounts, VerdictEnvelope, VerdictMutant, VerdictThresholds, buildVerdictEnvelope, generateRunId, isActionableStatus };

package/dist/verdict-envelope.mjs

@@ -0,0 +1,2 @@
+import { a as isActionableStatus, i as generateRunId, n as VERDICT_ENVELOPE_SCHEMA_VERSION, r as buildVerdictEnvelope, t as ACTIONABLE_STATUSES } from "./verdict-envelope-BWc61mHm.mjs";
+export { ACTIONABLE_STATUSES, VERDICT_ENVELOPE_SCHEMA_VERSION, buildVerdictEnvelope, generateRunId, isActionableStatus };