@systemfsoftware/stryker-js 2.0.0 → 3.0.1

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @systemfsoftware/stryker-js
 
+## 3.0.1
+
+### Patch Changes
+
+- Updated dependencies:
+  - @systemfsoftware/effect-cell-types@7.0.0
+
+## 3.0.0
+
+### Major Changes
+
+- Reporter plugins are now pull-stream consumers: a reporter exports a factory
+  that returns an async consumer of the four run events, instead of registering
+  an Effect layer that provides the `Reporter` capability service.
+
+  - Removed: `ReporterService`, `broadcastReporter`, `NamedReporter`, the
+    `Reporter` service class, and the legacy event payload types.
+  - The event protocol ships as a Standard Schema object; validate and infer it
+    with `import { ReporterEventSchema, type ReporterFactory, type ReporterInit }
+    from '@systemfsoftware/stryker-js/ReporterEvent'`.
+  - Event payloads are narrowed: the dry-run event no longer carries the coverage
+    map; the plan event carries reduced mutant descriptors instead of full run
+    options; `mutantTested` drops `killedBy`, `coveredBy`, `static`,
+    `testsCompleted` and `statusReason`, and renames `mutatorName` to `mutator`.
+  - `ReporterFailed.event` now names the event kind being processed instead of a
+    lifecycle method name; `'wrapUp'` no longer occurs.
+  - An unknown reporter name now fails the run at startup instead of being
+    silently ignored. A reporter that fails on the terminal report now fails the
+    run; a reporter that fails earlier is logged and detached with the exit code
+    unchanged.
+  - `@systemfsoftware/stryker-js-engine/builtin-reporters` no longer exports
+    `strykerPlugins`; call `makeBuiltinReporterFactories({ fileSystem, path })`.
+  - The built-in json and clear-text reporters write their notices directly to
+    stdout and stderr instead of the Effect logger, and the html reporter no
+    longer depends on `@effect/platform-node`.
+
+- Remove the --llms command manifest: the CLI no longer accepts --llms and the Run stream no longer carries a manifest terminal event.
+
 ## 2.0.0
 
 ### Major Changes

package/dist/{Checker-DYgIIEai.d.mts → Checker-A8o5B3Ub.d.mts}

@@ -1,4 +1,4 @@
-import { _t as Mutant } from "./Mutant-BPRJTF8f.mjs";
+import { gt as Mutant } from "./Mutant-Ci25PsWA.mjs";
 import * as Context from "effect/Context";
 import * as S from "effect/Schema";
 import * as Effect from "effect/Effect";

package/dist/Checker.d.mts

@@ -1,2 +1,2 @@
-import { a as FailedCheckResult, c as CheckStatus, l as CheckerFailed, n as Checker, o as PassedCheckResult, r as CheckerService, s as CheckResultSchema, t as CheckResult } from "./Checker-DYgIIEai.mjs";
+import { a as FailedCheckResult, c as CheckStatus, l as CheckerFailed, n as Checker, o as PassedCheckResult, r as CheckerService, s as CheckResultSchema, t as CheckResult } from "./Checker-A8o5B3Ub.mjs";
 export { CheckResult, CheckResultSchema, CheckStatus, Checker, CheckerFailed, CheckerService, FailedCheckResult, PassedCheckResult };

package/dist/{Evaluator-RZBS4oeh.d.mts → Evaluator-CnAN8-pZ.d.mts}

@@ -1,7 +1,7 @@
+import { _ as MutationTestResult } from "./Report.schema-_buHXdnZ.mjs";
 import { r as ExitClass } from "./ExitClass.schema-BmOIK5zT.mjs";
 import * as Context from "effect/Context";
 import * as S from "effect/Schema";
