@systemfsoftware/stryker-js 3.0.2 → 4.0.0

package/dist/Mutant-Ci25PsWA.d.mts

@@ -1,351 +0,0 @@
-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 Effect from "effect/Effect";
-//#region src/Mutant.schema.d.ts
-declare const PositionSchema: S.Struct<{
-  readonly line: S.Finite;
-  readonly column: S.Finite;
-}>;
-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;
-  }>;
-}>;
-declare const Mutant_base: S.Class<Mutant, S.TaggedStruct<"Mutant", {
-  readonly id: S.NonEmptyString;
-  readonly fileName: S.NonEmptyString;
-  readonly mutatorName: S.NonEmptyString;
-  readonly replacement: S.String;
-  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 status: S.optional<S.Literals<readonly ["Killed", "Survived", "NoCoverage", "Timeout", "CompileError", "RuntimeError", "Ignored", "Pending"]>>;
-  readonly statusReason: S.optional<S.String>;
-  readonly coveredBy: S.optional<S.$Array<S.String>>;
-  readonly static: S.optional<S.Boolean>;
-  readonly testsCompleted: S.optional<S.Finite>;
-  readonly description: S.optional<S.String>;
-}>, {}>;
-declare class Mutant extends Mutant_base {}
-type Position$1 = S.Schema.Type<typeof PositionSchema>;
-type Location = S.Schema.Type<typeof LocationSchema>;
-//#endregion
-//#region src/TestRunner.schema.d.ts
-declare const DryRunStatus: S.Literals<readonly ["complete", "error", "timeout"]>;
-type DryRunStatus = typeof DryRunStatus.Type;
-declare const TestStatus: S.Literals<readonly ["success", "failed", "skipped"]>;
-type TestStatus = typeof TestStatus.Type;
-declare const MutantRunStatus: S.Literals<readonly ["killed", "survived", "timeout", "error"]>;
-type MutantRunStatus = typeof MutantRunStatus.Type;
-declare const TestResultSchema: S.Union<readonly [S.Struct<{
-  readonly id: S.String;
-  readonly name: S.String;
-  readonly timeSpentMs: S.Finite;
-  readonly fileName: S.optionalKey<S.String>;
-  readonly startPosition: S.optionalKey<S.Struct<{
-    readonly line: S.Finite;
-    readonly column: S.Finite;
-  }>>;
-  readonly status: S.Literal<"failed">;
-  readonly failureMessage: S.String;
-}>, S.Struct<{
-  readonly id: S.String;
-  readonly name: S.String;
-  readonly timeSpentMs: S.Finite;
-  readonly fileName: S.optionalKey<S.String>;
-  readonly startPosition: S.optionalKey<S.Struct<{
-    readonly line: S.Finite;
-    readonly column: S.Finite;
-  }>>;
-  readonly status: S.Literal<"skipped">;
-}>, S.Struct<{
-  readonly id: S.String;
-  readonly name: S.String;
-  readonly timeSpentMs: S.Finite;
-  readonly fileName: S.optionalKey<S.String>;
-  readonly startPosition: S.optionalKey<S.Struct<{
-    readonly line: S.Finite;
-    readonly column: S.Finite;
-  }>>;
-  readonly status: S.Literal<"success">;
-}>]>;
-declare const MutantCoverageSchema: S.Struct<{
-  readonly perTest: S.$Record<S.String, S.$Record<S.String, S.Finite>>;
-  readonly static: S.$Record<S.String, S.Finite>;
-}>;
-declare const DryRunResultSchema: S.Union<readonly [S.Struct<{
-  readonly status: S.Literal<"complete">;
-  readonly tests: S.$Array<S.Union<readonly [S.Struct<{
-    readonly id: S.String;
-    readonly name: S.String;
-    readonly timeSpentMs: S.Finite;
-    readonly fileName: S.optionalKey<S.String>;
-    readonly startPosition: S.optionalKey<S.Struct<{
-      readonly line: S.Finite;
-      readonly column: S.Finite;
-    }>>;
-    readonly status: S.Literal<"failed">;
-    readonly failureMessage: S.String;
-  }>, S.Struct<{
-    readonly id: S.String;
-    readonly name: S.String;
-    readonly timeSpentMs: S.Finite;
-    readonly fileName: S.optionalKey<S.String>;
-    readonly startPosition: S.optionalKey<S.Struct<{
-      readonly line: S.Finite;
-      readonly column: S.Finite;
-    }>>;
-    readonly status: S.Literal<"skipped">;
-  }>, S.Struct<{
-    readonly id: S.String;
-    readonly name: S.String;
-    readonly timeSpentMs: S.Finite;
-    readonly fileName: S.optionalKey<S.String>;
-    readonly startPosition: S.optionalKey<S.Struct<{
-      readonly line: S.Finite;
-      readonly column: S.Finite;
-    }>>;
-    readonly status: S.Literal<"success">;
-  }>]>>;
-  readonly mutantCoverage: S.optionalKey<S.Struct<{
-    readonly perTest: S.$Record<S.String, S.$Record<S.String, S.Finite>>;
-    readonly static: S.$Record<S.String, S.Finite>;
-  }>>;
-}>, S.Struct<{
-  readonly status: S.Literal<"timeout">;
-  readonly reason: S.optionalKey<S.String>;
-}>, S.Struct<{
-  readonly status: S.Literal<"error">;
-  readonly errorMessage: S.String;
-}>]>;
-declare const MutantRunResultSchema: S.Union<readonly [S.Struct<{
-  readonly status: S.Literal<"killed">;
-  readonly killedBy: S.$Array<S.String>;
-  readonly failureMessage: S.String;
-  readonly nrOfTests: S.Finite;
-}>, S.Struct<{
-  readonly status: S.Literal<"survived">;
-  readonly nrOfTests: S.Finite;
-}>, S.Struct<{
-  readonly status: S.Literal<"timeout">;
-  readonly reason: S.optionalKey<S.String>;
-}>, S.Struct<{
-  readonly status: S.Literal<"error">;
-  readonly errorMessage: S.String;
-}>]>;
-declare const CoverageAnalysisSchema: S.Literals<readonly ["off", "all", "perTest"]>;
-declare const DryRunOptionsSchema: S.Struct<{
-  readonly timeout: S.Finite;
-  readonly disableBail: S.Boolean;
-  readonly coverageAnalysis: S.Literals<readonly ["off", "all", "perTest"]>;
-  readonly files: S.optionalKey<S.$Array<S.String>>;
-  readonly testFiles: S.optionalKey<S.$Array<S.String>>;
-}>;
-declare const MutantActivationSchema: S.Literals<readonly ["runtime", "static"]>;
-declare const MutantRunOptionsSchema: S.Struct<{
-  readonly timeout: S.Finite;
-  readonly disableBail: S.Boolean;
-  readonly activeMutant: typeof Mutant;
-  readonly sandboxFileName: S.String;
-  readonly mutantActivation: S.Literals<readonly ["runtime", "static"]>;
-  readonly reloadEnvironment: S.Boolean;
-  readonly testFilter: S.optionalKey<S.$Array<S.String>>;
-  readonly hitLimit: S.optionalKey<S.Finite>;
-}>;
-declare const TestRunnerCapabilitiesSchema: S.Struct<{
-  readonly reloadEnvironment: S.Boolean;
-}>;
-declare const TestRunnerFailed_base: S.Class<TestRunnerFailed, S.TaggedStruct<"TestRunnerFailed", {
-  readonly cause: S.String;
-  readonly phase: S.Literals<readonly ["capabilities", "dispose", "dryRun", "init", "mutantRun"]>;
-  readonly runnerName: S.String;
-}>, import("effect/Cause").YieldableError>;
-declare class TestRunnerFailed extends TestRunnerFailed_base {}
-declare namespace TestRunner_d_exports {
-  export { BaseTestResult, CompleteDryRunResult, CoverageAnalysis, CoverageAnalysisSchema, DryRunOptions, DryRunOptionsSchema, DryRunResult, DryRunResultSchema, DryRunStatus, ErrorDryRunResult, ErrorMutantRunResult, FailedTestResult, KilledMutantRunResult, MutantActivation, MutantActivationSchema, MutantCoverage$1 as MutantCoverage, MutantCoverageSchema, MutantRunOptions, MutantRunOptionsSchema, MutantRunResult, MutantRunResultSchema, MutantRunStatus, Position, RunOptions, SkippedTestResult, SuccessTestResult, SurvivedMutantRunResult, TestResult, TestResultSchema, TestRunner, TestRunnerCapabilities, TestRunnerCapabilitiesSchema, TestRunnerFailed, TestRunnerService, TestStatus, TimeoutDryRunResult, TimeoutMutantRunResult, testFilesProvided, toMutantRunResult };
-}
-interface Position {
-  readonly line: number;
-  readonly column: number;
-}
-interface BaseTestResult {
-  readonly id: string;
-  readonly name: string;
-  readonly timeSpentMs: number;
-  readonly fileName?: string;
-  readonly startPosition?: Position;
-}
-interface FailedTestResult extends BaseTestResult {
-  readonly status: 'failed';
-  readonly failureMessage: string;
-}
-interface SkippedTestResult extends BaseTestResult {
-  readonly status: 'skipped';
-}
-interface SuccessTestResult extends BaseTestResult {
-  readonly status: 'success';
-}
-type TestResult = FailedTestResult | SkippedTestResult | SuccessTestResult;
-interface MutantCoverage$1 {
-  readonly perTest: Record<string, Record<string, number>>;
-  readonly static: Record<string, number>;
-}
-interface CompleteDryRunResult {
-  readonly tests: readonly TestResult[];
-  readonly mutantCoverage?: MutantCoverage$1;
-  readonly status: 'complete';
-}
-interface TimeoutDryRunResult {
-  readonly status: 'timeout';
-  readonly reason?: string;
-}
-interface ErrorDryRunResult {
-  readonly status: 'error';
-  readonly errorMessage: string;
-}
-type DryRunResult = CompleteDryRunResult | ErrorDryRunResult | TimeoutDryRunResult;
-interface TimeoutMutantRunResult {
-  readonly status: 'timeout';
-  readonly reason?: string;
-}
-interface KilledMutantRunResult {
-  readonly status: 'killed';
-  readonly killedBy: readonly string[];
-  readonly failureMessage: string;
-  readonly nrOfTests: number;
-}
-interface SurvivedMutantRunResult {
-  readonly status: 'survived';
-  readonly nrOfTests: number;
-}
-interface ErrorMutantRunResult {
-  readonly status: 'error';
-  readonly errorMessage: string;
-}
-type MutantRunResult = ErrorMutantRunResult | KilledMutantRunResult | SurvivedMutantRunResult | TimeoutMutantRunResult;
-type CoverageAnalysis = 'off' | 'all' | 'perTest';
-interface RunOptions {
-  readonly timeout: number;
-  readonly disableBail: boolean;
-}
-interface DryRunOptions extends RunOptions {
-  readonly coverageAnalysis: CoverageAnalysis;
-  readonly files?: readonly string[];
-  readonly testFiles?: readonly string[];
-}
-type MutantActivation = 'runtime' | 'static';
-interface MutantRunOptions extends RunOptions {
-  readonly testFilter?: readonly string[];
-  readonly hitLimit?: number;
-  readonly activeMutant: Mutant;
-  readonly sandboxFileName: string;
-  readonly mutantActivation: MutantActivation;
-  readonly reloadEnvironment: boolean;
-}
-interface TestRunnerCapabilities {
-  readonly reloadEnvironment: boolean;
-}
-declare function toMutantRunResult(dryRunResult: DryRunResult, reportAllKillers: boolean): MutantRunResult;
-interface TestRunnerService {
-  readonly capabilities: Effect.Effect<TestRunnerCapabilities, TestRunnerFailed>;
-  readonly init: Effect.Effect<void, TestRunnerFailed>;
-  readonly dryRun: (options: DryRunOptions) => Effect.Effect<DryRunResult, TestRunnerFailed>;
-  readonly mutantRun: (options: MutantRunOptions) => Effect.Effect<MutantRunResult, TestRunnerFailed>;
-  readonly dispose: Effect.Effect<void, TestRunnerFailed>;
-}
-declare const TestRunner_base: Context.ServiceClass<TestRunner, "~@systemfsoftware/stryker-js/TestRunner", TestRunnerService>;
-declare class TestRunner extends TestRunner_base {}
-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, Report_schema_d_exports as schema };
-}
-type CoverageData = Record<string, number>;
-type CoveragePerTestId = Record<string, CoverageData>;
-interface Coverage {
-  readonly static: CoverageData;
-  readonly perTest: CoveragePerTestId;
-}
-type MutantStatus = 'Killed' | 'Survived' | 'NoCoverage' | 'Timeout' | 'CompileError' | 'RuntimeError' | 'Ignored' | 'Pending';
-interface EarlyResultPlan {
-  readonly plan: 'EarlyResult';
-  readonly mutant: Mutant;
-}
-interface RunPlan {
-  readonly plan: 'Run';
-  readonly mutant: Mutant;
-  readonly runOptions: MutantRunOptions;
-  readonly netTime: number;
-}
-type TestPlan = EarlyResultPlan | RunPlan;
-declare const isMutant: (value: unknown) => value is Mutant;
-type MutantTestCoverage = Mutant & {
-  readonly coveredBy: ReadonlyArray<string> | undefined;
-  readonly static: boolean | undefined;
-};
-type MutantResult = Mutant & {
-  readonly status: MutantStatus;
-  readonly statusReason?: string | undefined;
-  readonly testsCompleted?: number | undefined;
-  readonly killedBy?: readonly string[] | undefined;
-  readonly coveredBy?: readonly string[] | undefined;
-  readonly static?: boolean | undefined;
-};
-declare const INSTRUMENTER_CONSTANTS: Readonly<{
-  NAMESPACE: '__stryker__';
-  MUTATION_COVERAGE_OBJECT: 'mutantCoverage';
-  ACTIVE_MUTANT: 'activeMutant';
-  CURRENT_TEST_ID: 'currentTestId';
-  HIT_COUNT: 'hitCount';
-  HIT_LIMIT: 'hitLimit';
-  ACTIVE_MUTANT_ENV_VARIABLE: '__STRYKER_ACTIVE_MUTANT__';
-}>;
-interface InstrumenterContext {
-  activeMutant?: string;
-  currentTestId?: string;
-  mutantCoverage?: MutantCoverage;
-  hitCount?: number;
-  hitLimit?: number;
-}
-type MutantCoverage = Coverage;
-declare function normalizeFileName(fileName: string): string;
-interface ErrnoException extends Error {
-  code?: string;
-  errno?: number;
-  path?: string;
-  syscall?: string;
-}
-declare function isErrnoException(error: unknown): error is ErrnoException;
-declare function errorToString(error: unknown): string;
-declare const ERROR_CODES: Readonly<{
-  NoSuchFileOrDirectory: 'ENOENT';
-}>;
-interface MutationRange {
-  readonly start: Position$1;
-  readonly end: Position$1;
-}
-type MutateDescription = ReadonlyArray<MutationRange> | boolean;
-interface FileDescription {
-  readonly mutate: MutateDescription;
-}
-type FileDescriptions = Record<string, FileDescription>;
-type MutantRunPlan = RunPlan;
-type MutantEarlyResultPlan = EarlyResultPlan;
-type MutantTestPlan = TestPlan;
-declare const causeText: (cause: unknown, depth: number) => string | undefined;
-//#endregion
-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,3 +0,0 @@
-import { C as causeText, D as normalizeFileName, E as isMutant, S as TestPlan, T as isErrnoException, _ as MutantTestPlan, _t as Position, a as EarlyResultPlan, b as MutationRange, c as FileDescriptions, d as MutantCoverage, f as MutantEarlyResultPlan, g as MutantTestCoverage, gt as Mutant, h as MutantStatus, ht as LocationSchema, i as ERROR_CODES, l as INSTRUMENTER_CONSTANTS, m as MutantRunPlan, mt as Location, n as CoverageData, o as ErrnoException, p as MutantResult, r as CoveragePerTestId, s as FileDescription, t as Coverage, u as InstrumenterContext, vt as PositionSchema, w as errorToString, x as RunPlan, y as MutateDescription } from "./Mutant-Ci25PsWA.mjs";
-import { C as Report_schema_d_exports } from "./Report.schema-_buHXdnZ.mjs";
-export { Coverage, CoverageData, CoveragePerTestId, ERROR_CODES, EarlyResultPlan, ErrnoException, FileDescription, FileDescriptions, INSTRUMENTER_CONSTANTS, InstrumenterContext, type Location, LocationSchema, Mutant, MutantCoverage, MutantEarlyResultPlan, MutantResult, MutantRunPlan, MutantStatus, MutantTestCoverage, MutantTestPlan, MutateDescription, MutationRange, type Position, PositionSchema, RunPlan, TestPlan, causeText, errorToString, isErrnoException, isMutant, normalizeFileName, Report_schema_d_exports as schema };

