@systemfsoftware/stryker-js 1.0.0 → 3.0.0

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([

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