-import * as schema from "mutation-testing-report-schema/api";
 import * as Effect from "effect/Effect";
 //#region src/Evaluator.schema.d.ts
 declare const EvaluatorFailed_base: S.Class<EvaluatorFailed, S.TaggedStruct<"EvaluatorFailed", {
@@ -11,7 +11,7 @@ declare class EvaluatorFailed extends EvaluatorFailed_base {}
 //#endregion
 //#region src/Evaluator.d.ts
 interface EvaluatorService {
-  readonly evaluate: (report: schema.MutationTestResult) => Effect.Effect<ExitClass | null, EvaluatorFailed>;
+  readonly evaluate: (report: MutationTestResult) => Effect.Effect<ExitClass | null, EvaluatorFailed>;
 }
 declare const Evaluator_base: Context.ServiceClass<Evaluator, "~@systemfsoftware/stryker-js/Evaluator", EvaluatorService>;
 declare class Evaluator extends Evaluator_base {}

package/dist/Evaluator.d.mts

@@ -1,3 +1,3 @@
-import { n as EvaluatorService, r as EvaluatorFailed, t as Evaluator } from "./Evaluator-RZBS4oeh.mjs";
+import { n as EvaluatorService, r as EvaluatorFailed, t as Evaluator } from "./Evaluator-CnAN8-pZ.mjs";
 import { r as ExitClass } from "./ExitClass.schema-BmOIK5zT.mjs";
 export { Evaluator, EvaluatorFailed, EvaluatorService, type ExitClass };

package/dist/ExitClass.d.mts

@@ -1,9 +1,9 @@
 import { n as ClassifyExitDecision, r as ExitClass, t as ClassifyExitCommand } from "./ExitClass.schema-BmOIK5zT.mjs";
 //#region src/ExitClass.d.ts
 declare const EXIT_CODE: Record<ExitClass, number>;
-declare function verdictExitClass(score: number | null, breakingThreshold: number | null): ExitClass | null;
 declare function highestExitClass(pending: Iterable<ExitClass>): ExitClass | null;
 declare function resolveExitCode(pending: Iterable<ExitClass>, signal: number | null): number;
+declare function verdictExitClass(score: number | null, breakingThreshold: number | null): ExitClass | null;
 declare const classifyExit: (command: ClassifyExitCommand) => ClassifyExitDecision;
 //#endregion
 export { EXIT_CODE, ExitClass, classifyExit, highestExitClass, resolveExitCode, verdictExitClass };

package/dist/ExitClass.mjs

@@ -1,5 +1,6 @@
 import * as S from "effect/Schema";
 import * as Match from "effect/Match";
+import * as Option from "effect/Option";
 //#region src/ExitClass.schema.ts
 const ExitClass = S.Literals([
 	"VerdictFail",
@@ -25,42 +26,30 @@ const EXIT_CODE = {
 	RuntimeError: 3,
 	InternalError: 4
 };
-function verdictExitClass(score, breakingThreshold) {
-	if (breakingThreshold === null || score === null) return null;
-	if (score < breakingThreshold) return "VerdictFail";
-	return null;
-}
 function highestExitClass(pending) {
-	let highest = null;
-	for (const exitClass of pending) if (highest === null || EXIT_CODE[exitClass] > EXIT_CODE[highest]) highest = exitClass;
-	return highest;
+	return Array.from(pending).reduce((incumbent, challenger) => Option.match(Option.fromNullishOr(incumbent), {
+		onNone: () => challenger,
+		onSome: (value) => Match.value(EXIT_CODE[value] < EXIT_CODE[challenger]).pipe(Match.when(true, () => challenger), Match.when(false, () => value), Match.exhaustive)
+	}), null);
 }
 function resolveExitCode(pending, signal) {
-	if (signal !== null) return 128 + signal;
-	const highest = highestExitClass(pending);
-	if (highest === null) return 0;
-	return EXIT_CODE[highest];
+	return Option.match(Option.fromNullishOr(signal), {
+		onNone: () => Option.match(Option.fromNullishOr(highestExitClass(pending)), {
+			onNone: () => 0,
+			onSome: (exitClass) => EXIT_CODE[exitClass]
+		}),
+		onSome: (value) => 128 + value
+	});
+}
+function verdictExitClass(score, breakingThreshold) {
+	return Option.getOrNull(Option.zipWith(Option.fromNullishOr(score), Option.fromNullishOr(breakingThreshold), (value, threshold) => Match.value(value < threshold).pipe(Match.when(true, () => "VerdictFail"), Match.when(false, () => null), Match.exhaustive)));
 }
-const deriveVerdict = (score, breakingThreshold) => {
-	if (score === null || breakingThreshold === null) return null;
-	if (score < breakingThreshold) return "VerdictFail";
-	return null;
-};
-const rank = (value) => Match.value(value).pipe(Match.when("InternalError", () => 4), Match.when("RuntimeError", () => 3), Match.when("ConfigError", () => 2), Match.when("VerdictFail", () => 1), Match.exhaustive);
-const withVerdict = (pending, verdict) => {
-	if (verdict === null) return pending;
-	if (pending.includes(verdict)) return pending;
-	return [...pending, verdict];
-};
-const highestOf = (values) => values.reduce((acc, cur) => {
-	if (acc === null) return cur;
-	if (rank(cur) > rank(acc)) return cur;
-	return acc;
-}, null);
 const classifyExit = (command) => {
-	const verdictClass = deriveVerdict(command.score, command.breakingThreshold);
-	const pendingWithVerdict = withVerdict(command.pending, verdictClass);
-	const highestClass = highestOf(pendingWithVerdict);
+	const verdictClass = verdictExitClass(command.score, command.breakingThreshold);
+	const highestClass = highestExitClass(Option.match(Option.fromNullishOr(verdictClass), {
+		onNone: () => command.pending,
+		onSome: (verdict) => Array.from(/* @__PURE__ */ new Set([...command.pending, verdict]))
+	}));
 	return ClassifyExitDecision.make({
 		highestClass,
 		verdictClass

package/dist/Metrics.d.mts

@@ -0,0 +1,7 @@
+import { a as FileResult, p as MutantResult } from "./Report.schema-_buHXdnZ.mjs";
+import { i as MetricsSchema, n as MetricsResult, r as MetricsResultSchema, t as Metrics } from "./Metrics.schema-BaVd6rXs.mjs";
+//#region src/Metrics.d.ts
+declare const countMutants: (mutants: readonly MutantResult[]) => Metrics;
+declare const calculateMetrics: (files: Readonly<Record<string, FileResult>>) => MetricsResult;
+//#endregion
+export { type Metrics, type MetricsResult, MetricsResultSchema, MetricsSchema, calculateMetrics, countMutants };

package/dist/Metrics.mjs

@@ -0,0 +1,79 @@
+import { n as MetricsSchema, t as MetricsResultSchema } from "./Metrics.schema-DZdoc46X.mjs";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Arr from "effect/Array";
+//#region src/Metrics.ts
+const countStatus = (mutants, status) => mutants.filter((mutant) => mutant.status === status).length;
+const percentage = (numerator, denominator) => numerator / denominator * 100;
+/** A percentage whose denominator is zero is not 0%; `emptyDenominator` says what it is instead. */
+const percentOr = (emptyDenominator, numerator, denominator) => Match.value(denominator).pipe(Match.when(0, () => emptyDenominator), Match.orElse(() => percentage(numerator, denominator)));
+const coveredFraction = (totalDetected, totalCovered, totalValid) => Match.value(totalValid).pipe(Match.when(0, () => NaN), Match.orElse(() => percentOr(0, totalDetected, totalCovered)));
+const countMutants = (mutants) => {
+	const pending = countStatus(mutants, "Pending");
+	const killed = countStatus(mutants, "Killed");
+	const timeout = countStatus(mutants, "Timeout");
+	const survived = countStatus(mutants, "Survived");
+	const noCoverage = countStatus(mutants, "NoCoverage");
+	const runtimeErrors = countStatus(mutants, "RuntimeError");
+	const compileErrors = countStatus(mutants, "CompileError");
+	const ignored = countStatus(mutants, "Ignored");
+	const totalDetected = timeout + killed;
+	const totalUndetected = survived + noCoverage;
+	const totalCovered = totalDetected + survived;
+	const totalValid = totalUndetected + totalDetected;
+	const totalInvalid = runtimeErrors + compileErrors;
+	return {
+		pending,
+		killed,
+		timeout,
+		survived,
+		noCoverage,
+		runtimeErrors,
+		compileErrors,
+		ignored,
+		totalDetected,
+		totalUndetected,
+		totalCovered,
+		totalValid,
+		totalInvalid,
+		totalMutants: totalValid + totalInvalid + ignored + pending,
+		mutationScore: percentOr(NaN, totalDetected, totalValid),
+		mutationScoreBasedOnCoveredCode: coveredFraction(totalDetected, totalCovered, totalValid)
+	};
+};
+const segmentOf = (fileName) => {
+	const separator = fileName.indexOf("/");
+	if (separator === -1) return fileName;
+	return fileName.slice(0, separator);
+};
+const groupBySegment = (files) => Object.entries(files).reduce((groups, [fileName, file]) => {
+	const segment = segmentOf(fileName);
+	const group = groups[segment] ?? {};
+	group[fileName] = file;
+	groups[segment] = group;
+	return groups;
+}, {});
+const metricsOf = (files) => countMutants(Object.values(files).flatMap((file) => file.mutants));
+const fileResultOf = (fileName, file) => ({
+	name: fileName,
+	metrics: countMutants(file.mutants),
+	childResults: []
+});
+const nestedGroupResult = (segment, entries) => {
+	const nested = Object.fromEntries(entries.map(([fileName, file]) => [fileName.slice(segment.length + 1), file]));
+	return {
+		name: segment,
+		metrics: metricsOf(nested),
+		childResults: childResultsOf(nested)
+	};
+};
+const soleSegmentFileResult = (segment, entries) => Option.flatMap(Arr.head(entries), ([fileName, file]) => Match.value(fileName === segment && entries.length === 1).pipe(Match.when(true, () => Option.some(fileResultOf(fileName, file))), Match.orElse(() => Option.none())));
+const childResultOf = (segment, entries) => Option.getOrElse(soleSegmentFileResult(segment, entries), () => nestedGroupResult(segment, entries));
+const childResultsOf = (files) => Object.entries(groupBySegment(files)).map(([segment, grouped]) => childResultOf(segment, Object.entries(grouped))).sort((left, right) => left.name.localeCompare(right.name));
+const calculateMetrics = (files) => ({
+	name: "All files",
+	metrics: metricsOf(files),
+	childResults: childResultsOf(files)
+});
+//#endregion
+export { MetricsResultSchema, MetricsSchema, calculateMetrics, countMutants };

package/dist/Metrics.schema-BaVd6rXs.d.mts

@@ -0,0 +1,50 @@
+import * as S from "effect/Schema";
+//#region src/Metrics.schema.d.ts
+declare const MetricsSchema: S.Struct<{
+  readonly pending: S.Finite;
+  readonly killed: S.Finite;
+  readonly timeout: S.Finite;
+  readonly survived: S.Finite;
+  readonly noCoverage: S.Finite;
+  readonly runtimeErrors: S.Finite;
+  readonly compileErrors: S.Finite;
+  readonly ignored: S.Finite;
+  readonly totalDetected: S.Finite;
+  readonly totalUndetected: S.Finite;
+  readonly totalInvalid: S.Finite;
+  readonly totalValid: S.Finite;
+  readonly totalMutants: S.Finite;
+  readonly totalCovered: S.Finite;
+  readonly mutationScore: S.Finite;
+  readonly mutationScoreBasedOnCoveredCode: S.Finite;
+}>;
+type Metrics = typeof MetricsSchema.Type;
+interface MetricsResult {
+  readonly name: string;
+  readonly metrics: Metrics;
+  readonly childResults: readonly MetricsResult[];
+}
+declare const MetricsResultSchema: S.Struct<{
+  readonly name: S.String;
+  readonly metrics: S.Struct<{
+    readonly pending: S.Finite;
+    readonly killed: S.Finite;
+    readonly timeout: S.Finite;
+    readonly survived: S.Finite;
+    readonly noCoverage: S.Finite;
+    readonly runtimeErrors: S.Finite;
+    readonly compileErrors: S.Finite;
+    readonly ignored: S.Finite;
+    readonly totalDetected: S.Finite;
+    readonly totalUndetected: S.Finite;
+    readonly totalInvalid: S.Finite;
+    readonly totalValid: S.Finite;
+    readonly totalMutants: S.Finite;
+    readonly totalCovered: S.Finite;
+    readonly mutationScore: S.Finite;
+    readonly mutationScoreBasedOnCoveredCode: S.Finite;
+  }>;
+  readonly childResults: S.$Array<S.suspend<S.Codec<MetricsResult, MetricsResult, never, never>>>;
+}>;
+//#endregion
+export { MetricsSchema as i, MetricsResult as n, MetricsResultSchema as r, Metrics as t };

package/dist/Metrics.schema-DZdoc46X.mjs

@@ -0,0 +1,27 @@
+import * as S from "effect/Schema";
+//#region src/Metrics.schema.ts
+const MetricsSchema = S.Struct({
+	pending: S.Finite,
+	killed: S.Finite,
+	timeout: S.Finite,
+	survived: S.Finite,
+	noCoverage: S.Finite,
+	runtimeErrors: S.Finite,
+	compileErrors: S.Finite,
+	ignored: S.Finite,
+	totalDetected: S.Finite,
+	totalUndetected: S.Finite,
+	totalInvalid: S.Finite,
+	totalValid: S.Finite,
+	totalMutants: S.Finite,
+	totalCovered: S.Finite,
+	mutationScore: S.Finite,
+	mutationScoreBasedOnCoveredCode: S.Finite
+});
+const MetricsResultSchema = S.Struct({
+	name: S.String,
+	metrics: MetricsSchema,
+	childResults: S.Array(S.suspend(() => MetricsResultSchema))
+}).annotate({ identifier: "MetricsResult" });
+//#endregion
+export { MetricsSchema as n, MetricsResultSchema as t };

package/dist/{Mutant-BPRJTF8f.d.mts → Mutant-Ci25PsWA.d.mts}

@@ -1,6 +1,6 @@
+import { C as Report_schema_d_exports } from "./Report.schema-_buHXdnZ.mjs";
 import * as Context from "effect/Context";
 import * as S from "effect/Schema";
-import * as schema from "mutation-testing-report-schema/api";
 import * as Effect from "effect/Effect";
 //#region src/Mutant.schema.d.ts
 declare const PositionSchema: S.Struct<{
@@ -18,9 +18,9 @@ declare const LocationSchema: S.Struct<{
   }>;
 }>;
 declare const Mutant_base: S.Class<Mutant, S.TaggedStruct<"Mutant", {
-  readonly id: S.String;
-  readonly fileName: S.String;
-  readonly mutatorName: S.String;
+  readonly id: S.NonEmptyString;
+  readonly fileName: S.NonEmptyString;
+  readonly mutatorName: S.NonEmptyString;
   readonly replacement: S.String;
   readonly location: S.Struct<{
     readonly start: S.Struct<{
@@ -272,7 +272,7 @@ declare function testFilesProvided(options: {
   readonly testFiles?: readonly string[];
 }): boolean;
 declare namespace Mutant_d_exports {
-  export { Coverage, CoverageData, CoveragePerTestId, ERROR_CODES, EarlyResultPlan, ErrnoException, FileDescription, FileDescriptions, INSTRUMENTER_CONSTANTS, InstrumenterContext, Location, LocationSchema, Mutant, MutantCoverage, MutantEarlyResultPlan, MutantResult, MutantRunPlan, MutantStatus, MutantTestCoverage, MutantTestPlan, MutateDescription, MutationRange, Position$1 as Position, PositionSchema, RunPlan, TestPlan, causeText, errorToString, isErrnoException, isMutant, normalizeFileName, schema };
+  export { Coverage, CoverageData, CoveragePerTestId, ERROR_CODES, EarlyResultPlan, ErrnoException, FileDescription, FileDescriptions, INSTRUMENTER_CONSTANTS, InstrumenterContext, Location, LocationSchema, Mutant, MutantCoverage, MutantEarlyResultPlan, MutantResult, MutantRunPlan, MutantStatus, MutantTestCoverage, MutantTestPlan, MutateDescription, MutationRange, Position$1 as Position, PositionSchema, RunPlan, TestPlan, causeText, errorToString, isErrnoException, isMutant, normalizeFileName, Report_schema_d_exports as schema };
 }
 type CoverageData = Record<string, number>;
 type CoveragePerTestId = Record<string, CoverageData>;
@@ -348,4 +348,4 @@ type MutantEarlyResultPlan = EarlyResultPlan;
 type MutantTestPlan = TestPlan;
 declare const causeText: (cause: unknown, depth: number) => string | undefined;
 //#endregion
-export { TimeoutMutantRunResult as $, CompleteDryRunResult as A, MutantRunOptions as B, causeText as C, normalizeFileName as D, isMutant as E, ErrorMutantRunResult as F, SuccessTestResult as G, Position as H, FailedTestResult as I, TestRunner as J, SurvivedMutantRunResult as K, KilledMutantRunResult as L, DryRunOptions as M, DryRunResult as N, schema as O, ErrorDryRunResult as P, TimeoutDryRunResult as Q, MutantActivation as R, TestPlan as S, isErrnoException as T, RunOptions as U, MutantRunResult as V, SkippedTestResult as W, TestRunnerService as X, TestRunnerCapabilities as Y, TestRunner_d_exports as Z, MutantTestPlan as _, Mutant as _t, EarlyResultPlan as a, DryRunStatus as at, MutationRange as b, FileDescriptions as c, MutantRunOptionsSchema as ct, MutantCoverage as d, TestResultSchema as dt, testFilesProvided as et, MutantEarlyResultPlan as f, TestRunnerCapabilitiesSchema as ft, MutantTestCoverage as g, LocationSchema as gt, MutantStatus as h, Location as ht, ERROR_CODES as i, DryRunResultSchema as it, CoverageAnalysis as j, BaseTestResult as k, INSTRUMENTER_CONSTANTS as l, MutantRunResultSchema as lt, MutantRunPlan as m, TestStatus as mt, CoverageData as n, CoverageAnalysisSchema as nt, ErrnoException as o, MutantActivationSchema as ot, MutantResult as p, TestRunnerFailed as pt, TestResult as q, CoveragePerTestId as r, DryRunOptionsSchema as rt, FileDescription as s, MutantCoverageSchema as st, Coverage as t, toMutantRunResult as tt, InstrumenterContext as u, MutantRunStatus as ut, Mutant_d_exports as v, Position$1 as vt, errorToString as w, RunPlan as x, MutateDescription as y, PositionSchema as yt, MutantCoverage$1 as z };
+export { testFilesProvided as $, CoverageAnalysis as A, MutantRunResult as B, causeText as C, normalizeFileName as D, isMutant as E, FailedTestResult as F, SurvivedMutantRunResult as G, RunOptions as H, KilledMutantRunResult as I, TestRunnerCapabilities as J, TestResult as K, MutantActivation as L, DryRunResult as M, ErrorDryRunResult as N, BaseTestResult as O, ErrorMutantRunResult as P, TimeoutMutantRunResult as Q, MutantCoverage$1 as R, TestPlan as S, isErrnoException as T, SkippedTestResult as U, Position as V, SuccessTestResult as W, TestRunner_d_exports as X, TestRunnerService as Y, TimeoutDryRunResult as Z, MutantTestPlan as _, Position$1 as _t, EarlyResultPlan as a, MutantActivationSchema as at, MutationRange as b, FileDescriptions as c, MutantRunResultSchema as ct, MutantCoverage as d, TestRunnerCapabilitiesSchema as dt, toMutantRunResult as et, MutantEarlyResultPlan as f, TestRunnerFailed as ft, MutantTestCoverage as g, Mutant as gt, MutantStatus as h, LocationSchema as ht, ERROR_CODES as i, DryRunStatus as it, DryRunOptions as j, CompleteDryRunResult as k, INSTRUMENTER_CONSTANTS as l, MutantRunStatus as lt, MutantRunPlan as m, Location as mt, CoverageData as n, DryRunOptionsSchema as nt, ErrnoException as o, MutantCoverageSchema as ot, MutantResult as p, TestStatus as pt, TestRunner as q, CoveragePerTestId as r, DryRunResultSchema as rt, FileDescription as s, MutantRunOptionsSchema as st, Coverage as t, CoverageAnalysisSchema as tt, InstrumenterContext as u, TestResultSchema as ut, Mutant_d_exports as v, PositionSchema as vt, errorToString as w, RunPlan as x, MutateDescription as y, MutantRunOptions as z };

package/dist/Mutant.d.mts

@@ -1,2 +1,3 @@
-import { C as causeText, D as normalizeFileName, E as isMutant, O as schema, S as TestPlan, T as isErrnoException, _ as MutantTestPlan, _t as Mutant, a as EarlyResultPlan, b as MutationRange, c as FileDescriptions, d as MutantCoverage, f as MutantEarlyResultPlan, g as MutantTestCoverage, gt as LocationSchema, h as MutantStatus, ht as Location, i as ERROR_CODES, l as INSTRUMENTER_CONSTANTS, m as MutantRunPlan, n as CoverageData, o as ErrnoException, p as MutantResult, r as CoveragePerTestId, s as FileDescription, t as Coverage, u as InstrumenterContext, vt as Position, w as errorToString, x as RunPlan, y as MutateDescription, yt as PositionSchema } from "./Mutant-BPRJTF8f.mjs";
-export { Coverage, CoverageData, CoveragePerTestId, ERROR_CODES, EarlyResultPlan, ErrnoException, FileDescription, FileDescriptions, INSTRUMENTER_CONSTANTS, InstrumenterContext, type Location, LocationSchema, Mutant, MutantCoverage, MutantEarlyResultPlan, MutantResult, MutantRunPlan, MutantStatus, MutantTestCoverage, MutantTestPlan, MutateDescription, MutationRange, type Position, PositionSchema, RunPlan, TestPlan, causeText, errorToString, isErrnoException, isMutant, normalizeFileName, schema };
+import { C as causeText, D as normalizeFileName, E as isMutant, S as TestPlan, T as isErrnoException, _ as MutantTestPlan, _t as Position, a as EarlyResultPlan, b as MutationRange, c as FileDescriptions, d as MutantCoverage, f as MutantEarlyResultPlan, g as MutantTestCoverage, gt as Mutant, h as MutantStatus, ht as LocationSchema, i as ERROR_CODES, l as INSTRUMENTER_CONSTANTS, m as MutantRunPlan, mt as Location, n as CoverageData, o as ErrnoException, p as MutantResult, r as CoveragePerTestId, s as FileDescription, t as Coverage, u as InstrumenterContext, vt as PositionSchema, w as errorToString, x as RunPlan, y as MutateDescription } from "./Mutant-Ci25PsWA.mjs";
+import { C as Report_schema_d_exports } from "./Report.schema-_buHXdnZ.mjs";
+export { Coverage, CoverageData, CoveragePerTestId, ERROR_CODES, EarlyResultPlan, ErrnoException, FileDescription, FileDescriptions, INSTRUMENTER_CONSTANTS, InstrumenterContext, type Location, LocationSchema, Mutant, MutantCoverage, MutantEarlyResultPlan, MutantResult, MutantRunPlan, MutantStatus, MutantTestCoverage, MutantTestPlan, MutateDescription, MutationRange, type Position, PositionSchema, RunPlan, TestPlan, causeText, errorToString, isErrnoException, isMutant, normalizeFileName, Report_schema_d_exports as schema };

package/dist/Mutant.mjs

@@ -1,6 +1,9 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { n as Mutant, r as PositionSchema, t as LocationSchema } from "./Mutant.schema-BTWhFTk4.mjs";
-import * as schema from "mutation-testing-report-schema/api";
+import { n as Mutant, r as PositionSchema, t as LocationSchema } from "./Mutant.schema-H3r0ho_R.mjs";
+import { t as Report_schema_exports } from "./Report.mjs";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 //#region src/Mutant.ts
 var Mutant_exports = /* @__PURE__ */ __exportAll({
 	ERROR_CODES: () => ERROR_CODES,
@@ -13,7 +16,7 @@ var Mutant_exports = /* @__PURE__ */ __exportAll({
 	isErrnoException: () => isErrnoException,
 	isMutant: () => isMutant,
 	normalizeFileName: () => normalizeFileName,
-	schema: () => schema
+	schema: () => Report_schema_exports
 });
 const isMutant = (value) => value instanceof Mutant;
 const INSTRUMENTER_CONSTANTS = Object.freeze({
@@ -28,87 +31,60 @@ const INSTRUMENTER_CONSTANTS = Object.freeze({
 function normalizeFileName(fileName) {
 	return fileName.replace(/\\/g, "/");
 }
+const hasText = (value) => Predicate.isString(value) && value.length > 0;
+const textIfNonEmpty = (value) => Option.getOrUndefined(Option.filter(Option.fromUndefinedOr(value), hasText));
+const fieldOf = (value, key) => Match.value(key in value).pipe(Match.when(true, () => {
+	return Reflect.get(value, key);
+}), Match.orElse(() => void 0));
+const hasStringCode = (error) => Match.value(fieldOf(error, "code")).pipe(Match.when(Match.string, () => true), Match.orElse(() => false));
 function isErrnoException(error) {
-	if (!(error instanceof Error)) return false;
-	if (!("code" in error)) return false;
-	return typeof Reflect.get(error, "code") === "string";
+	return Match.value(error).pipe(Match.when(Match.instanceOf(Error), hasStringCode), Match.orElse(() => false));
 }
-const isEmptyError = (error) => {
-	if (error === void 0 || error === null) return true;
-	if (typeof error === "string" && error.length === 0) return true;
-	if (error === 0 || error === false) return true;
-	if (typeof error === "number" && Number.isNaN(error)) return true;
-	return false;
-};
-const formatErrnoException = (error) => {
-	const stack = error.stack;
-	if (stack !== void 0 && stack.length > 0) return `${error.name}: ${error.code} (${error.syscall}) ${stack}`;
-	return `${error.name}: ${error.code} (${error.syscall})`;
-};
-const formatError = (error) => {
-	const message = `${error.name}: ${error.message}`;
-	if (error.stack !== void 0 && error.stack.length > 0) return `${message}\n${error.stack.toString()}`;
-	return message;
-};
-const stringifyNonError = (error) => {
-	if (typeof error === "string") return error;
-	if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") return JSON.stringify(error);
+const isEmptyNumber = (value) => Match.value(value).pipe(Match.when(0, () => true), Match.orElse(Number.isNaN));
+const isEmptyError = (error) => Match.value(error).pipe(Match.when(Match.undefined, () => true), Match.when(Match.null, () => true), Match.when(Match.string, (text) => text.length === 0), Match.when(Match.number, isEmptyNumber), Match.when(Match.boolean, (value) => !value), Match.orElse(() => false));
+const formatErrnoException = (error) => Match.value(error.stack).pipe(Match.when(hasText, (stack) => `${error.name}: ${error.code} (${error.syscall}) ${stack}`), Match.orElse(() => `${error.name}: ${error.code} (${error.syscall})`));
+const formatError = (error) => Match.value(error.stack).pipe(Match.when(hasText, (stack) => `${error.name}: ${error.message}\n${stack}`), Match.orElse(() => `${error.name}: ${error.message}`));
+const isJsonPrimitive = (value) => Match.value(value).pipe(Match.when(Match.number, () => true), Match.when(Match.boolean, () => true), Match.when(Match.bigint, () => true), Match.orElse(() => false));
+const jsonText = (error) => {
 	try {
-		const json = JSON.stringify(error);
-		if (typeof json === "string" && json.length > 0) return json;
-	} catch {}
-	if (typeof error === "object" && error !== null && "toString" in error) {
-		const toStringValue = Reflect.get(error, "toString");
-		if (typeof toStringValue === "function") try {
-			const text = Reflect.apply(toStringValue, error, []);
-			if (typeof text === "string" && text.length > 0 && text !== "[object Object]") return text;
-		} catch {}
+		return textIfNonEmpty(JSON.stringify(error));
+	} catch {
+		return;
 	}
-	return "";
 };
-function errorToString(error) {
-	if (isEmptyError(error)) return "";
-	if (error instanceof Error) {
-		if (isErrnoException(error)) return formatErrnoException(error);
-		return formatError(error);
+const isNonPlaceholderText = (text) => Match.value({
+	hasLength: text.length > 0,
+	isPlaceholder: text === "[object Object]"
+}).pipe(Match.when({
+	hasLength: true,
+	isPlaceholder: false
+}, () => true), Match.orElse(() => false));
+const isUsableText = (value) => Match.value(value).pipe(Match.when(Match.string, isNonPlaceholderText), Match.orElse(() => false));
+const usableText = (value) => Match.value(value).pipe(Match.when(isUsableText, (text) => text), Match.orElse(() => ""));
+const objectToStringText = (value) => Match.value(fieldOf(value, "toString")).pipe(Match.when(Match.instanceOf(Function), (callable) => {
+	try {
+		return usableText(Reflect.apply(callable, value, []));
+	} catch {
+		return "";
 	}
-	return stringifyNonError(error);
+}), Match.orElse(() => ""));
+const isObjectType = (cause) => typeof cause === "object";
+const toStringText = (error) => Match.value(error).pipe(Match.when(Match.null, () => ""), Match.when(isObjectType, (value) => objectToStringText(value)), Match.orElse(() => ""));
+const stringifyRest = (error) => Match.value(jsonText(error)).pipe(Match.when(hasText, (json) => json), Match.orElse(() => toStringText(error)));
+const stringifyNonError = (error) => Match.value(error).pipe(Match.when(Match.string, (text) => text), Match.when(isJsonPrimitive, (primitive) => JSON.stringify(primitive)), Match.orElse(() => stringifyRest(error)));
+const errorText = (error) => Match.value(error).pipe(Match.when(isErrnoException, formatErrnoException), Match.orElse(() => formatError(error)));
+function errorToString(error) {
+	return Match.value(error).pipe(Match.when(isEmptyError, () => ""), Match.when(Match.instanceOf(Error), errorText), Match.orElse(() => stringifyNonError(error)));
 }
 const ERROR_CODES = Object.freeze({ NoSuchFileOrDirectory: "ENOENT" });
-const stringField = (value, key) => {
-	if (!(key in value)) return;
-	const field = Reflect.get(value, key);
-	if (typeof field === "string" && field.length > 0) return field;
-};
-const tagOf = (value) => {
-	let tag;
-	if ("_tag" in value) tag = Reflect.get(value, "_tag");
-	else tag = void 0;
-	if (typeof tag === "string" && tag.length > 0) return tag;
-	if (value instanceof Error && value.name.length > 0) return value.name;
-};
-const causeText = (cause, depth) => {
-	if (depth > 4 || cause === void 0 || cause === null) return;
-	if (typeof cause === "string") {
-		if (cause.length > 0) return cause;
-		return;
-	}
-	if (typeof cause !== "object") return;
-	let own;
-	const reason = stringField(cause, "reason");
-	if (reason !== void 0) own = reason;
-	else {
-		const message = stringField(cause, "message");
-		if (message !== void 0) own = message;
-		else if (cause instanceof Error && cause.message.length > 0) own = cause.message;
-		else own = tagOf(cause);
-	}
-	let nested;
-	if ("cause" in cause) nested = causeText(Reflect.get(cause, "cause"), depth + 1);
-	else nested = void 0;
-	if (own === void 0) return nested;
-	if (nested === void 0) return own;
-	return `${own}: ${nested}`;
-};
+const errorNameOf = (value) => Match.value(value).pipe(Match.when(Match.instanceOf(Error), (error) => textIfNonEmpty(error.name)), Match.orElse(() => void 0));
+const tagOf = (value) => Match.value(textIfNonEmpty(fieldOf(value, "_tag"))).pipe(Match.when(hasText, (tag) => tag), Match.orElse(() => errorNameOf(value)));
+const textWithNested = (own, nested) => Match.value(own).pipe(Match.when(hasText, (text) => appendNested(text, nested)), Match.orElse(() => nested));
+const appendNested = (own, nested) => Match.value(nested).pipe(Match.when(hasText, (text) => `${own}: ${text}`), Match.orElse(() => own));
+const errorMessage = (error) => Match.value(error.message.length > 0).pipe(Match.when(true, () => error.message), Match.orElse(() => tagOf(error)));
+const errorMessageOrTag = (value) => Match.value(value).pipe(Match.when(Match.instanceOf(Error), errorMessage), Match.orElse(() => tagOf(value)));
+const messageText = (value) => Match.value(textIfNonEmpty(fieldOf(value, "message"))).pipe(Match.when(hasText, (message) => message), Match.orElse(() => errorMessageOrTag(value)));
+const ownCauseText = (value) => Match.value(textIfNonEmpty(fieldOf(value, "reason"))).pipe(Match.when(hasText, (reason) => reason), Match.orElse(() => messageText(value)));
+const causeText = (cause, depth) => Match.value(cause).pipe(Match.when(() => depth > 4, () => void 0), Match.when(Match.undefined, () => void 0), Match.when(Match.null, () => void 0), Match.when(Match.string, textIfNonEmpty), Match.when(isObjectType, (value) => textWithNested(ownCauseText(value), causeText(fieldOf(value, "cause"), depth + 1))), Match.orElse(() => void 0));
 //#endregion
-export { ERROR_CODES, INSTRUMENTER_CONSTANTS, LocationSchema, Mutant, PositionSchema, causeText, errorToString, isErrnoException, isMutant, normalizeFileName, schema, Mutant_exports as t };
+export { ERROR_CODES, INSTRUMENTER_CONSTANTS, LocationSchema, Mutant, PositionSchema, causeText, errorToString, isErrnoException, isMutant, normalizeFileName, Report_schema_exports as schema, Mutant_exports as t };

package/dist/{Mutant.schema-BTWhFTk4.mjs → Mutant.schema-H3r0ho_R.mjs}

@@ -9,9 +9,9 @@ const LocationSchema = S.Struct({
 	end: PositionSchema
 });
 var Mutant = class extends S.TaggedClass()("Mutant", {
-	id: S.String,
-	fileName: S.String,
-	mutatorName: S.String,
+	id: S.NonEmptyString,
+	fileName: S.NonEmptyString,
+	mutatorName: S.NonEmptyString,
 	replacement: S.String,
 	location: LocationSchema,
 	status: S.optional(S.Literals([