package/dist/Mutant.mjs

@@ -1,90 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-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,
-	INSTRUMENTER_CONSTANTS: () => INSTRUMENTER_CONSTANTS,
-	LocationSchema: () => LocationSchema,
-	Mutant: () => Mutant,
-	PositionSchema: () => PositionSchema,
-	causeText: () => causeText,
-	errorToString: () => errorToString,
-	isErrnoException: () => isErrnoException,
-	isMutant: () => isMutant,
-	normalizeFileName: () => normalizeFileName,
-	schema: () => Report_schema_exports
-});
-const isMutant = (value) => value instanceof Mutant;
-const INSTRUMENTER_CONSTANTS = Object.freeze({
-	NAMESPACE: "__stryker__",
-	MUTATION_COVERAGE_OBJECT: "mutantCoverage",
-	ACTIVE_MUTANT: "activeMutant",
-	CURRENT_TEST_ID: "currentTestId",
-	HIT_COUNT: "hitCount",
-	HIT_LIMIT: "hitLimit",
-	ACTIVE_MUTANT_ENV_VARIABLE: "__STRYKER_ACTIVE_MUTANT__"
-});
-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) {
-	return Match.value(error).pipe(Match.when(Match.instanceOf(Error), hasStringCode), Match.orElse(() => false));
-}
-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 {
-		return textIfNonEmpty(JSON.stringify(error));
-	} catch {
-		return;
-	}
-};
-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 "";
-	}
-}), 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 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, Report_schema_exports as schema, Mutant_exports as t };

