@systemfsoftware/stryker-js 2.0.0 → 3.0.0

package/dist/{Plugin-DcDAIBQi.d.mts → Plugin-CunIOPtw.d.mts}

@@ -1,28 +1,41 @@
-import { n as Checker } from "./Checker-DYgIIEai.mjs";
-import { J as TestRunner } from "./Mutant-BPRJTF8f.mjs";
-import { t as Evaluator } from "./Evaluator-RZBS4oeh.mjs";
+import { n as Checker } from "./Checker-A8o5B3Ub.mjs";
+import { q as TestRunner } from "./Mutant-Ci25PsWA.mjs";
+import { t as Evaluator } from "./Evaluator-CnAN8-pZ.mjs";
 import { t as Ignorer } from "./Ignorer-BUY68FZQ.mjs";
 import { t as Module } from "./Module-DHKEMAFI.mjs";
-import { c as Reporter } from "./Reporter-eZ3M7lO6.mjs";
+import { l as ReporterFactory } from "./ReporterEvent.schema-Db6r_euv.mjs";
 import * as Context from "effect/Context";
 import * as S from "effect/Schema";
-import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
+import * as Layer from "effect/Layer";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 //#region src/Plugin.schema.d.ts
 declare const PluginKind: S.Literals<readonly ["Checker", "TestRunner", "Reporter", "Ignore", "Evaluator"]>;
 type PluginKind = typeof PluginKind.Type;
