@systemfsoftware/stryker-js 4.0.0 → 5.0.0

package/dist/builtin-reporters-wAuKFSsd.mjs

@@ -0,0 +1,672 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import "effect/Stdio";
+import { MetricsResultSchema, MutationTestResultSchema, ReporterFailed } from "@systemfsoftware/stryker-js-plugin-interface";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as S from "effect/Schema";
+import * as Stream from "effect/Stream";
+import { errorToString } from "@systemfsoftware/stryker-js-instrumenter/mutants";
+import * as Predicate from "effect/Predicate";
+import "effect/Sink";
+//#region src/reporter-output.ts
+const sinksOf = (stdio) => ({
+	stdout: () => stdio.stdout({ endOnDone: false }),
+	stderr: () => stdio.stderr({ endOnDone: false })
+});
+const sinkFor = (stdio, channel) => sinksOf(stdio)[channel]();
+const write = (stdio, channel, chunks) => Stream.run(Stream.fromIterable(chunks), sinkFor(stdio, channel));
+/**
+* The one Effect→Promise bridge for the sync-loop progress bar (the only reporter
+* that cannot compose Effects — its writes fire inside a synchronous for-await).
+* Write errors are ignored like a broken pipe on a stream handle.
+*
+* Note: effect 4.0.0-rc.112 exports the runner as `Effect.runPromise`; there is no
+* `Runtime.runPromise` in this version (verified against the installed source) —
+* do not invent that import.
+*/
+const writeAsync = (stdio, channel, chunks) => Effect.runPromise(Effect.ignore(write(stdio, channel, chunks)));
+//#endregion
+//#region src/Reporter.ansi.ts
+const codes = {
+	red: "\x1B[31m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m",
+	grey: "\x1B[90m",
+	cyan: "\x1B[36m",
+	greenBright: "\x1B[92m",
+	redBright: "\x1B[91m",
+	blueBright: "\x1B[94m"
+};
+const reset = "\x1B[39m";
+function wrap(color, text) {
+	return `${codes[color]}${text}${reset}`;
+}
+const ansi = {
+	wrap,
+	red: (text) => wrap("red", text),
+	green: (text) => wrap("green", text),
+	yellow: (text) => wrap("yellow", text),
+	grey: (text) => wrap("grey", text),
+	cyan: (text) => wrap("cyan", text),
+	greenBright: (text) => wrap("greenBright", text),
+	redBright: (text) => wrap("redBright", text),
+	blueBright: (text) => wrap("blueBright", text)
+};
+//#endregion
+//#region src/mutation-score-table.ts
+const KNOWN_EMOJI = {
+	"✅": true,
+	"🙈": true,
+	"🤥": true,
+	"👽": true,
+	"⏰": true,
+	"⌛": true,
+	"💥": true
+};
+const charWidth = (char) => Match.value(char).pipe(Match.when((candidate) => KNOWN_EMOJI[candidate] === true, () => 2), Match.when((candidate) => (candidate.codePointAt(0) ?? 0) > 65535, () => 2), Match.orElse(() => 1));
+function stringWidth(input) {
+	return Array.from(input).reduce((width, char) => width + charWidth(char), 0);
+}
+const FILES_ROOT_NAME = "All files";
+const repeat = (char, nTimes) => {
+	if (nTimes > -1) return char.repeat(nTimes);
+	return char.repeat(0);
+};
+const spaces = (n) => repeat(" ", n);
+const statusHeader = (allowEmojis, emoji, label) => {
+	if (allowEmojis) return `${emoji} ${label}`;
+	return `# ${label}`;
+};
+const maxOf = (values) => values.reduce((acc, cur) => {
+	if (cur > acc) return cur;
+	return acc;
+}, Number.NEGATIVE_INFINITY);
+const widthOrZero = (width) => Match.value(width === Number.NEGATIVE_INFINITY).pipe(Match.when(true, () => 0), Match.when(false, () => width), Match.exhaustive);
+const determineContentWidth = (row, valueFactory, ancestorCount = 0) => {
+	const head = valueFactory(row, ancestorCount).length;
+	const childWidths = row.childResults.map((child) => determineContentWidth(child, valueFactory, ancestorCount + 1));
+	return widthOrZero(maxOf([head, ...childWidths]));
+};
+const columnWidth = (column) => {
+	if (column.isFirstColumn) return column.netWidth + 1;
+	return column.netWidth + 2;
+};
+const padColumn = (column, input) => Match.value(column.kind === "file").pipe(Match.when(true, () => `${input}${spaces(columnWidth(column) - stringWidth(input))}`), Match.when(false, () => Match.value(column.isFirstColumn).pipe(Match.when(true, () => `${spaces(column.netWidth - stringWidth(input))}${input} `), Match.when(false, () => `${spaces(column.netWidth - stringWidth(input))} ${input} `), Match.exhaustive)), Match.exhaustive);
+const drawLine = (column) => repeat("-", columnWidth(column));
+const drawHeader = (column) => padColumn(column, column.header);
+const mutationScoreOf = (scoreType, metrics) => Match.value(scoreType).pipe(Match.when("total", () => metrics.mutationScore), Match.when("covered", () => metrics.mutationScoreBasedOnCoveredCode), Match.exhaustive);
+const thresholdColor = (thresholds, value) => Match.value(value).pipe(Match.when((present) => Number.isNaN(present), () => ansi.grey), Match.when((present) => present >= thresholds.high, () => ansi.green), Match.when((present) => present >= thresholds.low, () => ansi.yellow), Match.orElse(() => ansi.red));
+const scoreColor = (column, score) => Match.value(column.allowColor).pipe(Match.when(true, () => thresholdColor(column.thresholds, mutationScoreOf(column.scoreType, score.metrics))), Match.when(false, () => (input) => input), Match.exhaustive);
+const colorFor = (column, score) => Match.value(column).pipe(Match.discriminator("kind")("mutationScore", (scored) => scoreColor(scored, score)), Match.orElse(() => (input) => input));
+const drawTableCell = (column, score, ancestorCount) => {
+	switch (column.kind) {
+		case "group": return column.columns.map((c) => drawTableCell(c, score, ancestorCount)).join("|");
+		case "single":
+		case "file":
+		case "mutationScore": {
+			const raw = column.valueFactory(score, ancestorCount);
+			const padded = padColumn(column, raw);
+			return colorFor(column, score)(padded);
+		}
+	}
+};
+const drawColumnHeaders = (column) => {
+	if (column.kind !== "group") return drawHeader(column);
+	return column.columns.map((c) => drawHeader(c)).join("|");
+};
+const drawColumnLines = (column) => {
+	if (column.kind !== "group") return drawLine(column);
+	return column.columns.map((c) => drawLine(c)).join("|");
+};
+const makeSingleColumn = (header, isFirstColumn, valueFactory, rows) => {
+	const maxContentSize = determineContentWidth(rows, valueFactory);
+	const netWidth = maxOf([maxContentSize, stringWidth(header)]);
+	return {
+		kind: "single",
+		header,
+		isFirstColumn,
+		netWidth: widthOrZero(netWidth),
+		valueFactory,
+		rows
+	};
+};
+const makeFileColumn = (rows) => {
+	const valueFactory = (row, ancestorCount) => {
+		if (ancestorCount === 0) return spaces(ancestorCount) + FILES_ROOT_NAME;
+		return spaces(ancestorCount) + row.name;
+	};
+	const netWidth = maxOf([determineContentWidth(rows, valueFactory), stringWidth("File")]);
+	return {
+		kind: "file",
+		header: "File",
+		isFirstColumn: true,
+		netWidth: widthOrZero(netWidth),
+		valueFactory,
+		rows
+	};
+};
+const makeMutationScoreColumn = (rows, thresholds, scoreType, allowColor) => {
+	const valueFactory = (row) => Match.value(mutationScoreOf(scoreType, row.metrics)).pipe(Match.when((present) => Number.isNaN(present), () => "n/a"), Match.orElse((present) => present.toFixed(2)));
+	const netWidth = maxOf([determineContentWidth(rows, valueFactory), stringWidth(scoreType)]);
+	return {
+		kind: "mutationScore",
+		header: scoreType,
+		isFirstColumn: false,
+		netWidth: widthOrZero(netWidth),
+		valueFactory,
+		rows,
+		thresholds,
+		scoreType,
+		allowColor
+	};
+};
+const paddingWidth = (isFirstColumn) => Match.value(isFirstColumn).pipe(Match.when(true, () => 1), Match.when(false, () => 2), Match.exhaustive);
+const widthAdjustedColumns = (columns, first, columnsWidth, netWidth) => Match.value(netWidth > columnsWidth + 1).pipe(Match.when(true, () => [{
+	...first,
+	netWidth: first.netWidth + (netWidth - columnsWidth - 1)
+}, ...columns.slice(1)]), Match.when(false, () => columns), Match.exhaustive);
+const makeGroupColumn = (groupName, ...columns) => {
+	const [first, ...rest] = columns;
+	if (first === void 0) throw new Error("a group column needs at least one column");
+	const columnsWidth = rest.reduce((acc, cur) => acc + columnWidth(cur), columnWidth(first)) - paddingWidth(first.isFirstColumn);
+	const netWidth = widthOrZero(maxOf([stringWidth(groupName), columnsWidth]));
+	return {
+		kind: "group",
+		header: groupName,
+		isFirstColumn: first.isFirstColumn,
+		netWidth,
+		columns: widthAdjustedColumns(columns, first, columnsWidth, netWidth)
+	};
+};
+const createColumns = (metricsResult, options) => {
+	const allowColor = options.clearTextReporter.allowColor;
+	const allowEmojis = options.clearTextReporter.allowEmojis;
+	return [
+		makeGroupColumn("", makeFileColumn(metricsResult)),
+		makeGroupColumn("% Mutation score", makeMutationScoreColumn(metricsResult, options.thresholds, "total", allowColor), makeMutationScoreColumn(metricsResult, options.thresholds, "covered", allowColor)),
+		makeGroupColumn("", makeSingleColumn(statusHeader(allowEmojis, "✅", "killed"), false, (row) => row.metrics.killed.toString(), metricsResult)),
+		makeGroupColumn("", makeSingleColumn(statusHeader(allowEmojis, "⌛️", "timeout"), false, (row) => row.metrics.timeout.toString(), metricsResult)),
+		makeGroupColumn("", makeSingleColumn(statusHeader(allowEmojis, "👽", "survived"), false, (row) => row.metrics.survived.toString(), metricsResult)),
+		makeGroupColumn("", makeSingleColumn(statusHeader(allowEmojis, "🙈", "no cov"), false, (row) => row.metrics.noCoverage.toString(), metricsResult)),
+		makeGroupColumn("", makeSingleColumn(statusHeader(allowEmojis, "💥", "errors"), false, (row) => (row.metrics.runtimeErrors + row.metrics.compileErrors).toString(), metricsResult))
+	];
+};
+const drawRow = (columns, toDraw) => `${columns.map(toDraw).join("|")}|`;
+const drawGroupHeader = (columns) => drawRow(columns, (c) => drawHeader(c));
+const drawGroupLine = (columns) => drawRow(columns, (c) => drawLine(c));
+const drawLineRow = (columns) => drawRow(columns, (c) => drawColumnLines(c));
+const drawColumnHeader = (columns) => drawRow(columns, (c) => drawColumnHeaders(c));
+const drawTableBody = (columns, options, current, ancestorCount) => {
+	const ownRow = Match.value(options.clearTextReporter.skipFull === false || current.metrics.mutationScore !== 100).pipe(Match.when(true, () => [drawRow(columns, (column) => drawTableCell(column, current, ancestorCount))]), Match.when(false, () => []), Match.exhaustive);
+	const childRows = current.childResults.flatMap((child) => drawTableBody(columns, options, child, ancestorCount + 1));
+	return [...ownRow, ...childRows];
+};
+const EOL = "\n";
+const drawMutationScoreTable = (metricsResult, options) => {
+	const columns = createColumns(metricsResult, options);
+	return [
+		drawGroupLine(columns),
+		drawGroupHeader(columns),
+		drawColumnHeader(columns),
+		drawLineRow(columns),
+		drawTableBody(columns, options, metricsResult, 0).join(EOL),
+		drawLineRow(columns)
+	].join(EOL);
+};
+//#endregion
+//#region src/Reporter.schema.ts
+var ClearTextReportCommand = class extends S.TaggedClass()("ClearTextReportCommand", {
+	report: MutationTestResultSchema,
+	metrics: MetricsResultSchema
+}) {};
+//#endregion
+//#region src/clear-text-report.ts
+function plural(items) {
+	if (items > 1) return "s";
+	else return "";
+}
+function getEmojiForStatus(status) {
+	switch (status) {
+		case "Killed": return "✅";
+		case "NoCoverage": return "🙈";
+		case "Ignored": return "🤥";
+		case "Survived": return "👽";
+		case "Timeout": return "⏰";
+		case "Pending": return "⌛";
+		case "RuntimeError":
+		case "CompileError": return "💥";
+	}
+}
+function sourceLocation(fileName, position, allowColor) {
+	return [
+		(() => {
+			if (allowColor) return ansi.cyan(fileName);
+			return fileName;
+		})(),
+		(() => {
+			if (allowColor) return ansi.yellow(String(position.line));
+			return String(position.line);
+		})(),
+		(() => {
+			if (allowColor) return ansi.yellow(String(position.column));
+			return String(position.column);
+		})()
+	].join(":");
+}
+function mutantLabel(status, allowEmojis) {
+	if (allowEmojis) return `${getEmojiForStatus(status)} ${status}`;
+	return status;
+}
+/**
+* Where a mutant's block is written: the diagnostics channel for mutants that
+* failed to run, the report for the ones that inform, and nowhere for the rest.
+*/
+const REPORT_CHANNEL = {
+	Killed: "debug",
+	Timeout: "debug",
+	RuntimeError: "debug",
+	CompileError: "debug",
+	Survived: "stdout",
+	NoCoverage: "stdout",
+	Ignored: "none",
+	Pending: "none"
+};
+function extractReportMutants(report) {
+	if (!Predicate.hasProperty(report, "files")) return [];
+	return Object.entries(report.files).flatMap(([fileName, file]) => file.mutants.map((mutant) => ({
+		fileName,
+		mutant: {
+			...mutant,
+			fileName
+		},
+		source: file.source
+	})));
+}
+function sourceLine(source, position) {
+	const raw = source.split("\n")[position.line - 1];
+	if (raw === void 0) return "";
+	return raw;
+}
+function tailFromColumn(raw, column) {
+	if (raw.length === 0) return [];
+	return [raw.slice(column)];
+}
+function sliceSource(source, position) {
+	if (source === void 0) return [];
+	return tailFromColumn(sourceLine(source, position), position.column);
+}
+function originalLines(source, position, allowColor) {
+	return sliceSource(source, position).map((l) => {
+		if (allowColor) return ansi.red(`-   ${l}`);
+		return `-   ${l}`;
+	});
+}
+function replacementLines(replacement, allowColor) {
+	if (replacement === void 0) return [];
+	return replacement.split("\n").filter(Boolean).map((l) => {
+		if (allowColor) return ansi.green(`+   ${l}`);
+		return `+   ${l}`;
+	});
+}
+const logsCoveredTests = (mutant, options) => {
+	if (!options.clearTextReporter.logTests) return false;
+	return mutant.coveredBy !== void 0;
+};
+const coveredTestsTail = (mutant, options) => {
+	if (!logsCoveredTests(mutant, options)) return [];
+	return formatCoveredTests(mutant.coveredBy, options);
+};
+const survivorTail = (mutant, options) => {
+	if (mutant.static === true) return ["Ran all tests for this mutant."];
+	return coveredTestsTail(mutant, options);
+};
+const killedByLine = (killer) => {
+	if (killer === void 0) return [];
+	return [`Killed by: ${killer}`];
+};
+const killerTail = (mutant) => {
+	const killedBy = mutant.killedBy;
+	if (killedBy === void 0) return [];
+	return killedByLine(killedBy[0]);
+};
+const statusReasonTail = (mutant) => {
+	if (mutant.statusReason === void 0) return [];
+	return [`Error message: ${mutant.statusReason}`];
+};
+/**
+* The lines below a mutant block: one tail per status, chosen by the status the
+* mutant settled at.
+*/
+const statusTail = (mutant, options) => Match.value(mutant.status).pipe(Match.when("Survived", () => survivorTail(mutant, options)), Match.when("Killed", () => killerTail(mutant)), Match.whenOr("RuntimeError", "CompileError", () => statusReasonTail(mutant)), Match.orElse(() => []));
+const overflowNotice = (hidden) => {
+	if (hidden <= 0) return [];
+	return [`  and ${hidden} more test${plural(hidden)}!`];
+};
+function formatCoveredTests(tests, options) {
+	const maxLog = options.clearTextReporter.maxTestsToLog;
+	const logged = Math.min(maxLog, tests.length);
+	if (logged <= 0) return [];
+	return [
+		"Tests ran:",
+		...tests.slice(0, logged).map((test) => `    ${test}`),
+		...overflowNotice(tests.length - maxLog),
+		""
+	];
+}
+function mutantBlock(fileName, mutant, source, options) {
+	const allowColor = options.clearTextReporter.allowColor;
+	const allowEmojis = options.clearTextReporter.allowEmojis;
+	const out = [];
+	out.push(`[${mutantLabel(mutant.status, allowEmojis)}] ${mutant.mutatorName}`);
+	out.push(sourceLocation(fileName, mutant.location.start, allowColor));
+	out.push(...originalLines(source, mutant.location.start, allowColor));
+	out.push(...replacementLines(mutant.replacement, allowColor));
+	out.push(...statusTail(mutant, options));
+	out.push("");
+	return out;
+}
+const linesForChannel = (entries, channel, options) => {
+	return entries.filter((entry) => REPORT_CHANNEL[entry.mutant.status] === channel).flatMap((entry) => mutantBlock(entry.fileName, entry.mutant, entry.source, options));
+};
+function collectMutants(report, options) {
+	const entries = extractReportMutants(report);
+	return {
+		stdout: linesForChannel(entries, "stdout", options),
+		debug: linesForChannel(entries, "debug", options),
+		totalTests: entries.reduce((total, entry) => total + (entry.mutant.testsCompleted ?? 0), 0)
+	};
+}
+const partialScoresVisible = (metrics, options) => {
+	if (!options.clearTextReporter.skipFull) return true;
+	return metrics.childResults.some((child) => child.metrics.mutationScore !== 100);
+};
+const drawsScoreTable = (metrics, options) => {
+	if (!options.clearTextReporter.reportScoreTable) return false;
+	return partialScoresVisible(metrics, options);
+};
+function scoreTable(metrics, options) {
+	if (!drawsScoreTable(metrics, options)) return void 0;
+	return drawMutationScoreTable(metrics, options);
+}
+const EMPTY_REPORT_LINES = {
+	stdout: [],
+	debug: []
+};
+const testsPerMutant = (metrics, totalTests) => {
+	const total = metrics.metrics.totalMutants;
+	if (total === 0) return "0.00";
+	return (totalTests / total).toFixed(2);
+};
+const lineIfPresent = (line) => {
+	if (line === void 0) return [];
+	return [line];
+};
+const mutantReportSection = (report, metrics, options) => {
+	if (!options.clearTextReporter.reportMutants) return EMPTY_REPORT_LINES;
+	const blocks = collectMutants(report, options);
+	return {
+		stdout: [
+			"",
+			...blocks.stdout,
+			`Ran ${testsPerMutant(metrics, blocks.totalTests)} tests per mutant on average.`
+		],
+		debug: blocks.debug
+	};
+};
+function renderClearText(report, metrics, options) {
+	const section = mutantReportSection(report, metrics, options);
+	return {
+		stdout: [
+			"",
+			...section.stdout,
+			...lineIfPresent(scoreTable(metrics, options))
+		],
+		debug: [...section.debug]
+	};
+}
+const rememberTerminalReport = (seen, event) => {
+	Match.value(event).pipe(Match.tag("mutationTestReportReady", (ready) => {
+		seen.terminal = {
+			report: ready.report,
+			metrics: ready.metrics
+		};
+	}), Match.orElse(() => void 0));
+};
+const decodeClearTextReport = (terminal) => S.decodeUnknownEffect(ClearTextReportCommand)({
+	_tag: "ClearTextReportCommand",
+	report: terminal.report,
+	metrics: terminal.metrics
+}).pipe(Effect.mapError((cause) => ReporterFailed.make({
+	reporterName: "clear-text",
+	event: "mutationTestReportReady",
+	cause: errorToString(cause)
+})));
+const streamErrorOf$1 = (cause) => ReporterFailed.make({
+	reporterName: "clear-text",
+	event: "mutationTestReportReady",
+	cause: errorToString(cause)
+});
+const failAsClearText = (cause) => ReporterFailed.make({
+	reporterName: "clear-text",
+	event: "mutationTestReportReady",
+	cause: errorToString(cause)
+});
+const writeRendered = (services, rendered, options) => {
+	const stdoutEffect = write(services.stdio, "stdout", rendered.stdout.map((line) => `${line}\n`)).pipe(Effect.mapError(failAsClearText), Effect.asVoid);
+	return Match.value(options.logLevel === "debug").pipe(Match.when(true, () => Effect.andThen(stdoutEffect, write(services.stdio, "stderr", rendered.debug.map((line) => `${line}\n`)).pipe(Effect.mapError(failAsClearText)))), Match.orElse(() => stdoutEffect));
+};
+const makeClearTextReporter = (services) => (options) => (events) => {
+	const seen = {};
+	return Stream.runForEach(Stream.fromAsyncIterable(events, streamErrorOf$1), (event) => Effect.sync(() => rememberTerminalReport(seen, event))).pipe(Effect.andThen(Effect.sync(() => seen.terminal)), Effect.flatMap((terminal) => Option.match(Option.fromUndefinedOr(terminal), {
+		onNone: () => Effect.void,
+		onSome: (ready) => decodeClearTextReport(ready).pipe(Effect.flatMap((command) => writeRendered(services, renderClearText(command.report, command.metrics, options), options)))
+	})));
+};
+//#endregion
+//#region src/json-reporter.ts
+const failAsJsonReporter = (cause) => ReporterFailed.make({
+	reporterName: "json",
+	event: "mutationTestReportReady",
+	cause: errorToString(cause)
+});
+const writeReport = (services, options, report) => Effect.gen(function* () {
+	const json = yield* S.encodeEffect(S.fromJsonString(S.Unknown, { space: 0 }))(report).pipe(Effect.orDie);
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const fileName = path.resolve(options.jsonReporter.fileName);
+	if (options.logLevel === "debug") yield* Effect.ignore(write(services.stdio, "stderr", [`Using relative path ${path.normalize(options.jsonReporter.fileName)}\n`]));
+	yield* fs.makeDirectory(path.dirname(fileName), { recursive: true }).pipe(Effect.mapError(failAsJsonReporter));
+	yield* fs.writeFileString(fileName, json).pipe(Effect.mapError(failAsJsonReporter));
+	const url = yield* path.toFileUrl(fileName).pipe(Effect.mapError(failAsJsonReporter));
+	yield* Effect.ignore(write(services.stdio, "stdout", [`Your report can be found at: ${url.href}\n`]));
+}).pipe(Effect.provideService(FileSystem.FileSystem, services.fileSystem), Effect.provideService(Path.Path, services.path));
+const rememberReport = (seen, event) => {
+	Match.value(event).pipe(Match.tag("mutationTestReportReady", (ready) => {
+		seen.report = ready.report;
+	}), Match.orElse(() => void 0));
+};
+const streamErrorOf = (cause) => ReporterFailed.make({
+	reporterName: "json",
+	event: "mutationTestReportReady",
+	cause: errorToString(cause)
+});
+const makeJsonReporter = (services) => (options) => (events) => {
+	const seen = {};
+	return Stream.runForEach(Stream.fromAsyncIterable(events, streamErrorOf), (event) => Effect.sync(() => rememberReport(seen, event))).pipe(Effect.andThen(Effect.sync(() => seen.report)), Effect.flatMap((report) => Option.match(Option.fromUndefinedOr(report), {
+		onNone: () => Effect.void,
+		onSome: (ready) => writeReport(services, options, ready)
+	})));
+};
+//#endregion
+//#region src/progress-reporter.ts
+const makeProgressBarState = (format, options) => ({
+	format,
+	total: options.total,
+	curr: 0,
+	width: options.width,
+	complete: options.complete,
+	incomplete: options.incomplete
+});
+const tickProgressBar = (state, ticks) => ({
+	...state,
+	curr: state.curr + ticks
+});
+const renderProgressBar = (state, data) => formatBar(state.format, state.curr, state.total, data, {
+	width: state.width,
+	complete: state.complete,
+	incomplete: state.incomplete
+});
+const isComplete = (state) => state.curr >= state.total;
+function formatBar(format, curr, total, data, options) {
+	const ratio = Match.value(total === 0).pipe(Match.when(true, () => 0), Match.when(false, () => Math.min(curr / total, 1)), Match.exhaustive);
+	const filled = Math.floor(ratio * options.width);
+	const bar = options.complete.repeat(filled) + options.incomplete.repeat(options.width - filled);
+	const percent = `${Math.floor(ratio * 100).toString().padStart(3, " ")}%`;
+	const printed = format.replace(":bar", bar).replace(":percent", percent);
+	return Object.entries(data).reduce((out, [key, value]) => out.replaceAll(`:${key}`, String(value)), printed);
+}
+const emptyTally = (startedAt) => ({
+	survived: 0,
+	timedOut: 0,
+	tested: 0,
+	mutants: 0,
+	total: 0,
+	ticks: 0,
+	ticksByMutantId: {},
+	timing: {
+		net: 0,
+		overhead: 0
+	},
+	capabilities: { reloadEnvironment: false },
+	startedAt
+});
+const getElapsedTime = (tally, now) => {
+	return formatTime(Math.floor((now - tally.startedAt) / 1e3));
+};
+const getEtc = (tally, now) => {
+	const elapsed = Math.floor((now - tally.startedAt) / 1e3);
+	const remaining = Math.floor(elapsed / tally.ticks * (tally.total - tally.ticks));
+	return Match.value(Number.isFinite(remaining) && remaining > 0).pipe(Match.when(true, () => formatTime(remaining)), Match.when(false, () => "n/a"), Match.exhaustive);
+};
+function formatTime(timeInSeconds) {
+	const hours = Math.floor(timeInSeconds / 3600);
+	const minutes = Math.floor(timeInSeconds % 3600 / 60);
+	return Match.value(hours > 0).pipe(Match.when(true, () => `~${hours}h ${minutes}m`), Match.when(false, () => Match.value(minutes > 0).pipe(Match.when(true, () => `~${minutes}m`), Match.when(false, () => "<1m"), Match.exhaustive)), Match.exhaustive);
+}
+const ticksFor = (plan, tally) => Match.value(tally.capabilities.reloadEnvironment === false && plan.reloadEnvironment).pipe(Match.when(true, () => plan.netTime + tally.timing.overhead), Match.when(false, () => plan.netTime), Match.exhaustive);
+const progressData = (tally, now) => ({
+	survived: tally.survived,
+	timedOut: tally.timedOut,
+	tested: tally.tested,
+	mutants: tally.mutants,
+	total: tally.total,
+	ticks: tally.ticks,
+	et: getElapsedTime(tally, now),
+	etc: getEtc(tally, now)
+});
+const tallyAfterTest = (tally, tested, ticks) => {
+	const counted = Match.value(tested.status).pipe(Match.when("Survived", () => ({
+		survived: 1,
+		timedOut: 0
+	})), Match.when("Timeout", () => ({
+		survived: 0,
+		timedOut: 1
+	})), Match.orElse(() => ({
+		survived: 0,
+		timedOut: 0
+	})));
+	return {
+		...tally,
+		tested: tested.completed,
+		ticks: tally.ticks + ticks,
+		survived: tally.survived + counted.survived,
+		timedOut: tally.timedOut + counted.timedOut
+	};
+};
+const PROGRESS_BAR_FORMAT = "Mutation testing  [:bar] :percent (elapsed: :et, remaining: :etc) :tested/:mutants Mutants tested (:survived survived, :timedOut timed out)";
+const PROGRESS_BAR_OPTIONS = {
+	complete: "=",
+	incomplete: " ",
+	width: 50
+};
+const progressStreamErrorOf = (cause) => ReporterFailed.make({
+	reporterName: "progress",
+	event: "mutationTestReportReady",
+	cause: errorToString(cause)
+});
+const makeProgressBarReporter = (services) => () => (events) => {
+	const progress = {
+		tally: emptyTally(0),
+		bar: void 0
+	};
+	let pending = Promise.resolve();
+	const enqueue = (text) => {
+		pending = pending.then(() => writeAsync(services.stdio, "stdout", [text])).catch(() => void 0);
+	};
+	const render = (now) => Option.match(Option.fromUndefinedOr(progress.bar), {
+		onNone: () => void 0,
+		onSome: (bar) => {
+			const line = renderProgressBar(bar, progressData(progress.tally, now));
+			const newline = Match.value(isComplete(bar)).pipe(Match.when(true, () => "\n"), Match.when(false, () => ""), Match.exhaustive);
+			enqueue(`\r${line}${newline}`);
+		}
+	});
+	return Stream.runForEach(Stream.fromAsyncIterable(events, progressStreamErrorOf), (event) => Effect.sync(() => applyProgressEvent(progress, render, event))).pipe(Effect.ensuring(Effect.ignore(Effect.promise(() => {
+		finishProgressBar(progress, enqueue);
+		return pending;
+	}))));
+};
+const makeProgressStreamReporter = () => (events) => Stream.runDrain(Stream.fromAsyncIterable(events, progressStreamErrorOf));
+const applyProgressEvent = (progress, render, event) => {
+	Match.value(event).pipe(Match.tag("dryRunCompleted", (dryRun) => {
+		progress.tally = {
+			...progress.tally,
+			timing: dryRun.timing,
+			capabilities: { reloadEnvironment: dryRun.capabilities.reloadEnvironment }
+		};
+	}), Match.tag("mutationTestingPlanReady", (planReady) => {
+		const ticksByMutantId = Object.fromEntries(planReady.plans.flatMap((plan) => {
+			if (plan.plan !== "Run") return [];
+			return [[plan.mutantId, ticksFor(plan, progress.tally)]];
+		}));
+		const total = Object.values(ticksByMutantId).reduce((sum, ticks) => sum + ticks, 0);
+		progress.tally = {
+			...progress.tally,
+			startedAt: performance.now(),
+			ticksByMutantId,
+			mutants: Object.keys(ticksByMutantId).length,
+			total
+		};
+		progress.bar = makeProgressBarState(PROGRESS_BAR_FORMAT, {
+			...PROGRESS_BAR_OPTIONS,
+			total
+		});
+	}), Match.tag("mutantTested", (tested) => {
+		Option.match(Option.fromUndefinedOr(progress.tally.ticksByMutantId[tested.id]), {
+			onNone: () => void 0,
+			onSome: (ticks) => {
+				progress.tally = tallyAfterTest(progress.tally, tested, ticks);
+				progress.bar = Option.getOrUndefined(Option.map(Option.fromUndefinedOr(progress.bar), (bar) => tickProgressBar(bar, ticks)));
+				render(performance.now());
+			}
+		});
+	}), Match.orElse(() => void 0));
+};
+const finishProgressBar = (progress, enqueue) => {
+	Option.match(Option.fromUndefinedOr(progress.bar), {
+		onNone: () => void 0,
+		onSome: (bar) => Match.value(isComplete(bar)).pipe(Match.when(true, () => void 0), Match.when(false, () => enqueue("\n")), Match.exhaustive)
+	});
+};
+//#endregion
+//#region src/builtin-reporters.ts
+const makeBuiltinReporterFactories = (services) => ({
+	"json": makeJsonReporter(services),
+	"clear-text": makeClearTextReporter(services),
+	"progress": makeProgressBarReporter(services),
+	"progress-stream": makeProgressStreamReporter
+});
+//#endregion
+export { ansi as n, makeBuiltinReporterFactories as t };

package/dist/builtin-reporters.d.mts

@@ -0,0 +1,14 @@
+import * as FileSystem from 'effect/FileSystem';
+import * as Path from 'effect/Path';
+import { ReporterFactory } from '@systemfsoftware/stryker-js-plugin-interface';
+import * as Stdio from 'effect/Stdio';
+
+export declare interface BuiltinReporterServices {
+    readonly fileSystem: FileSystem.FileSystem;
+    readonly path: Path.Path;
+    readonly stdio: Stdio.Stdio;
+}
+
+export declare const makeBuiltinReporterFactories: (services: BuiltinReporterServices) => Record<string, ReporterFactory>;
+
+export { }

package/dist/builtin-reporters.mjs

@@ -0,0 +1,2 @@
+import { t as makeBuiltinReporterFactories } from "./builtin-reporters-wAuKFSsd.mjs";
+export { makeBuiltinReporterFactories };