@systemfsoftware/stryker-js 1.0.0 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,169 @@
 # @systemfsoftware/stryker-js
 
+## 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
+
+- The packages are renamed. `plugin-api` is now `@systemfsoftware/stryker-js`, the
+  language every plugin is written against. `mutation-run` is split: the run
+  itself is `@systemfsoftware/stryker-js-engine`
+  (host-neutral, no Node on its manifest) and the Node process entries are
+  `@systemfsoftware/stryker-js-cli`, which owns the worker files and the runtime
+  gate. `mutation-report` is now `@systemfsoftware/stryker-js-html-reporter`.
+  `@systemfsoftware/stryker-js-platform-node` is never published — do not install
+  it. Install the new names and change your imports.
+
+  Options types moved. `StrykerOptions`, `PartialStrykerOptions` and `LogLevel` are
+  imported from the `Schema` export; `Mutant`, `MutantStatus`, `Position` and
+  `Location` from the `Mutant` export. Point a config's `extends` at the language
+  package's `Schema` export.
+
+  `MutantStatus` accepts one spelling per outcome: `Killed`, `Survived`,
+  `NoCoverage`, `Timeout`, `CompileError`, `RuntimeError`, `Ignored` and `Pending`.
+  The lowercase and abbreviated forms — `killed`, `timedOut`, `noCoverage` and the
+  rest — are gone. A comparison against a removed spelling never matched the value
+  the reporter actually produced, so check any status comparison you wrote.
+
+  Statuses, plugin kinds, exit classes and AST formats are string literal unions
+  rather than enums, so read them as their string values. Member access such as
+  `ExitClass.VerdictFail` no longer resolves.
+
+  A plugin no longer receives a logger, and the logger port is gone. Plugins log
+  through Effect, and the host decides where that output goes.
+
+  The bundled base preset is gone. A config inherits from the language package's
+  `Schema` export and states the thresholds, reporters and plugins it wants; you no
+  longer silently inherit a package manager, a plugin list or a break threshold.
+
+- An evaluator now answers with the verdict it reached instead of failing to
+  report one.
+
+  `Evaluator.evaluate` returns `ExitClass | null` on the success channel: the
+  class the run should end in, or `null` for nothing to report. `ExitClass` is
+  exported from `@systemfsoftware/stryker-js/evaluate`. The error
+  channel is for the evaluator itself breaking — a report it cannot read, a
+  decision it cannot reach.
+
+  Previously the only way to report a failed gate was to fail, which a caller
+  could not tell apart from the evaluator crashing, so neither the exit code nor
+  the message could distinguish them. If you wrote an evaluator that failed to
+  signal a verdict, return the class instead.
+
+  A run's verdict is now the most severe class anyone reported — the score against
+  your `break` threshold, plus every evaluator's answer.
+
+- Plugins are written against Effect instead of Promise.
+
+  `Checker`, `TestRunner`, `Reporter`, `Ignorer` and `Evaluator` are capability services whose operations return an `Effect`. Provide your plugin as a `Layer` through `declarePlugin`; the class, factory and value declarations are gone, along with the `typed-inject` dependency. Implement the operations that were optional — return `Effect.void` where there is nothing to do, and one group per mutant from `group` if you have no grouping opinion.
+
+  Each capability fails with a tagged error. Outcomes are not failures: a killed mutant, a survivor and a compile error in the code under test are successful results.
+
+  Read the sandbox path from `SandboxDirectory`. `commonTokens`, `tokens` and the plugin context types are removed. `determineHitLimitReached` returns an `Option`.
+
+### Minor Changes
+
+- `RENDERED_OPTION_DEFAULTS` is exported from the `core` entry point. It carries
+  the four option defaults that appear in human-readable help text, so a tool
+  printing "the default is X" reads the same value the option schema applies
+  instead of restating it.
+
+- The shared helpers package is gone. Nothing installs it any more, and the
+  handful of helpers worth sharing now live in the plugin contract next to the
+  types they serve:
+
+  - `strykerReportBugUrl`, `normalizeFileName`, `propertyPath`, `errorToString`
+    and `isErrnoException` from `@systemfsoftware/stryker-js/core`
+  - `noopLogger` from `@systemfsoftware/stryker-js/logging`
+  - `testFilesProvided` from `@systemfsoftware/stryker-js/test-runner`
+
+  If you imported any of those, change the specifier. Everything else it exported
+  had no consumer and is removed: use `Predicate.isNotNullish` from Effect in place
+  of `notEmpty`, and `RegExp.escape` in place of `escapeRegExp`.
+
+- Checker and test-runner workers now talk over Effect's own worker RPC, and every
+  call they exchange is a declared operation with a declared result.
+
+  Before, the parent and its workers spoke a protocol written by hand: messages were
+  newline-delimited JSON, arguments were typed as "any JSON value", and each method
+  was reached by name through a proxy. Nothing checked that a payload was one the far
+  end could serve, so a value it could not read was refused after it arrived, and a
+  call whose message never landed was waited on anyway.
+
+  The six operations that cross that boundary — a checker's `check` and `group`, a
+  runner's `capabilities`, `dryRun` and `mutantRun` — now each name what they take
+  and what they return, and the options a worker starts from are sent once when it
+  starts rather than as a first method call. A payload that does not fit is refused
+  where it is built, and a worker that cannot answer fails the call that was waiting.
+
+  The two worker entry points are no longer importable subpaths of this package.
+  They were only ever spawned as processes, and the paths resolved to TypeScript
+  sources that could not be executed.
+
+### Patch Changes
+
+- A mutation run that is killed mid-way keeps every completed mutant: the JSONL progress stream is flushed after each result, and incremental mode writes remembered verdicts as they finish so the next run continues instead of starting over.
+
+  Remembered killed mutants still name the tests that killed them, so a resumed run's report matches a complete run.
+
+  The progress stream path is progressStreamFile (default reports/mutation-stream.jsonl) and can be set in config or with --progressStreamFile.
+
+- New version is published through npm trusted publishing, so it carries a provenance attestation you can verify.
+
+- Peer Effect requirement advances to 4.0.0-rc.112. No API changes.
+
+- An oversized message between the runner and a worker now fails the run with a
+  reason instead of exhausting memory. Each side of the connection reads frames
+  up to 16 MiB, which leaves headroom over the largest legitimate payload — a dry
+  run carrying per-test coverage — and a frame past the limit fails the calls
+  waiting on it rather than growing until the process dies.
+
+- Each of these packages now has a README, so its registry page says what the package is, how
+  to install it, and what to import or register — previously the page was blank. The lint
+  plugins show the configuration line that enables what they recommend.
+
+  `@systemfsoftware/stryker-js-html-reporter` also carries its licence text
+
+- These packages no longer install dependencies they never imported, so installing them pulls less into your tree.
+
+  `tslib` is gone from all six. The mutation runner additionally stops installing `lodash.groupby`, `semver` and `source-map`, and the command line interface stops installing `@effect/platform-node-shared`. Nothing exported changes.
+
+- Published packages no longer carry build artifacts left over from earlier builds. One package was shipping about a megabyte of bundled test-runner internals this way.
+
+- The closing verdict line carries its findings again. It had shrunk to the score alone, so a consumer reading the stream could no longer see the score limits the run was held to, where the report was written, or which mutants survived — the survivors were reported while the run was in flight and then absent from the summary that closes it.
+
+  The verdict now states the thresholds, the report path, and every surviving mutant with its file, position, mutator and replacement.
+
 ## 1.0.0
 
 ### Major Changes

package/README.md

@@ -29,4 +29,4 @@ Each concept module is an enumerated specifier:
 
 ## License
 
-Apache-2.0. Part of [systemfsoftware](https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/testing/mutation/stryker-js/stryker-js#readme).
+Apache-2.0. Part of [systemfsoftware](https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/stryker-js/stryker-js#readme).

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 };