package/dist/Mutant.schema-H3r0ho_R.mjs

@@ -1,34 +0,0 @@
-import * as S from "effect/Schema";
-//#region src/Mutant.schema.ts
-const PositionSchema = S.Struct({
-	line: S.Finite,
-	column: S.Finite
-});
-const LocationSchema = S.Struct({
-	start: PositionSchema,
-	end: PositionSchema
-});
-var Mutant = class extends S.TaggedClass()("Mutant", {
-	id: S.NonEmptyString,
-	fileName: S.NonEmptyString,
-	mutatorName: S.NonEmptyString,
-	replacement: S.String,
-	location: LocationSchema,
-	status: S.optional(S.Literals([
-		"Killed",
-		"Survived",
-		"NoCoverage",
-		"Timeout",
-		"CompileError",
-		"RuntimeError",
-		"Ignored",
-		"Pending"
-	])),
-	statusReason: S.optional(S.String),
-	coveredBy: S.optional(S.Array(S.String)),
-	static: S.optional(S.Boolean),
-	testsCompleted: S.optional(S.Finite),
-	description: S.optional(S.String)
-}) {};
-//#endregion
-export { Mutant as n, PositionSchema as r, LocationSchema as t };

package/dist/Plugin-BtItMchw.d.mts

@@ -1,153 +0,0 @@
-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 { l as ReporterFactory } from "./ReporterEvent.schema-BhtyYCZo.mjs";
-import * as Context from "effect/Context";
-import * as S from "effect/Schema";
-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 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 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;
-  readonly shadowedIndex: S.Finite;
-  readonly winnerIndex: S.Finite;
-}>, {}>;
-declare class Shadowing extends Shadowing_base {}
-declare namespace Plugin_d_exports {
-  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;
-  readonly allowConsoleColors: boolean;
-  readonly buildCommand?: string | undefined;
-  readonly checkers: readonly string[];
-  readonly checkerNodeArgs: readonly string[];
-  readonly concurrency?: string | number | undefined;
-  readonly commandRunner: {
-    readonly [x: string]: unknown;
-    readonly command: string;
-  };
-  readonly coverageAnalysis: "all" | "off" | "perTest";
-  readonly clearTextReporter: {
-    readonly [x: string]: unknown;
-    readonly allowColor: boolean;
-    readonly allowEmojis: boolean;
-    readonly logTests: boolean;
-    readonly maxTestsToLog: number;
-    readonly reportTests: boolean;
-    readonly reportMutants: boolean;
-    readonly reportScoreTable: boolean;
-    readonly skipFull: boolean;
-  };
-  readonly dryRunOnly: boolean;
-  readonly ignorePatterns: readonly string[];
-  readonly ignoreStatic: boolean;
-  readonly incremental: boolean;
-  readonly incrementalFile: string;
-  readonly progressStreamFile: string;
-  readonly force: boolean;
-  readonly fileLogLevel: "debug" | "error" | "fatal" | "info" | "off" | "trace" | "warn";
-  readonly inPlace: boolean;
-  readonly logLevel: "debug" | "error" | "fatal" | "info" | "off" | "trace" | "warn";
-  readonly maxConcurrentTestRunners: number;
-  readonly maxTestRunnerReuse: number;
-  readonly mutate: readonly string[];
-  readonly mutator: {
-    readonly excludedMutations: readonly string[];
-  };
-  readonly packageManager?: "npm" | "pnpm" | "yarn" | undefined;
-  readonly plugins: readonly string[];
-  readonly appendPlugins: readonly string[];
-  readonly reporters: readonly string[];
-  readonly htmlReporter: {
-    readonly fileName: string;
-  };
-  readonly jsonReporter: {
-    readonly fileName: string;
-  };
-  readonly disableTypeChecks: string | boolean;
-  readonly symlinkNodeModules: boolean;
-  readonly tempDirName: string;
-  readonly cleanTempDir: "always" | boolean;
-  readonly testRunner: string;
-  readonly testRunnerNodeArgs: readonly string[];
-  readonly thresholds: {
-    readonly high: number;
-    readonly low: number;
-    readonly break: number | null;
-  };
-  readonly timeoutFactor: number;
-  readonly timeoutMS: number;
-  readonly dryRunTimeoutMinutes: number;
-  readonly tsconfigFile: string;
-  readonly warnings: boolean | {
-    readonly [x: string]: unknown;
-    readonly unknownOptions: boolean;
-    readonly preprocessorErrors: boolean;
-    readonly unserializableOptions: boolean;
-    readonly slow: boolean;
-  };
-  readonly disableBail: boolean;
-  readonly allowEmpty: boolean;
-  readonly ignorers: readonly string[];
-  readonly testFiles: readonly string[];
-}>;
-declare class RunConfiguration extends RunConfiguration_base {}
-declare const SandboxDirectory_base: Context.ServiceClass<SandboxDirectory, "~@systemfsoftware/stryker-js/SandboxDirectory", string>;
-declare class SandboxDirectory extends SandboxDirectory_base {}
-interface PluginInterfaces {
-  Checker: Checker;
-  TestRunner: TestRunner;
-  Ignore: Ignorer;
-  Evaluator: Evaluator;
-}
-type PluginEnvironment = RunConfiguration | SandboxDirectory | FileSystem.FileSystem | Module | Path.Path;
-type AnyPluginContribution = { [K in PluginKind]: PluginContribution<K>; }[PluginKind];
-type ContributionOf<K extends PluginKind> = Extract<AnyPluginContribution, {
-  readonly kind: K;
-}>;
-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 { 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 };