-declare const PluginContribution_base: S.Class<PluginContribution<"Checker" | "Evaluator" | "Ignore" | "Reporter" | "TestRunner">, S.TaggedStruct<"PluginContribution", {
-  readonly kind: S.Literals<readonly ["Checker", "TestRunner", "Reporter", "Ignore", "Evaluator"]>;
+declare const PluginLayerKind: S.Literals<readonly ["Checker", "TestRunner", "Ignore", "Evaluator"]>;
+type PluginLayerKind = typeof PluginLayerKind.Type;
+declare const PluginLayerContribution_base: S.Class<PluginLayerContribution<"Checker" | "Evaluator" | "Ignore" | "TestRunner">, S.TaggedStruct<"PluginContribution", {
+  readonly kind: S.Literals<readonly ["Checker", "TestRunner", "Ignore", "Evaluator"]>;
   readonly name: S.String;
   readonly layer: S.Unknown;
 }>, {}>;
-declare class PluginContribution<K extends PluginKind = PluginKind> extends PluginContribution_base {
+declare class PluginLayerContribution<K extends PluginLayerKind = PluginLayerKind> extends PluginLayerContribution_base {
   readonly kind: K;
   readonly name: string;
   readonly layer: Layer.Layer<PluginInterfaces[K], never, PluginEnvironment>;
 }
+declare const PluginReporterContribution_base: S.Class<PluginReporterContribution, S.TaggedStruct<"PluginContribution", {
+  readonly kind: S.Literals<readonly ["Checker", "TestRunner", "Reporter", "Ignore", "Evaluator"]>;
+  readonly name: S.String;
+  readonly make: S.Unknown;
+}>, {}>;
+declare class PluginReporterContribution extends PluginReporterContribution_base {
+  readonly kind: 'Reporter';
+  readonly name: string;
+  readonly make: ReporterFactory;
+}
+type PluginContribution<K extends PluginKind = PluginKind> = K extends 'Reporter' ? PluginReporterContribution : PluginLayerContribution<Extract<K, PluginLayerKind>>;
 declare const Shadowing_base: S.Class<Shadowing, S.TaggedStruct<"Shadowing", {
   readonly kind: S.String;
   readonly name: S.String;
@@ -31,7 +44,7 @@ declare const Shadowing_base: S.Class<Shadowing, S.TaggedStruct<"Shadowing", {
 }>, {}>;
 declare class Shadowing extends Shadowing_base {}
 declare namespace Plugin_d_exports {
-  export { AnyPluginContribution, ComposedPlugins, ContributionOf, MergedPluginServices, PluginContribution, PluginEnvironment, PluginInterfaces, PluginKind, RunConfiguration, SandboxDirectory, Shadowing, composePlugins, declarePlugin };
+  export { AnyPluginContribution, ComposedPlugins, ContributionOf, MergedPluginServices, PluginContribution, PluginEnvironment, PluginInterfaces, PluginKind, PluginLayerContribution, PluginLayerKind, PluginReporterContribution, RunConfiguration, SandboxDirectory, SelectedReporterFactory, Shadowing, composePlugins, declarePlugin };
 }
 declare const RunConfiguration_base: Context.ServiceClass<RunConfiguration, "~@systemfsoftware/stryker-js/RunConfiguration", {
   readonly [x: string]: unknown;
@@ -115,7 +128,6 @@ declare class SandboxDirectory extends SandboxDirectory_base {}
 interface PluginInterfaces {
   Checker: Checker;
   TestRunner: TestRunner;
-  Reporter: Reporter;
   Ignore: Ignorer;
   Evaluator: Evaluator;
 }
@@ -124,12 +136,18 @@ type AnyPluginContribution = { [K in PluginKind]: PluginContribution<K>; }[Plugi
 type ContributionOf<K extends PluginKind> = Extract<AnyPluginContribution, {
   readonly kind: K;
 }>;
-declare function declarePlugin<K extends PluginKind>(kind: K, name: string, layer: Layer.Layer<PluginInterfaces[K], never, PluginEnvironment>): PluginContribution<K>;
-type MergedPluginServices = Checker & Ignorer & Reporter & TestRunner;
+declare function declarePlugin(kind: 'Reporter', name: string, make: ReporterFactory): PluginContribution<'Reporter'>;
+declare function declarePlugin<K extends PluginLayerKind>(kind: K, name: string, layer: Layer.Layer<PluginInterfaces[K], never, PluginEnvironment>): PluginContribution<K>;
+type MergedPluginServices = Checker & Ignorer & TestRunner;
+interface SelectedReporterFactory {
+  readonly name: string;
+  readonly make: ReporterFactory;
+}
 interface ComposedPlugins {
   readonly layer: Option.Option<Layer.Layer<MergedPluginServices, never, PluginEnvironment>>;
+  readonly reporterFactories: readonly SelectedReporterFactory[];
   readonly shadowings: readonly Shadowing[];
 }
 declare function composePlugins(contributions: readonly AnyPluginContribution[]): ComposedPlugins;
 //#endregion
-export { PluginEnvironment as a, RunConfiguration as c, declarePlugin as d, PluginContribution as f, MergedPluginServices as i, SandboxDirectory as l, Shadowing as m, ComposedPlugins as n, PluginInterfaces as o, PluginKind as p, ContributionOf as r, Plugin_d_exports as s, AnyPluginContribution as t, composePlugins as u };
+export { PluginReporterContribution as _, PluginEnvironment as a, RunConfiguration as c, composePlugins as d, declarePlugin as f, PluginLayerKind as g, PluginLayerContribution as h, MergedPluginServices as i, SandboxDirectory as l, PluginKind as m, ComposedPlugins as n, PluginInterfaces as o, PluginContribution as p, ContributionOf as r, Plugin_d_exports as s, AnyPluginContribution as t, SelectedReporterFactory as u, Shadowing as v };

package/dist/Plugin-DXFdJP1l.mjs

@@ -0,0 +1,105 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import * as Context from "effect/Context";
+import * as S from "effect/Schema";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Layer from "effect/Layer";
+import * as MutableHashMap from "effect/MutableHashMap";
+//#region src/Plugin.schema.ts
+const PluginKind = S.Literals([
+	"Checker",
+	"TestRunner",
+	"Reporter",
+	"Ignore",
+	"Evaluator"
+]);
+const PluginLayerKind = S.Literals([
+	"Checker",
+	"TestRunner",
+	"Ignore",
+	"Evaluator"
+]);
+var PluginLayerContribution = class extends S.TaggedClass()("PluginContribution", {
+	kind: PluginLayerKind,
+	name: S.String,
+	layer: S.Unknown
+}) {};
+var PluginReporterContribution = class extends S.TaggedClass()("PluginContribution", {
+	kind: PluginKind,
+	name: S.String,
+	make: S.Unknown
+}) {};
+var Shadowing = class extends S.TaggedClass()("Shadowing", {
+	kind: S.String,
+	name: S.String,
+	shadowedIndex: S.Finite,
+	winnerIndex: S.Finite
+}) {};
+//#endregion
+//#region src/Plugin.ts
+var Plugin_exports = /* @__PURE__ */ __exportAll({
+	PluginKind: () => PluginKind,
+	PluginLayerContribution: () => PluginLayerContribution,
+	PluginReporterContribution: () => PluginReporterContribution,
+	RunConfiguration: () => RunConfiguration,
+	SandboxDirectory: () => SandboxDirectory,
+	Shadowing: () => Shadowing,
+	composePlugins: () => composePlugins,
+	declarePlugin: () => declarePlugin
+});
+var RunConfiguration = class extends Context.Service()("~@systemfsoftware/stryker-js/RunConfiguration") {};
+var SandboxDirectory = class extends Context.Service()("~@systemfsoftware/stryker-js/SandboxDirectory") {};
+function declarePlugin(kind, name, payload) {
+	if (kind === "Reporter") return new PluginReporterContribution({
+		kind,
+		name,
+		make: payload
+	});
+	return new PluginLayerContribution({
+		kind,
+		name,
+		layer: payload
+	});
+}
+function foldContributions(contributions) {
+	const resolved = MutableHashMap.empty();
+	const shadowings = [];
+	const lastSeen = MutableHashMap.empty();
+	for (const [index, contribution] of contributions.entries()) {
+		const key = `${contribution.kind}:${contribution.name}`;
+		const previous = MutableHashMap.get(lastSeen, key);
+		shadowings.push(...Option.match(previous, {
+			onNone: () => [],
+			onSome: (shadowedIndex) => [new Shadowing({
+				kind: String(contribution.kind),
+				name: contribution.name,
+				shadowedIndex,
+				winnerIndex: index
+			})]
+		}));
+		MutableHashMap.set(resolved, key, contribution);
+		MutableHashMap.set(lastSeen, key, index);
+	}
+	return {
+		resolved,
+		shadowings
+	};
+}
+const reporterFactoryOf = (contribution) => Match.value(contribution).pipe(Match.discriminator("kind")("Reporter", (reporter) => [{
+	name: reporter.name,
+	make: reporter.make
+}]), Match.orElse(() => []));
+const layerOf = (contribution) => Match.value(contribution).pipe(Match.discriminator("kind")("Reporter", () => []), Match.orElse((nonReporter) => [nonReporter.layer]));
+const mergedLayer = (layers) => layers.reduce((accumulated, next) => Layer.merge(accumulated, next));
+function composePlugins(contributions) {
+	const { resolved, shadowings } = foldContributions(contributions);
+	const allResolved = Array.from(MutableHashMap.values(resolved));
+	const layers = allResolved.flatMap(layerOf);
+	return {
+		layer: Option.map(Option.fromUndefinedOr(layers.at(0)), () => mergedLayer(layers)),
+		reporterFactories: allResolved.flatMap(reporterFactoryOf),
+		shadowings
+	};
+}
+//#endregion
+export { declarePlugin as a, PluginReporterContribution as c, composePlugins as i, Shadowing as l, RunConfiguration as n, PluginKind as o, SandboxDirectory as r, PluginLayerContribution as s, Plugin_exports as t };

package/dist/Plugin.d.mts

@@ -1,2 +1,2 @@
-import { a as PluginEnvironment, c as RunConfiguration, d as declarePlugin, f as PluginContribution, i as MergedPluginServices, l as SandboxDirectory, m as Shadowing, n as ComposedPlugins, o as PluginInterfaces, p as PluginKind, r as ContributionOf, t as AnyPluginContribution, u as composePlugins } from "./Plugin-DcDAIBQi.mjs";
-export { AnyPluginContribution, ComposedPlugins, ContributionOf, MergedPluginServices, PluginContribution, PluginEnvironment, PluginInterfaces, PluginKind, RunConfiguration, SandboxDirectory, Shadowing, composePlugins, declarePlugin };
+import { _ as PluginReporterContribution, a as PluginEnvironment, c as RunConfiguration, d as composePlugins, f as declarePlugin, g as PluginLayerKind, h as PluginLayerContribution, i as MergedPluginServices, l as SandboxDirectory, m as PluginKind, n as ComposedPlugins, o as PluginInterfaces, p as PluginContribution, r as ContributionOf, t as AnyPluginContribution, u as SelectedReporterFactory, v as Shadowing } from "./Plugin-CunIOPtw.mjs";
+export { AnyPluginContribution, ComposedPlugins, ContributionOf, MergedPluginServices, type PluginContribution, PluginEnvironment, PluginInterfaces, PluginKind, PluginLayerContribution, type PluginLayerKind, PluginReporterContribution, RunConfiguration, SandboxDirectory, SelectedReporterFactory, Shadowing, composePlugins, declarePlugin };

package/dist/Plugin.mjs

@@ -1,2 +1,2 @@
-import { a as declarePlugin, c as Shadowing, i as composePlugins, n as RunConfiguration, o as PluginContribution, r as SandboxDirectory, s as PluginKind } from "./Plugin-Ceh1G8Dz.mjs";
-export { PluginContribution, PluginKind, RunConfiguration, SandboxDirectory, Shadowing, composePlugins, declarePlugin };
+import { a as declarePlugin, c as PluginReporterContribution, i as composePlugins, l as Shadowing, n as RunConfiguration, o as PluginKind, r as SandboxDirectory, s as PluginLayerContribution } from "./Plugin-DXFdJP1l.mjs";
+export { PluginKind, PluginLayerContribution, PluginReporterContribution, RunConfiguration, SandboxDirectory, Shadowing, composePlugins, declarePlugin };

package/dist/Report.d.mts

@@ -0,0 +1,2 @@
+import { A as Thresholds, D as TestFileDefinitionDictionary, E as TestFile, O as TestFileDefinitionDictionarySchema, S as PositionSchema, T as TestDefinitionSchema, _ as MutationTestResult, a as FileResult, b as OpenEndLocationSchema, c as FileResultSchema, d as Location, f as LocationSchema, g as MutantStatusSchema, h as MutantStatus, i as DependenciesSchema, j as ThresholdsSchema, k as TestFileSchema, l as FrameworkInformation, m as MutantResultSchema, n as BrandingInformationSchema, o as FileResultDictionary, p as MutantResult, r as Dependencies, s as FileResultDictionarySchema, t as BrandingInformation, u as FrameworkInformationSchema, v as MutationTestResultSchema, w as TestDefinition, x as Position, y as OpenEndLocation } from "./Report.schema-_buHXdnZ.mjs";
+export { BrandingInformation, BrandingInformationSchema, Dependencies, DependenciesSchema, FileResult, FileResultDictionary, FileResultDictionarySchema, FileResultSchema, FrameworkInformation, FrameworkInformationSchema, Location, LocationSchema, MutantResult, MutantResultSchema, MutantStatus, MutantStatusSchema, MutationTestResult, MutationTestResultSchema, OpenEndLocation, OpenEndLocationSchema, Position, PositionSchema, TestDefinition, TestDefinitionSchema, TestFile, TestFileDefinitionDictionary, TestFileDefinitionDictionarySchema, TestFileSchema, Thresholds, ThresholdsSchema };

package/dist/Report.mjs

@@ -0,0 +1,98 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import * as S from "effect/Schema";
+//#region src/Report.schema.ts
+var Report_schema_exports = /* @__PURE__ */ __exportAll({
+	BrandingInformationSchema: () => BrandingInformationSchema,
+	DependenciesSchema: () => DependenciesSchema,
+	FileResultDictionarySchema: () => FileResultDictionarySchema,
+	FileResultSchema: () => FileResultSchema,
+	FrameworkInformationSchema: () => FrameworkInformationSchema,
+	LocationSchema: () => LocationSchema,
+	MutantResultSchema: () => MutantResultSchema,
+	MutantStatusSchema: () => MutantStatusSchema,
+	MutationTestResultSchema: () => MutationTestResultSchema,
+	OpenEndLocationSchema: () => OpenEndLocationSchema,
+	PositionSchema: () => PositionSchema,
+	TestDefinitionSchema: () => TestDefinitionSchema,
+	TestFileDefinitionDictionarySchema: () => TestFileDefinitionDictionarySchema,
+	TestFileSchema: () => TestFileSchema,
+	ThresholdsSchema: () => ThresholdsSchema
+});
+const PositionSchema = S.Struct({
+	line: S.Finite,
+	column: S.Finite
+});
+const LocationSchema = S.Struct({
+	start: PositionSchema,
+	end: PositionSchema
+});
+const OpenEndLocationSchema = S.Struct({
+	start: PositionSchema,
+	end: S.optional(PositionSchema)
+});
+const MutantStatusSchema = S.Literals([
+	"Killed",
+	"Survived",
+	"NoCoverage",
+	"CompileError",
+	"RuntimeError",
+	"Timeout",
+	"Ignored",
+	"Pending"
+]);
+const MutantResultSchema = S.Struct({
+	id: S.String,
+	mutatorName: S.String,
+	status: MutantStatusSchema,
+	location: LocationSchema,
+	replacement: S.optional(S.String),
+	description: S.optional(S.String),
+	statusReason: S.optional(S.String),
+	static: S.optional(S.Boolean),
+	coveredBy: S.optional(S.Array(S.String)),
+	killedBy: S.optional(S.Array(S.String)),
+	testsCompleted: S.optional(S.Finite),
+	duration: S.optional(S.Finite)
+});
+const FileResultSchema = S.Struct({
+	language: S.String,
+	source: S.String,
+	mutants: S.Array(MutantResultSchema)
+});
+const FileResultDictionarySchema = S.Record(S.String, FileResultSchema);
+const TestDefinitionSchema = S.Struct({
+	id: S.String,
+	name: S.String,
+	location: S.optional(OpenEndLocationSchema)
+});
+const TestFileSchema = S.Struct({
+	source: S.optional(S.String),
+	tests: S.Array(TestDefinitionSchema)
+});
+const TestFileDefinitionDictionarySchema = S.Record(S.String, TestFileSchema);
+const ThresholdsSchema = S.Struct({
+	high: S.Finite,
+	low: S.Finite
+});
+const BrandingInformationSchema = S.Struct({
+	homepageUrl: S.String,
+	imageUrl: S.optional(S.String)
+});
+const DependenciesSchema = S.Record(S.String, S.String);
+const FrameworkInformationSchema = S.Struct({
+	name: S.String,
+	version: S.optional(S.String),
+	branding: S.optional(BrandingInformationSchema),
+	dependencies: S.optional(DependenciesSchema)
+});
+const MutationTestResultSchema = S.Struct({
+	schemaVersion: S.String,
+	files: FileResultDictionarySchema,
+	thresholds: ThresholdsSchema,
+	config: S.optional(S.Record(S.String, S.Unknown)),
+	testFiles: S.optional(TestFileDefinitionDictionarySchema),
+	projectRoot: S.optional(S.String),
+	framework: S.optional(FrameworkInformationSchema)
+});
+//#endregion
+export { BrandingInformationSchema, DependenciesSchema, FileResultDictionarySchema, FileResultSchema, FrameworkInformationSchema, LocationSchema, MutantResultSchema, MutantStatusSchema, MutationTestResultSchema, OpenEndLocationSchema, PositionSchema, TestDefinitionSchema, TestFileDefinitionDictionarySchema, TestFileSchema, ThresholdsSchema, Report_schema_exports as t };

package/dist/Report.schema-_buHXdnZ.d.mts

@@ -0,0 +1,251 @@
+import * as S from "effect/Schema";
+declare namespace Report_schema_d_exports {
+  export { BrandingInformation, BrandingInformationSchema, Dependencies, DependenciesSchema, FileResult, FileResultDictionary, FileResultDictionarySchema, FileResultSchema, FrameworkInformation, FrameworkInformationSchema, Location, LocationSchema, MutantResult, MutantResultSchema, MutantStatus, MutantStatusSchema, MutationTestResult, MutationTestResultSchema, OpenEndLocation, OpenEndLocationSchema, Position, PositionSchema, TestDefinition, TestDefinitionSchema, TestFile, TestFileDefinitionDictionary, TestFileDefinitionDictionarySchema, TestFileSchema, Thresholds, ThresholdsSchema };
+}
+declare const PositionSchema: S.Struct<{
+  readonly line: S.Finite;
+  readonly column: S.Finite;
+}>;
+type Position = typeof PositionSchema.Type;
+declare const LocationSchema: S.Struct<{
+  readonly start: S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+  }>;
+  readonly end: S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+  }>;
+}>;
+type Location = typeof LocationSchema.Type;
+declare const OpenEndLocationSchema: S.Struct<{
+  readonly start: S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+  }>;
+  readonly end: S.optional<S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+  }>>;
+}>;
+type OpenEndLocation = typeof OpenEndLocationSchema.Type;
+declare const MutantStatusSchema: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+type MutantStatus = typeof MutantStatusSchema.Type;
+declare const MutantResultSchema: S.Struct<{
+  readonly id: S.String;
+  readonly mutatorName: S.String;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+  readonly location: S.Struct<{
+    readonly start: S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>;
+    readonly end: S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>;
+  }>;
+  readonly replacement: S.optional<S.String>;
+  readonly description: S.optional<S.String>;
+  readonly statusReason: S.optional<S.String>;
+  readonly static: S.optional<S.Boolean>;
+  readonly coveredBy: S.optional<S.$Array<S.String>>;
+  readonly killedBy: S.optional<S.$Array<S.String>>;
+  readonly testsCompleted: S.optional<S.Finite>;
+  readonly duration: S.optional<S.Finite>;
+}>;
+type MutantResult = typeof MutantResultSchema.Type;
+declare const FileResultSchema: S.Struct<{
+  readonly language: S.String;
+  readonly source: S.String;
+  readonly mutants: S.$Array<S.Struct<{
+    readonly id: S.String;
+    readonly mutatorName: S.String;
+    readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+    readonly location: S.Struct<{
+      readonly start: S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>;
+      readonly end: S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>;
+    }>;
+    readonly replacement: S.optional<S.String>;
+    readonly description: S.optional<S.String>;
+    readonly statusReason: S.optional<S.String>;
+    readonly static: S.optional<S.Boolean>;
+    readonly coveredBy: S.optional<S.$Array<S.String>>;
+    readonly killedBy: S.optional<S.$Array<S.String>>;
+    readonly testsCompleted: S.optional<S.Finite>;
+    readonly duration: S.optional<S.Finite>;
+  }>>;
+}>;
+type FileResult = typeof FileResultSchema.Type;
+declare const FileResultDictionarySchema: S.$Record<S.String, S.Struct<{
+  readonly language: S.String;
+  readonly source: S.String;
+  readonly mutants: S.$Array<S.Struct<{
+    readonly id: S.String;
+    readonly mutatorName: S.String;
+    readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+    readonly location: S.Struct<{
+      readonly start: S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>;
+      readonly end: S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>;
+    }>;
+    readonly replacement: S.optional<S.String>;
+    readonly description: S.optional<S.String>;
+    readonly statusReason: S.optional<S.String>;
+    readonly static: S.optional<S.Boolean>;
+    readonly coveredBy: S.optional<S.$Array<S.String>>;
+    readonly killedBy: S.optional<S.$Array<S.String>>;
+    readonly testsCompleted: S.optional<S.Finite>;
+    readonly duration: S.optional<S.Finite>;
+  }>>;
+}>>;
+type FileResultDictionary = typeof FileResultDictionarySchema.Type;
+declare const TestDefinitionSchema: S.Struct<{
+  readonly id: S.String;
+  readonly name: S.String;
+  readonly location: S.optional<S.Struct<{
+    readonly start: S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>;
+    readonly end: S.optional<S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>>;
+  }>>;
+}>;
+type TestDefinition = typeof TestDefinitionSchema.Type;
+declare const TestFileSchema: S.Struct<{
+  readonly source: S.optional<S.String>;
+  readonly tests: S.$Array<S.Struct<{
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly location: S.optional<S.Struct<{
+      readonly start: S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>;
+      readonly end: S.optional<S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>>;
+    }>>;
+  }>>;
+}>;
+type TestFile = typeof TestFileSchema.Type;
+declare const TestFileDefinitionDictionarySchema: S.$Record<S.String, S.Struct<{
+  readonly source: S.optional<S.String>;
+  readonly tests: S.$Array<S.Struct<{
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly location: S.optional<S.Struct<{
+      readonly start: S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>;
+      readonly end: S.optional<S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>>;
+    }>>;
+  }>>;
+}>>;
+type TestFileDefinitionDictionary = typeof TestFileDefinitionDictionarySchema.Type;
+declare const ThresholdsSchema: S.Struct<{
+  readonly high: S.Finite;
+  readonly low: S.Finite;
+}>;
+type Thresholds = typeof ThresholdsSchema.Type;
+declare const BrandingInformationSchema: S.Struct<{
+  readonly homepageUrl: S.String;
+  readonly imageUrl: S.optional<S.String>;
+}>;
+type BrandingInformation = typeof BrandingInformationSchema.Type;
+declare const DependenciesSchema: S.$Record<S.String, S.String>;
+type Dependencies = typeof DependenciesSchema.Type;
+declare const FrameworkInformationSchema: S.Struct<{
+  readonly name: S.String;
+  readonly version: S.optional<S.String>;
+  readonly branding: S.optional<S.Struct<{
+    readonly homepageUrl: S.String;
+    readonly imageUrl: S.optional<S.String>;
+  }>>;
+  readonly dependencies: S.optional<S.$Record<S.String, S.String>>;
+}>;
+type FrameworkInformation = typeof FrameworkInformationSchema.Type;
+declare const MutationTestResultSchema: S.Struct<{
+  readonly schemaVersion: S.String;
+  readonly files: S.$Record<S.String, S.Struct<{
+    readonly language: S.String;
+    readonly source: S.String;
+    readonly mutants: S.$Array<S.Struct<{
+      readonly id: S.String;
+      readonly mutatorName: S.String;
+      readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+      readonly location: S.Struct<{
+        readonly start: S.Struct<{
+          readonly line: S.Finite;
+          readonly column: S.Finite;
+        }>;
+        readonly end: S.Struct<{
+          readonly line: S.Finite;
+          readonly column: S.Finite;
+        }>;
+      }>;
+      readonly replacement: S.optional<S.String>;
+      readonly description: S.optional<S.String>;
+      readonly statusReason: S.optional<S.String>;
+      readonly static: S.optional<S.Boolean>;
+      readonly coveredBy: S.optional<S.$Array<S.String>>;
+      readonly killedBy: S.optional<S.$Array<S.String>>;
+      readonly testsCompleted: S.optional<S.Finite>;
+      readonly duration: S.optional<S.Finite>;
+    }>>;
+  }>>;
+  readonly thresholds: S.Struct<{
+    readonly high: S.Finite;
+    readonly low: S.Finite;
+  }>;
+  readonly config: S.optional<S.$Record<S.String, S.Unknown>>;
+  readonly testFiles: S.optional<S.$Record<S.String, S.Struct<{
+    readonly source: S.optional<S.String>;
+    readonly tests: S.$Array<S.Struct<{
+      readonly id: S.String;
+      readonly name: S.String;
+      readonly location: S.optional<S.Struct<{
+        readonly start: S.Struct<{
+          readonly line: S.Finite;
+          readonly column: S.Finite;
+        }>;
+        readonly end: S.optional<S.Struct<{
+          readonly line: S.Finite;
+          readonly column: S.Finite;
+        }>>;
+      }>>;
+    }>>;
+  }>>>;
+  readonly projectRoot: S.optional<S.String>;
+  readonly framework: S.optional<S.Struct<{
+    readonly name: S.String;
+    readonly version: S.optional<S.String>;
+    readonly branding: S.optional<S.Struct<{
+      readonly homepageUrl: S.String;
+      readonly imageUrl: S.optional<S.String>;
+    }>>;
+    readonly dependencies: S.optional<S.$Record<S.String, S.String>>;
+  }>>;
+}>;
+type MutationTestResult = typeof MutationTestResultSchema.Type;
+//#endregion
+export { Thresholds as A, Report_schema_d_exports as C, TestFileDefinitionDictionary as D, TestFile as E, TestFileDefinitionDictionarySchema as O, PositionSchema as S, TestDefinitionSchema as T, MutationTestResult as _, FileResult as a, OpenEndLocationSchema as b, FileResultSchema as c, Location as d, LocationSchema as f, MutantStatusSchema as g, MutantStatus as h, DependenciesSchema as i, ThresholdsSchema as j, TestFileSchema as k, FrameworkInformation as l, MutantResultSchema as m, BrandingInformationSchema as n, FileResultDictionary as o, MutantResult as p, Dependencies as r, FileResultDictionarySchema as s, BrandingInformation as t, FrameworkInformationSchema as u, MutationTestResultSchema as v, TestDefinition as w, Position as x, OpenEndLocation as y };

package/dist/Reporter-BU7qo6MR.d.mts

@@ -0,0 +1,16 @@
+import { n as MetricsResult, t as Metrics } from "./Metrics.schema-BaVd6rXs.mjs";
+import { a as ReporterEvent, c as ReporterEventUnion, d as ReporterPlanDescriptor, f as RunTiming, i as MutationTestingPlanReady, l as ReporterFactory, n as MutantTested, o as ReporterEventKind, r as MutationTestReportReady, s as ReporterEventSchema, t as DryRunCompleted, u as ReporterInit } from "./ReporterEvent.schema-Db6r_euv.mjs";
+import * as S from "effect/Schema";
+//#region src/Reporter.schema.d.ts
+declare const ReporterFailed_base: S.Class<ReporterFailed, S.TaggedStruct<"ReporterFailed", {
+  readonly cause: S.String;
+  readonly event: S.Literals<readonly ["dryRunCompleted", "mutationTestingPlanReady", "mutantTested", "mutationTestReportReady"]>;
+  readonly reporterName: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class ReporterFailed extends ReporterFailed_base {}
+declare namespace Reporter_d_exports {
+  export { DryRunCompleted, Metrics, MetricsResult, MutantTested, MutationTestReportReady, MutationTestingPlanReady, REPORTER_SCHEMA_VERSION, ReporterEvent, ReporterEventKind, ReporterEventSchema, ReporterEventUnion, ReporterFactory, ReporterFailed, ReporterInit, ReporterPlanDescriptor, RunTiming };
+}
+declare const REPORTER_SCHEMA_VERSION = "1.0";
+//#endregion
+export { Reporter_d_exports as n, ReporterFailed as r, REPORTER_SCHEMA_VERSION as t };

package/dist/Reporter-BWTwlSJf.mjs

@@ -0,0 +1,25 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { DryRunCompleted, MutantTested, MutationTestReportReady, MutationTestingPlanReady, ReporterEventKind, ReporterEventSchema, ReporterEventUnion } from "./ReporterEvent.mjs";
+import * as S from "effect/Schema";
+//#region src/Reporter.schema.ts
+var ReporterFailed = class extends S.TaggedError()("ReporterFailed", {
+	cause: S.String,
+	event: ReporterEventKind,
+	reporterName: S.String
+}) {};
+//#endregion
+//#region src/Reporter.ts
+var Reporter_exports = /* @__PURE__ */ __exportAll({
+	DryRunCompleted: () => DryRunCompleted,
+	MutantTested: () => MutantTested,
+	MutationTestReportReady: () => MutationTestReportReady,
+	MutationTestingPlanReady: () => MutationTestingPlanReady,
+	REPORTER_SCHEMA_VERSION: () => "1.0",
+	ReporterEventKind: () => ReporterEventKind,
+	ReporterEventSchema: () => ReporterEventSchema,
+	ReporterEventUnion: () => ReporterEventUnion,
+	ReporterFailed: () => ReporterFailed
+});
+const REPORTER_SCHEMA_VERSION = "1.0";
+//#endregion
+export { Reporter_exports as n, ReporterFailed as r, REPORTER_SCHEMA_VERSION as t };

package/dist/Reporter.d.mts

@@ -1,2 +1,4 @@
-import { a as MutationTestMetricsResult, c as Reporter, d as RunTiming, f as TestMetrics, h as ReporterFailed, i as MetricsResult, l as ReporterService, m as broadcastReporter, n as DryRunCompletedEvent, o as MutationTestingPlanReadyEvent, p as TestRunnerCapabilities, r as Metrics, s as NamedReporter, t as CompleteDryRunResultForReporter } from "./Reporter-eZ3M7lO6.mjs";
-export { CompleteDryRunResultForReporter, DryRunCompletedEvent, Metrics, MetricsResult, MutationTestMetricsResult, MutationTestingPlanReadyEvent, NamedReporter, Reporter, ReporterFailed, ReporterService, RunTiming, TestMetrics, TestRunnerCapabilities, broadcastReporter };
+import { n as MetricsResult, t as Metrics } from "./Metrics.schema-BaVd6rXs.mjs";
+import { a as ReporterEvent, c as ReporterEventUnion, d as ReporterPlanDescriptor, f as RunTiming, i as MutationTestingPlanReady, l as ReporterFactory, n as MutantTested, o as ReporterEventKind, r as MutationTestReportReady, s as ReporterEventSchema, t as DryRunCompleted, u as ReporterInit } from "./ReporterEvent.schema-Db6r_euv.mjs";
+import { r as ReporterFailed, t as REPORTER_SCHEMA_VERSION } from "./Reporter-BU7qo6MR.mjs";
+export { DryRunCompleted, type Metrics, type MetricsResult, MutantTested, MutationTestReportReady, MutationTestingPlanReady, REPORTER_SCHEMA_VERSION, type ReporterEvent, ReporterEventKind, ReporterEventSchema, ReporterEventUnion, type ReporterFactory, ReporterFailed, type ReporterInit, type ReporterPlanDescriptor, type RunTiming };

package/dist/Reporter.mjs

@@ -1,2 +1,3 @@
-import { i as ReporterFailed, r as broadcastReporter, t as Reporter } from "./Reporter-COVWW1my.mjs";
-export { Reporter, ReporterFailed, broadcastReporter };
+import { DryRunCompleted, MutantTested, MutationTestReportReady, MutationTestingPlanReady, ReporterEventKind, ReporterEventSchema, ReporterEventUnion } from "./ReporterEvent.mjs";
+import { r as ReporterFailed, t as REPORTER_SCHEMA_VERSION } from "./Reporter-BWTwlSJf.mjs";
+export { DryRunCompleted, MutantTested, MutationTestReportReady, MutationTestingPlanReady, REPORTER_SCHEMA_VERSION, ReporterEventKind, ReporterEventSchema, ReporterEventUnion, ReporterFailed };

package/dist/ReporterEvent.d.mts

@@ -0,0 +1,2 @@
+import { a as ReporterEvent, c as ReporterEventUnion, d as ReporterPlanDescriptor, f as RunTiming, i as MutationTestingPlanReady, l as ReporterFactory, n as MutantTested, o as ReporterEventKind, r as MutationTestReportReady, s as ReporterEventSchema, t as DryRunCompleted, u as ReporterInit } from "./ReporterEvent.schema-Db6r_euv.mjs";
+export { DryRunCompleted, MutantTested, MutationTestReportReady, MutationTestingPlanReady, ReporterEvent, ReporterEventKind, ReporterEventSchema, ReporterEventUnion, ReporterFactory, ReporterInit, ReporterPlanDescriptor, RunTiming };