@systemfsoftware/stryker-js-cli-contract 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1709 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import * as S from "effect/Schema";
+import { Schema, SchemaGetter } from "effect";
+import * as SchemaGetter$1 from "effect/SchemaGetter";
+import { Mutant, Plugin, Report } from "@systemfsoftware/stryker-js-plugin-interface";
+//#region src/output-mode.schema.ts
+const OutputMode = S.Literals(["human", "machine"]);
+const ModeSignal = S.Literals([
+	"flag",
+	"env",
+	"tty",
+	"agent",
+	"tool"
+]);
+//#endregion
+//#region src/OutputMode/mod.ts
+var OutputMode_exports = /* @__PURE__ */ __exportAll({
+	ModeSignal: () => ModeSignal,
+	OutputMode: () => OutputMode
+});
+//#endregion
+//#region src/plugin-load-failure-reason.schema.ts
+const PluginLoadFailureReason = Schema.Union([
+	Schema.TaggedStruct("PeerMissing", { peer: Schema.String }),
+	Schema.TaggedStruct("PeerVersionUnsupported", {
+		peer: Schema.String,
+		detail: Schema.String
+	}),
+	Schema.TaggedStruct("PeerUnrecognized", { peer: Schema.String }),
+	Schema.TaggedStruct("InvalidContribution", { detail: Schema.String }),
+	Schema.TaggedStruct("ImportFailed", { cause: Schema.Unknown })
+]);
+//#endregion
+//#region src/stream-version.schema.ts
+const StreamSchemaVersion = S.Literal("2.0");
+//#endregion
+//#region src/run-event.schema.ts
+const RunPhase = S.Literals([
+	"prepare",
+	"instrument",
+	"dry-run",
+	"mutation-test"
+]);
+const RunId = S.String.pipe(S.check(S.isPattern(/^[0-9A-HJKMNP-TV-Z]{26}$/)), S.brand("RunId"));
+var RunStarted = class extends S.TaggedClass()("stream", {
+	schemaVersion: StreamSchemaVersion,
+	runId: RunId,
+	mode: OutputMode,
+	signal: ModeSignal
+}) {};
+var PhaseEntered = class extends S.TaggedClass()("phase", {
+	phase: RunPhase,
+	elapsedMs: Report.NonNegativeFinite
+}) {};
+var PlanKnown = class extends S.TaggedClass()("plan", { total: Report.NonNegativeInt }) {};
+const MutantCost = S.Struct({
+	fixedOverheadMs: Report.NonNegativeFinite,
+	testBodyMs: Report.NonNegativeFinite,
+	testsExecuted: Report.NonNegativeInt,
+	shared: S.Boolean
+});
+/**
+* The machine-stream line a tested mutant is published as. Its wire shape is a
+* published contract: the `mutant` tag and the `file`/`mutator` keys must not
+* change. The line carries the verified fields of `Reporter.MutantTested` plus
+* the static classification (R24) and the measured cost breakdown (R39).
+*/
+var RunMutantTestedEvent = class extends S.TaggedClass()("mutantTested", {
+	id: Mutant.MutantId,
+	status: Mutant.MutantStatusSchema,
+	fileName: Mutant.CanonicalFileName,
+	location: Mutant.Location,
+	mutatorName: Mutant.MutatorName,
+	replacement: S.NullOr(S.String),
+	completed: Report.NonNegativeInt,
+	total: Report.NonNegativeInt,
+	static: S.Boolean,
+	cost: S.NullOr(MutantCost)
+}) {};
+const RunMutantTested = S.TaggedStruct("mutant", {
+	id: Mutant.MutantId,
+	status: Mutant.MutantStatusSchema,
+	file: S.toType(Mutant.CanonicalFileName),
+	location: Mutant.Location,
+	mutator: Mutant.MutatorName,
+	replacement: S.NullOr(S.String),
+	completed: Report.NonNegativeInt,
+	total: Report.NonNegativeInt,
+	static: S.Boolean,
+	cost: S.NullOr(MutantCost)
+}).pipe(S.decodeTo(S.toType(RunMutantTestedEvent), {
+	decode: SchemaGetter.transform((line) => RunMutantTestedEvent.make({
+		id: line.id,
+		status: line.status,
+		fileName: line.file,
+		location: line.location,
+		mutatorName: line.mutator,
+		replacement: line.replacement,
+		completed: line.completed,
+		total: line.total,
+		static: line.static,
+		cost: line.cost
+	})),
+	encode: SchemaGetter.transform((tested) => ({
+		_tag: "mutant",
+		id: tested.id,
+		status: tested.status,
+		file: tested.fileName,
+		location: tested.location,
+		mutator: tested.mutatorName,
+		replacement: tested.replacement,
+		completed: tested.completed,
+		total: tested.total,
+		static: tested.static,
+		cost: tested.cost
+	}))
+}));
+var Heartbeat = class extends S.TaggedClass()("tick", {
+	elapsedMs: Report.NonNegativeFinite,
+	completed: Report.NonNegativeInt,
+	total: S.NullOr(Report.NonNegativeInt)
+}) {};
+const VerdictLocation = S.Struct({
+	start: Mutant.Position,
+	end: Mutant.Position
+});
+const VerdictThresholds = S.Struct({
+	high: Report.Percentage,
+	low: Report.Percentage,
+	break: S.NullOr(Report.Percentage)
+});
+const VerdictMutant = S.Struct({
+	id: S.String,
+	file: S.String,
+	location: VerdictLocation,
+	mutator: S.String,
+	replacement: S.NullOr(S.String),
+	status: Mutant.MutantStatusSchema
+});
+const RunScope = S.Literals(["full", "diff"]);
+const MutantSetPolicy = S.Literals(["default", "full"]);
+const PhaseDurations = S.Struct({
+	prepare: Report.NonNegativeFinite,
+	instrument: Report.NonNegativeFinite,
+	"dry-run": Report.NonNegativeFinite,
+	"mutation-test": Report.NonNegativeFinite
+});
+const StaticVerdict = S.Struct({
+	count: Report.NonNegativeInt,
+	costMs: Report.NonNegativeFinite
+});
+var VerdictReached = class extends S.TaggedClass()("verdict", {
+	schemaVersion: StreamSchemaVersion,
+	runId: RunId,
+	mode: OutputMode,
+	signal: ModeSignal,
+	score: S.NullOr(Report.Percentage),
+	thresholds: VerdictThresholds,
+	reportFile: S.NullOr(S.String),
+	counts: Report.Metrics,
+	mutants: S.Array(VerdictMutant),
+	scope: RunScope,
+	mutantSetPolicy: MutantSetPolicy,
+	phaseDurations: S.NullOr(PhaseDurations),
+	static: S.NullOr(StaticVerdict)
+}) {};
+const FrameworkContributionRow = S.Struct({
+	name: S.String,
+	formatId: S.String,
+	extensions: S.Array(S.String)
+});
+const FrameworkModuleRow = S.Struct({
+	moduleName: S.String,
+	contributions: S.Array(FrameworkContributionRow)
+});
+const FormatClaimShadowingRow = S.Struct({
+	extension: S.String,
+	winner: S.String,
+	loser: S.String
+});
+var PluginsReported = class extends S.TaggedClass()("plugins", {
+	modules: S.Array(FrameworkModuleRow),
+	shadowings: S.Array(FormatClaimShadowingRow)
+}) {};
+const FormatRegistryRow = S.Struct({
+	extension: S.String,
+	formatId: S.String,
+	ownerModule: S.String,
+	language: S.String
+});
+var FormatRegistryResolved = class extends S.TaggedClass()("formats", { rows: S.Array(FormatRegistryRow) }) {};
+const SkippedFileRow = S.Struct({
+	file: S.String,
+	extension: S.String,
+	reason: S.String
+});
+var SkippedReported = class extends S.TaggedClass()("skipped", { files: S.Array(SkippedFileRow) }) {};
+const ReuseRefusals = S.Struct({
+	semanticsChanged: Report.NonNegativeInt,
+	policyChanged: Report.NonNegativeInt,
+	runInputsChanged: Report.NonNegativeInt,
+	closureChanged: Report.NonNegativeInt,
+	timeoutUnreproduced: Report.NonNegativeInt,
+	flakyDependency: Report.NonNegativeInt,
+	noPriorRecord: Report.NonNegativeInt
+});
+var ReuseReported = class extends S.TaggedClass()("reuse", {
+	reused: Report.NonNegativeInt,
+	ran: Report.NonNegativeInt,
+	refused: ReuseRefusals
+}) {};
+var MutantDetailReported = class extends S.TaggedClass()("mutant-detail", {
+	id: Mutant.MutantId,
+	status: Mutant.MutantStatusSchema,
+	coveringTests: S.Array(S.String),
+	killedBy: S.NullOr(S.String),
+	reproducer: S.NullOr(S.String)
+}) {};
+const FeedbackJudgment = S.Literals(["useful", "not-useful"]);
+var FeedbackReported = class extends S.TaggedClass()("feedback", {
+	id: Mutant.MutantId,
+	judgment: FeedbackJudgment,
+	reason: S.NullOr(S.String)
+}) {};
+var RunFailed = class extends S.TaggedClass()("error", {
+	schemaVersion: StreamSchemaVersion,
+	code: Plugin.ExitCode,
+	error: S.String,
+	remediation: S.String,
+	reason: S.NullOr(PluginLoadFailureReason)
+}) {};
+var HelpRendered = class extends S.TaggedClass()("help", {
+	schemaVersion: StreamSchemaVersion,
+	code: S.Literals([0]),
+	help: S.String
+}) {};
+const RunEvent = Object.assign(S.Union([
+	RunStarted,
+	PhaseEntered,
+	PlanKnown,
+	RunMutantTested,
+	Heartbeat,
+	PluginsReported,
+	FormatRegistryResolved,
+	SkippedReported,
+	ReuseReported,
+	MutantDetailReported,
+	FeedbackReported,
+	VerdictReached,
+	RunFailed,
+	HelpRendered
+]), { QUEUE_BOUND: 256 });
+//#endregion
+//#region src/run-event-wire.schema.ts
+const RunEventWireLine = S.String.pipe(S.decodeTo(S.fromJsonString(RunEvent), {
+	decode: SchemaGetter$1.transform((line) => line.replace(/\n$/, "")),
+	encode: SchemaGetter$1.transform((json) => `${json}\n`)
+}));
+//#endregion
+//#region src/RunEvent/mod.ts
+var RunEvent_exports = /* @__PURE__ */ __exportAll({
+	FeedbackJudgment: () => FeedbackJudgment,
+	FeedbackReported: () => FeedbackReported,
+	FormatClaimShadowingRow: () => FormatClaimShadowingRow,
+	FormatRegistryResolved: () => FormatRegistryResolved,
+	FormatRegistryRow: () => FormatRegistryRow,
+	FrameworkContributionRow: () => FrameworkContributionRow,
+	FrameworkModuleRow: () => FrameworkModuleRow,
+	Heartbeat: () => Heartbeat,
+	HelpRendered: () => HelpRendered,
+	MutantCost: () => MutantCost,
+	MutantDetailReported: () => MutantDetailReported,
+	MutantSetPolicy: () => MutantSetPolicy,
+	PhaseDurations: () => PhaseDurations,
+	PhaseEntered: () => PhaseEntered,
+	PlanKnown: () => PlanKnown,
+	PluginLoadFailureReason: () => PluginLoadFailureReason,
+	PluginsReported: () => PluginsReported,
+	ReuseRefusals: () => ReuseRefusals,
+	ReuseReported: () => ReuseReported,
+	RunEvent: () => RunEvent,
+	RunEventWireLine: () => RunEventWireLine,
+	RunFailed: () => RunFailed,
+	RunId: () => RunId,
+	RunMutantTested: () => RunMutantTested,
+	RunMutantTestedEvent: () => RunMutantTestedEvent,
+	RunPhase: () => RunPhase,
+	RunScope: () => RunScope,
+	RunStarted: () => RunStarted,
+	SkippedFileRow: () => SkippedFileRow,
+	SkippedReported: () => SkippedReported,
+	StaticVerdict: () => StaticVerdict,
+	StreamSchemaVersion: () => StreamSchemaVersion,
+	VerdictLocation: () => VerdictLocation,
+	VerdictMutant: () => VerdictMutant,
+	VerdictReached: () => VerdictReached,
+	VerdictThresholds: () => VerdictThresholds
+});
+//#endregion
+//#region src/SpanTaxonomy.schema.ts
+const SpanName = S.String.check(S.isPattern(/^[A-Za-z][A-Za-z0-9_-]*(?:\.[A-Za-z][A-Za-z0-9_-]*)*$/, { expected: "a dot-separated span name whose segments start with a letter, such as \"stryker.checker.check\"" })).pipe(S.brand("SpanName"));
+const SpanAttributeKey = S.String.check(S.isPattern(/^[A-Za-z][A-Za-z0-9_.-]*$/, { expected: "an attribute key starting with a letter, such as \"stryker.checker.name\"" })).pipe(S.brand("SpanAttributeKey"));
+const SpanAttributeText = S.String;
+const SpanAttributeCount = S.Finite;
+const SpanRunStatus = S.Literals([
+	"success",
+	"failure",
+	"timed_out",
+	"aborted",
+	"skipped"
+]);
+const SpanDocument = S.Struct({
+	id: SpanName,
+	name: SpanName,
+	attributes: S.Record(SpanAttributeKey, S.Json)
+});
+const idsAreUnique = S.makeFilter((documents) => {
+	const duplicated = Mutant.duplicatedValue(documents.map((document) => document.id));
+	return duplicated === void 0 ? void 0 : `span taxonomy documents share the id "${duplicated}"`;
+}, { arbitraryConstraint: { uniqueBy: (document) => document.id } });
+const SpanDocuments = S.Array(SpanDocument).check(idsAreUnique);
+//#endregion
+//#region src/SpanTaxonomy.ts
+[.../* @__PURE__ */ new Set([
+	...Plugin.CheckerRpcs.requests.keys(),
+	...Plugin.TestRunnerRpcs.requests.keys(),
+	...Plugin.ReporterRpcs.requests.keys()
+])].sort();
+const Spans = {
+	checkerCheck: {
+		name: "stryker.checker.check",
+		attributes: {
+			"stryker.checker.name": SpanAttributeText,
+			"stryker.mutants.count": SpanAttributeCount
+		}
+	},
+	checkerCheckPlans: {
+		name: "stryker.checker.check_plans",
+		attributes: {}
+	},
+	checkerGroup: {
+		name: "stryker.checker.group",
+		attributes: {
+			"stryker.checker.name": SpanAttributeText,
+			"stryker.mutants.count": SpanAttributeCount
+		}
+	},
+	checkerGroupPlans: {
+		name: "stryker.checker.group_plans",
+		attributes: {}
+	},
+	checkerLogSkipped: {
+		name: "stryker.checker.log_skipped",
+		attributes: {}
+	},
+	checkerPoolCheckPlans: {
+		name: "stryker.checker_pool.check_plans",
+		attributes: {}
+	},
+	checkerPoolSplitChecked: {
+		name: "stryker.checker_pool.split_checked",
+		attributes: {}
+	},
+	checkerRecordSkipped: {
+		name: "stryker.checker.record_skipped",
+		attributes: {}
+	},
+	cliRun: {
+		name: "stryker.cli.run",
+		attributes: {
+			"stryker.run.outcome": SpanAttributeText,
+			"stryker.run.exit_code": SpanAttributeCount,
+			"stryker.run.error": SpanAttributeText
+		}
+	},
+	commandRunnerRun: {
+		name: "stryker.command_runner.run",
+		attributes: {}
+	},
+	concurrency: {
+		name: "stryker.concurrency",
+		attributes: {}
+	},
+	configDiscover: {
+		name: "stryker.config.discover",
+		attributes: {}
+	},
+	configExists: {
+		name: "stryker.config.exists",
+		attributes: {}
+	},
+	configExpectedFile: {
+		name: "stryker.config.expectedFile",
+		attributes: {}
+	},
+	configExtends: {
+		name: "stryker.config.extends",
+		attributes: {}
+	},
+	configExtendsChild: {
+		name: "stryker.config.extendsChild",
+		attributes: {}
+	},
+	configExtendsStep: {
+		name: "stryker.config.extendsStep",
+		attributes: {}
+	},
+	configLoad: {
+		name: "stryker.config.load",
+		attributes: {}
+	},
+	configLoadOptions: {
+		name: "stryker.config.loadOptions",
+		attributes: {}
+	},
+	configRead: {
+		name: "stryker.config_read",
+		attributes: {}
+	},
+	configReadDocument: {
+		name: "stryker.config.readDocument",
+		attributes: {}
+	},
+	configReadModule: {
+		name: "stryker.config.readModule",
+		attributes: {}
+	},
+	configReadRun: {
+		name: "stryker.config.readRun",
+		attributes: {}
+	},
+	dryRun: {
+		name: "stryker.dry_run",
+		attributes: {}
+	},
+	dryRunComplete: {
+		name: "stryker.dry_run.complete",
+		attributes: {}
+	},
+	dryRunPhase: {
+		name: "dryRun",
+		attributes: {}
+	},
+	dryRunResolveFiles: {
+		name: "stryker.dry_run.resolve_files",
+		attributes: {}
+	},
+	dryRunWriteFailed: {
+		name: "stryker.dry_run.write_failed",
+		attributes: {}
+	},
+	dryRunWritePassed: {
+		name: "stryker.dry_run.write_passed",
+		attributes: {}
+	},
+	frameworkClaimantList: {
+		name: "stryker.framework_claimant.list",
+		attributes: {}
+	},
+	frameworkClaimantOf: {
+		name: "stryker.framework_claimant.of",
+		attributes: {}
+	},
+	htmlReportReadBundleFromDisk: {
+		name: "html_report.read_bundle_from_disk",
+		attributes: {}
+	},
+	htmlReportWrite: {
+		name: "html_report.write",
+		attributes: {}
+	},
+	htmlReportWriteBundleFromDisk: {
+		name: "html_report.write_bundle_from_disk",
+		attributes: {}
+	},
+	htmlReportWriteFile: {
+		name: "html_report.write_file",
+		attributes: {}
+	},
+	incrementalReuse: {
+		name: "stryker.incremental_reuse",
+		attributes: {}
+	},
+	incrementalReuseRead: {
+		name: "stryker.incremental_reuse.read",
+		attributes: {}
+	},
+	instrument: {
+		name: "stryker.instrument",
+		attributes: {}
+	},
+	instrumentDisableTypeChecks: {
+		name: "stryker.instrument.disableTypeChecks",
+		attributes: {}
+	},
+	instrumentFrameworkEntryParse: {
+		name: "stryker.instrument.framework_entry.parse",
+		attributes: {}
+	},
+	instrumentFrameworkEntryTransform: {
+		name: "stryker.instrument.framework_entry.transform",
+		attributes: {}
+	},
+	instrumentGather: {
+		name: "stryker.instrument.gather",
+		attributes: {}
+	},
+	instrumentOfferSkips: {
+		name: "stryker.instrument.offer-skips",
+		attributes: {}
+	},
+	instrumentParserParseJS: {
+		name: "stryker.instrument.parser.parseJS",
+		attributes: {}
+	},
+	instrumentParserParseTS: {
+		name: "stryker.instrument.parser.parseTS",
+		attributes: {}
+	},
+	instrumentParserParseTsx: {
+		name: "stryker.instrument.parser.parseTsx",
+		attributes: {}
+	},
+	instrumentParserParseWithOxc: {
+		name: "stryker.instrument.parser.parseWithOxc",
+		attributes: {}
+	},
+	instrumentPhase: {
+		name: "instrument",
+		attributes: { fileCount: SpanAttributeCount }
+	},
+	instrumentReadFiles: {
+		name: "stryker.instrument.read_files",
+		attributes: {}
+	},
+	instrumentReportSkips: {
+		name: "stryker.instrument.report-skips",
+		attributes: {}
+	},
+	instrumentTransformScript: {
+		name: "stryker.instrument.transform.script",
+		attributes: {}
+	},
+	loadConfig: {
+		name: "stryker.load_config",
+		attributes: {}
+	},
+	mergeReports: {
+		name: "stryker.merge_reports",
+		attributes: {}
+	},
+	mergeReportsCollectPartDirs: {
+		name: "stryker.merge_reports.collect_part_dirs",
+		attributes: {}
+	},
+	mergeReportsDirectoryExists: {
+		name: "stryker.merge_reports.directory_exists",
+		attributes: {}
+	},
+	mergeReportsEncodeReport: {
+		name: "stryker.merge_reports.encode_report",
+		attributes: {}
+	},
+	mergeReportsFail: {
+		name: "stryker.merge_reports.fail",
+		attributes: {}
+	},
+	mergeReportsGather: {
+		name: "stryker.merge_reports.gather",
+		attributes: {}
+	},
+	mergeReportsListNames: {
+		name: "stryker.merge_reports.list_names",
+		attributes: {}
+	},
+	mergeReportsPutFile: {
+		name: "stryker.merge_reports.put_file",
+		attributes: {}
+	},
+	mergeReportsReadPart: {
+		name: "stryker.merge_reports.read_part",
+		attributes: {}
+	},
+	mergeReportsReadText: {
+		name: "stryker.merge_reports.read_text",
+		attributes: {}
+	},
+	mergeReportsRefuseCommand: {
+		name: "stryker.merge_reports.refuse_command",
+		attributes: {}
+	},
+	mergeReportsRefuseParts: {
+		name: "stryker.merge_reports.refuse_parts",
+		attributes: {}
+	},
+	mergeReportsRenderHtml: {
+		name: "stryker.merge_reports.render_html",
+		attributes: {}
+	},
+	mergeReportsWriteAbsent: {
+		name: "stryker.merge_reports.write_absent",
+		attributes: {}
+	},
+	mergeReportsWriteFiles: {
+		name: "stryker.merge_reports.write_files",
+		attributes: {}
+	},
+	mergeReportsWriteHtml: {
+		name: "stryker.merge_reports.write_html",
+		attributes: {}
+	},
+	mergeReportsWriteMerged: {
+		name: "stryker.merge_reports.write_merged",
+		attributes: {}
+	},
+	mutantRun: {
+		name: "stryker.mutant_run",
+		attributes: {}
+	},
+	mutationReportingAssembleReport: {
+		name: "stryker.mutationReporting.assembleReport",
+		attributes: {}
+	},
+	mutationReportingCheckpoint: {
+		name: "stryker.mutationReporting.checkpoint",
+		attributes: {}
+	},
+	mutationReportingDiscoverDependencies: {
+		name: "stryker.mutationReporting.discoverDependencies",
+		attributes: {}
+	},
+	mutationReportingEmitVerdict: {
+		name: "stryker.mutationReporting.emitVerdict",
+		attributes: {}
+	},
+	mutationReportingManifestVersion: {
+		name: "stryker.mutationReporting.manifestVersion",
+		attributes: {}
+	},
+	mutationReportingMutationTestReport: {
+		name: "stryker.mutationReporting.mutationTestReport",
+		attributes: {}
+	},
+	mutationReportingReadMutatedSources: {
+		name: "stryker.mutationReporting.readMutatedSources",
+		attributes: {}
+	},
+	mutationReportingReadTestSources: {
+		name: "stryker.mutationReporting.readTestSources",
+		attributes: {}
+	},
+	mutationReportingReportAll: {
+		name: "stryker.mutationReporting.reportAll",
+		attributes: {}
+	},
+	mutationReportingSlimIncrementalReport: {
+		name: "stryker.mutationReporting.slimIncrementalReport",
+		attributes: {}
+	},
+	mutationReportingWriteAtomic: {
+		name: "stryker.mutationReporting.writeAtomic",
+		attributes: {}
+	},
+	mutationReportingWriteIncrementalReport: {
+		name: "stryker.mutationReporting.writeIncrementalReport",
+		attributes: {}
+	},
+	mutationTest: {
+		name: "stryker.mutation_test",
+		attributes: {}
+	},
+	mutationTestBatch: {
+		name: "mutationTest.batch",
+		attributes: {
+			total: SpanAttributeCount,
+			testRunners: SpanAttributeCount
+		}
+	},
+	mutationTestCheckerScope: {
+		name: "stryker.mutation_test.checker_scope",
+		attributes: {}
+	},
+	mutationTestDryRunOnly: {
+		name: "stryker.mutation_test.dry_run_only",
+		attributes: {}
+	},
+	mutationTestEarlyResult: {
+		name: "stryker.mutation_test.early_result",
+		attributes: {}
+	},
+	mutationTestNoTests: {
+		name: "stryker.mutation_test.no_tests",
+		attributes: {}
+	},
+	mutationTestPhase: {
+		name: "mutationTest",
+		attributes: {
+			mutantCount: SpanAttributeCount,
+			skippedMutantCount: SpanAttributeCount,
+			testCount: SpanAttributeCount
+		}
+	},
+	mutationTestPlan: {
+		name: "stryker.mutation_test.plan",
+		attributes: {}
+	},
+	mutationTestPlanMutants: {
+		name: "stryker.mutation_test.plan_mutants",
+		attributes: {}
+	},
+	mutationTestPlanRead: {
+		name: "stryker.mutation_test.plan.read",
+		attributes: {}
+	},
+	mutationTestReadRelativeFiles: {
+		name: "stryker.mutation_test.read_relative_files",
+		attributes: {}
+	},
+	mutationTestSandboxFiles: {
+		name: "stryker.mutation_test.sandbox_files",
+		attributes: {}
+	},
+	outputDrain: {
+		name: "stryker.output.drain",
+		attributes: {}
+	},
+	outputModeProbe: {
+		name: "stryker.output_mode_probe",
+		attributes: {}
+	},
+	outputModeProbeRead: {
+		name: "stryker.outputModeProbe.read",
+		attributes: {}
+	},
+	phaseEntered: {
+		name: "stryker.phase.entered",
+		attributes: {}
+	},
+	pluginLoadLoad: {
+		name: "stryker.plugin_load.load",
+		attributes: {}
+	},
+	pluginLoadLoadPlugin: {
+		name: "stryker.plugin_load.load_plugin",
+		attributes: {}
+	},
+	pluginLoadPackageEntrypoint: {
+		name: "stryker.plugin_load.package_entrypoint",
+		attributes: {}
+	},
+	pluginLoadReport: {
+		name: "stryker.pluginLoad.report",
+		attributes: {}
+	},
+	prepare: {
+		name: "stryker.prepare",
+		attributes: {}
+	},
+	prepareAnnounceSummary: {
+		name: "stryker.prepare.announce-summary",
+		attributes: {}
+	},
+	prepareApply: {
+		name: "stryker.prepare.apply",
+		attributes: {}
+	},
+	prepareGather: {
+		name: "stryker.prepare.gather",
+		attributes: {}
+	},
+	preparePhase: {
+		name: "prepare",
+		attributes: {}
+	},
+	projectFilesRead: {
+		name: "stryker.project_files.read",
+		attributes: {}
+	},
+	projectFilesWriteInto: {
+		name: "stryker.project_files.write-into",
+		attributes: {}
+	},
+	projectRead: {
+		name: "stryker.project_read",
+		attributes: {}
+	},
+	projectReadFromDisk: {
+		name: "stryker.project.read",
+		attributes: {}
+	},
+	reportClearText: {
+		name: "stryker.report.clearText",
+		attributes: {}
+	},
+	reportClearTextWrite: {
+		name: "stryker.report.clearText.write",
+		attributes: {}
+	},
+	reportJson: {
+		name: "stryker.report.json",
+		attributes: {}
+	},
+	reportJsonWrite: {
+		name: "stryker.report.json.write",
+		attributes: {}
+	},
+	reportProgress: {
+		name: "stryker.report.progress",
+		attributes: {}
+	},
+	reportProgressConsume: {
+		name: "stryker.report.progress.consume",
+		attributes: {}
+	},
+	reportProgressConsumeEvent: {
+		name: "stryker.report.progress.consumeEvent",
+		attributes: {}
+	},
+	reporterStreamAttach: {
+		name: "stryker.reporterStream.attach",
+		attributes: {}
+	},
+	reporterStreamCloseStage: {
+		name: "stryker.reporterStream.closeStage",
+		attributes: {}
+	},
+	reporterStreamCurrentReporterInit: {
+		name: "stryker.reporterStream.currentReporterInit",
+		attributes: {}
+	},
+	reporterStreamDetach: {
+		name: "stryker.reporterStream.detach",
+		attributes: {}
+	},
+	reporterStreamEnvironmentTraceInit: {
+		name: "stryker.reporterStream.environmentTraceInit",
+		attributes: {}
+	},
+	reporterStreamOfferToChannel: {
+		name: "stryker.reporterStream.offerToChannel",
+		attributes: {}
+	},
+	reporterStreamSettle: {
+		name: "stryker.reporterStream.settle",
+		attributes: {}
+	},
+	reporterWiringSpawnPluginReporterFactory: {
+		name: "stryker.reporterWiring.spawnPluginReporterFactory",
+		attributes: {}
+	},
+	rerun: {
+		name: "stryker.rerun",
+		attributes: {}
+	},
+	restrictSocket: {
+		name: "restrictSocket",
+		attributes: {}
+	},
+	rpcCapabilities: {
+		name: "rpc.capabilities",
+		attributes: { "rpc.method": SpanAttributeText }
+	},
+	rpcCheck: {
+		name: "rpc.check",
+		attributes: { "rpc.method": SpanAttributeText }
+	},
+	rpcClientCapabilities: {
+		name: "RpcClient.capabilities",
+		attributes: {}
+	},
+	rpcClientCheck: {
+		name: "RpcClient.check",
+		attributes: {}
+	},
+	rpcClientDryRun: {
+		name: "RpcClient.dryRun",
+		attributes: {}
+	},
+	rpcClientFlush: {
+		name: "RpcClient.flush",
+		attributes: {}
+	},
+	rpcClientGroup: {
+		name: "RpcClient.group",
+		attributes: {}
+	},
+	rpcClientInit: {
+		name: "RpcClient.init",
+		attributes: {}
+	},
+	rpcClientMutantRun: {
+		name: "RpcClient.mutantRun",
+		attributes: {}
+	},
+	rpcClientOnEventBatch: {
+		name: "RpcClient.onEventBatch",
+		attributes: {}
+	},
+	rpcDryRun: {
+		name: "rpc.dryRun",
+		attributes: { "rpc.method": SpanAttributeText }
+	},
+	rpcFlush: {
+		name: "rpc.flush",
+		attributes: { "rpc.method": SpanAttributeText }
+	},
+	rpcGroup: {
+		name: "rpc.group",
+		attributes: { "rpc.method": SpanAttributeText }
+	},
+	rpcInit: {
+		name: "rpc.init",
+		attributes: { "rpc.method": SpanAttributeText }
+	},
+	rpcMutantRun: {
+		name: "rpc.mutantRun",
+		attributes: { "rpc.method": SpanAttributeText }
+	},
+	rpcOnEventBatch: {
+		name: "rpc.onEventBatch",
+		attributes: { "rpc.method": SpanAttributeText }
+	},
+	rpcServerCapabilities: {
+		name: "RpcServer.capabilities",
+		attributes: {}
+	},
+	rpcServerCheck: {
+		name: "RpcServer.check",
+		attributes: {}
+	},
+	rpcServerDryRun: {
+		name: "RpcServer.dryRun",
+		attributes: {}
+	},
+	rpcServerFlush: {
+		name: "RpcServer.flush",
+		attributes: {}
+	},
+	rpcServerGroup: {
+		name: "RpcServer.group",
+		attributes: {}
+	},
+	rpcServerInit: {
+		name: "RpcServer.init",
+		attributes: {}
+	},
+	rpcServerMutantRun: {
+		name: "RpcServer.mutantRun",
+		attributes: {}
+	},
+	rpcServerOnEventBatch: {
+		name: "RpcServer.onEventBatch",
+		attributes: {}
+	},
+	runConclude: {
+		name: "stryker.run.conclude",
+		attributes: {}
+	},
+	runConclusionRead: {
+		name: "stryker.run_conclusion.read",
+		attributes: {}
+	},
+	runEventStreamCloseAndDrain: {
+		name: "stryker.runEventStream.closeAndDrain",
+		attributes: {}
+	},
+	runEventStreamDrainFile: {
+		name: "stryker.runEventStream.drainFile",
+		attributes: {}
+	},
+	runEventStreamDrainStoredFile: {
+		name: "stryker.runEventStream.drainStoredFile",
+		attributes: {}
+	},
+	runEventStreamDrainToSinks: {
+		name: "stryker.runEventStream.drainToSinks",
+		attributes: {}
+	},
+	runEventStreamEmitMachineModeOutput: {
+		name: "stryker.runEventStream.emitMachineModeOutput",
+		attributes: {}
+	},
+	runEventStreamMake: {
+		name: "stryker.runEventStream.make",
+		attributes: {}
+	},
+	runEventStreamNullScoreVerdict: {
+		name: "stryker.runEventStream.nullScoreVerdict",
+		attributes: {}
+	},
+	runEventStreamOpen: {
+		name: "stryker.runEventStream.open",
+		attributes: {}
+	},
+	runEventStreamOpenHeader: {
+		name: "stryker.runEventStream.openHeader",
+		attributes: {}
+	},
+	runEventStreamStartDrain: {
+		name: "stryker.runEventStream.startDrain",
+		attributes: {}
+	},
+	runEventStreamTick: {
+		name: "stryker.runEventStream.tick",
+		attributes: {}
+	},
+	runRequest: {
+		name: "stryker.run_request",
+		attributes: {}
+	},
+	runRequestGather: {
+		name: "stryker.run_request.gather",
+		attributes: {}
+	},
+	sandboxAcquire: {
+		name: "stryker.sandbox.acquire",
+		attributes: {}
+	},
+	sandboxBuildRun: {
+		name: "stryker.sandbox.build.run",
+		attributes: {}
+	},
+	sandboxFindNodeModules: {
+		name: "stryker.sandbox.find_node_modules",
+		attributes: {}
+	},
+	sandboxLinkNodeModules: {
+		name: "stryker.sandbox.link_node_modules",
+		attributes: {}
+	},
+	sandboxMakeTempDir: {
+		name: "stryker.sandbox.make_temp_dir",
+		attributes: {}
+	},
+	sandboxMoveDirectory: {
+		name: "stryker.sandbox.move_directory",
+		attributes: {}
+	},
+	sandboxMoveDirectoryContents: {
+		name: "stryker.sandbox.move_directory.contents",
+		attributes: {}
+	},
+	sandboxMoveEntry: {
+		name: "stryker.sandbox.move_entry",
+		attributes: {}
+	},
+	sandboxPreprocessDisableTypeChecks: {
+		name: "stryker.sandbox.preprocess.disable_type_checks",
+		attributes: {}
+	},
+	sandboxRemoveEmptyParent: {
+		name: "stryker.sandbox.remove_empty_parent",
+		attributes: {}
+	},
+	sandboxRemoveTempDir: {
+		name: "stryker.sandbox.remove_temp_dir",
+		attributes: {}
+	},
+	sandboxRestoreOriginal: {
+		name: "stryker.sandbox.restore_original",
+		attributes: {}
+	},
+	sandboxSymlinkJunction: {
+		name: "stryker.sandbox.symlink_junction",
+		attributes: {}
+	},
+	sandboxSymlinkNodeModules: {
+		name: "stryker.sandbox.symlink_node_modules",
+		attributes: {}
+	},
+	sandboxTsconfigRewriteFileArrays: {
+		name: "stryker.sandbox.tsconfig.rewrite-file-arrays",
+		attributes: {}
+	},
+	survivorsAdmission: {
+		name: "stryker.survivors_admission",
+		attributes: {}
+	},
+	survivorsAdmissionGather: {
+		name: "stryker.survivors_admission.gather",
+		attributes: {}
+	},
+	survivorsAdmissionHashSources: {
+		name: "stryker.survivors_admission.hash_sources",
+		attributes: {}
+	},
+	survivorsAdmissionReadPriorReport: {
+		name: "stryker.survivors_admission.read_prior_report",
+		attributes: {}
+	},
+	survivorsAdmissionReadSource: {
+		name: "stryker.survivors_admission.read_source",
+		attributes: {}
+	},
+	survivorsAdmissionResolveOptions: {
+		name: "stryker.survivors_admission.resolve_options",
+		attributes: {}
+	},
+	testRunnerApplyEnvironmentState: {
+		name: "stryker.testRunner.applyEnvironmentState",
+		attributes: {}
+	},
+	testRunnerMaxReusePolicy: {
+		name: "stryker.testRunner.maxReusePolicy",
+		attributes: {}
+	},
+	testRunnerMutantRun: {
+		name: "stryker.testRunner.mutantRun",
+		attributes: {
+			"stryker.mutant.file": Mutant.CanonicalFileName,
+			"stryker.mutant.id": Mutant.MutantId,
+			"stryker.mutant.mutator": Mutant.MutatorName,
+			"stryker.mutant.status": Mutant.MutantStatusSchema,
+			"test.suite.name": SpanAttributeText,
+			"test.suite.run.status": SpanRunStatus,
+			"cicd.pipeline.run.id": SpanAttributeText,
+			"cicd.pipeline.name": SpanAttributeText
+		}
+	},
+	testRunnerReloadEnvironment: {
+		name: "stryker.testRunner.reloadEnvironment",
+		attributes: {}
+	},
+	testRunnerWithEnvironmentReload: {
+		name: "stryker.testRunner.withEnvironmentReload",
+		attributes: {}
+	},
+	testRunnerWithMaxReuse: {
+		name: "stryker.testRunner.withMaxReuse",
+		attributes: {}
+	},
+	typescriptCheckerCheck: {
+		name: "typescript-checker.check",
+		attributes: { "stryker.mutants.count": SpanAttributeCount }
+	},
+	typescriptCheckerCheckMutants: {
+		name: "stryker.typescript_checker.check_mutants",
+		attributes: {}
+	},
+	typescriptCheckerCompilerCheck: {
+		name: "typescript-checker.compiler.check",
+		attributes: {}
+	},
+	typescriptCheckerCompilerClose: {
+		name: "typescript-checker.compiler.close",
+		attributes: {}
+	},
+	typescriptCheckerCompilerDryRun: {
+		name: "typescript-checker.compiler.dryRun",
+		attributes: {}
+	},
+	typescriptCheckerCompilerGroups: {
+		name: "typescript-checker.compiler.groups",
+		attributes: {}
+	},
+	typescriptCheckerCompilerInit: {
+		name: "typescript-checker.compiler.init",
+		attributes: {}
+	},
+	typescriptCheckerCompilerLineAndCharacter: {
+		name: "typescript-checker.compiler.lineAndCharacter",
+		attributes: {}
+	},
+	typescriptCheckerCompilerMake: {
+		name: "typescript-checker.compiler.make",
+		attributes: {}
+	},
+	typescriptCheckerCompilerNodes: {
+		name: "typescript-checker.compiler.nodes",
+		attributes: {}
+	},
+	typescriptCheckerCompilerScoped: {
+		name: "typescript-checker.compiler.scoped",
+		attributes: {}
+	},
+	typescriptCheckerRuntimeMakeChecker: {
+		name: "typescript-checker.runtime.makeChecker",
+		attributes: {}
+	},
+	typescriptCheckerSoloRound: {
+		name: "typescript-checker.soloRound",
+		attributes: { "stryker.mutant.id": Mutant.MutantId }
+	},
+	validateOptions: {
+		name: "stryker.validate_options",
+		attributes: {}
+	},
+	vitestMutantRun: {
+		name: "stryker.vitest.mutant_run",
+		attributes: {}
+	},
+	vitestMutantRunRead: {
+		name: "vitest.mutant_run.read",
+		attributes: {}
+	},
+	vitestRunnerCollectRaw: {
+		name: "vitest.runner.collect_raw",
+		attributes: {}
+	},
+	vitestRunnerCompleteDryRun: {
+		name: "vitest.runner.complete_dry_run",
+		attributes: {}
+	},
+	vitestRunnerCoverageOfFile: {
+		name: "vitest.runner.coverage_of_file",
+		attributes: {}
+	},
+	vitestRunnerMake: {
+		name: "vitest.runner.make",
+		attributes: {}
+	},
+	vitestRuntimeAcquire: {
+		name: "vitest.runtime.acquire",
+		attributes: {}
+	},
+	vitestRuntimeApplyRunFilter: {
+		name: "vitest.runtime.apply_run_filter",
+		attributes: {}
+	},
+	vitestRuntimeClose: {
+		name: "vitest.runtime.close",
+		attributes: {}
+	},
+	vitestRuntimeOpen: {
+		name: "vitest.runtime.open",
+		attributes: {}
+	},
+	vitestRuntimeReadSandboxSelfAliases: {
+		name: "vitest.runtime.read_sandbox_self_aliases",
+		attributes: {}
+	},
+	vitestRuntimeStart: {
+		name: "vitest.runtime.start",
+		attributes: {}
+	},
+	vitestStandbyPoolClaim: {
+		name: "vitest.standby_pool.claim",
+		attributes: {}
+	},
+	vitestStandbyPoolDispose: {
+		name: "vitest.standby_pool.dispose",
+		attributes: {}
+	},
+	vitestStandbyPoolMake: {
+		name: "vitest.standby_pool.make",
+		attributes: {}
+	},
+	vitestStandbyPoolRelease: {
+		name: "vitest.standby_pool.release",
+		attributes: {}
+	},
+	workerIdGeneratorMake: {
+		name: "stryker.worker.idGenerator.make",
+		attributes: {}
+	},
+	workerProtocolFailInFlight: {
+		name: "stryker.worker.protocol.failInFlight",
+		attributes: {}
+	},
+	workerProtocolMake: {
+		name: "stryker.worker.protocol.make",
+		attributes: {}
+	},
+	workerSpawn: {
+		name: "stryker.worker.spawn",
+		attributes: {}
+	}
+};
+const spanMembers = Object.values(Spans);
+const rpcServedSpans = /* @__PURE__ */ new Map([
+	["capabilities", Spans.rpcCapabilities],
+	["check", Spans.rpcCheck],
+	["dryRun", Spans.rpcDryRun],
+	["flush", Spans.rpcFlush],
+	["group", Spans.rpcGroup],
+	["init", Spans.rpcInit],
+	["mutantRun", Spans.rpcMutantRun],
+	["onEventBatch", Spans.rpcOnEventBatch]
+]);
+const rpcServedSpanOf = (method) => rpcServedSpans.get(method);
+//#endregion
+//#region src/SpanTaxonomy/mod.ts
+var SpanTaxonomy_exports = /* @__PURE__ */ __exportAll({
+	SpanAttributeCount: () => SpanAttributeCount,
+	SpanAttributeKey: () => SpanAttributeKey,
+	SpanAttributeText: () => SpanAttributeText,
+	SpanDocument: () => SpanDocument,
+	SpanDocuments: () => SpanDocuments,
+	SpanName: () => SpanName,
+	Spans: () => Spans,
+	rpcServedSpanOf: () => rpcServedSpanOf,
+	spanMembers: () => spanMembers
+});
+//#endregion
+//#region src/StockCatalog.schema.ts
+const StockDefaultName = S.Literals([
+	"ArithmeticOperator",
+	"ArrayDeclaration",
+	"ArrowFunction",
+	"AssignmentOperator",
+	"BlockStatement",
+	"BooleanLiteral",
+	"ConditionalExpression",
+	"EqualityOperator",
+	"LogicalOperator",
+	"MethodExpression",
+	"ObjectLiteral",
+	"OptionalChaining",
+	"Regex",
+	"StringLiteral",
+	"UnaryOperator",
+	"UpdateOperator"
+]);
+const StockOptInName = S.Literals([
+	"AtomicUpdateSplit",
+	"SynchronizationRemoval",
+	"FinalizerEscape"
+]);
+const StockMutatorName = S.Union([StockDefaultName, StockOptInName]);
+const StockCatalog = {
+	provider: "stryker",
+	entries: [
+		{
+			id: "arithmetic-operator",
+			name: "ArithmeticOperator",
+			tier: "default",
+			definition: "A binary arithmetic operator: `+` becomes `-`, `-` becomes `+`, `*` becomes `/`, `/` becomes `*` and `%` becomes `*`. A string or template literal on either side is refused, as is a private name on the left.",
+			examples: [{
+				before: "const x = 1 + 2;",
+				after: ["1 - 2"]
+			}, {
+				before: "const x = 'a' + 'b';",
+				after: []
+			}]
+		},
+		{
+			id: "array-declaration",
+			name: "ArrayDeclaration",
+			tier: "default",
+			definition: "An array literal becomes `[]` and an empty one becomes `['Stryker was here']`; `Array(1, 2)` becomes `Array()` and `Array()` becomes `Array([])`. A call that is not `Array` is refused.",
+			examples: [
+				{
+					before: "const x = [1];",
+					after: ["[]"]
+				},
+				{
+					before: "const x = [];",
+					after: ["[\"Stryker was here\"]"]
+				},
+				{
+					before: "const x = Array(1, 2);",
+					after: ["Array()"]
+				},
+				{
+					before: "const x = Array();",
+					after: ["Array([])"]
+				},
+				{
+					before: "const x = someCall(1, 2);",
+					after: []
+				}
+			]
+		},
+		{
+			id: "arrow-function",
+			name: "ArrowFunction",
+			tier: "default",
+			definition: "An arrow function shorthand body becomes `undefined`. A block body, and a body that already is `undefined`, are refused.",
+			examples: [{
+				before: "const x = () => 1;",
+				after: ["() => undefined"]
+			}, {
+				before: "const x = () => { return 1; };",
+				after: []
+			}]
+		},
+		{
+			id: "assignment-operator",
+			name: "AssignmentOperator",
+			tier: "default",
+			definition: "A compound assignment operator: `+=` becomes `-=`, `*=` becomes `/=`, `%=` becomes `*=`, `<<=` becomes `>>=`, `&=` becomes `|=`, `&&=` becomes `||=` and `??=` becomes `&&=`. A compound assignment whose right side is string-like is refused, except for the logical assignments.",
+			examples: [{
+				before: "let x = 1; x += 2;",
+				after: ["x -= 2"]
+			}, {
+				before: "let s = 'a'; s += 'b';",
+				after: []
+			}]
+		},
+		{
+			id: "block-statement",
+			name: "BlockStatement",
+			tier: "default",
+			definition: "A non-empty block becomes `{}`. An empty block, and a derived constructor body that references `super` while the class initializes properties, are refused.",
+			examples: [{
+				before: "function f() { const x = 1; }",
+				after: ["{}"]
+			}, {
+				before: "function f() {}",
+				after: []
+			}]
+		},
+		{
+			id: "boolean-literal",
+			name: "BooleanLiteral",
+			tier: "default",
+			definition: "`true` becomes `false`, `false` becomes `true`, and a prefix `!` collapses to its operand. A literal that is not a boolean is refused.",
+			examples: [
+				{
+					before: "const x = true;",
+					after: ["false"]
+				},
+				{
+					before: "const x = !a;",
+					after: ["a"]
+				},
+				{
+					before: "const x = 1;",
+					after: []
+				}
+			]
+		},
+		{
+			id: "conditional-expression",
+			name: "ConditionalExpression",
+			tier: "default",
+			definition: "A condition becomes `true` and `false`; a loop test becomes `false`; a condition under `&&` becomes `true` and one under `||` becomes `false`. A statement the rule does not match is refused.",
+			examples: [{
+				before: "if (a) { f(); }",
+				after: ["true", "false"]
+			}, {
+				before: "while (a) { f(); }",
+				after: ["false"]
+			}]
+		},
+		{
+			id: "equality-operator",
+			name: "EqualityOperator",
+			tier: "default",
+			definition: "An ordering comparison becomes its two alternatives (`<` becomes `<=` and `>=`) and an equality comparison flips (`===` becomes `!==`, `!=` becomes `==`).",
+			examples: [{
+				before: "const x = a === b;",
+				after: ["a !== b"]
+			}, {
+				before: "const x = a < b;",
+				after: ["a <= b", "a >= b"]
+			}]
+		},
+		{
+			id: "logical-operator",
+			name: "LogicalOperator",
+			tier: "default",
+			definition: "`&&` becomes `||`, `||` becomes `&&` and `??` becomes `&&`. An expression that is not logical is refused.",
+			examples: [
+				{
+					before: "const x = a && b;",
+					after: ["a || b"]
+				},
+				{
+					before: "const x = a ?? b;",
+					after: ["a && b"]
+				},
+				{
+					before: "const x = a + b;",
+					after: []
+				}
+			]
+		},
+		{
+			id: "method-expression",
+			name: "MethodExpression",
+			tier: "default",
+			definition: "A known method call becomes its opposite (`toLowerCase` becomes `toUpperCase`) or, for a removal method, a call of the object itself (`arr.filter(p)` becomes `arr()`). A `super` call, an unknown method and a string-literal key are refused.",
+			examples: [
+				{
+					before: "const x = \"HELLO\".toLowerCase();",
+					after: ["\"HELLO\".toUpperCase()"]
+				},
+				{
+					before: "const x = arr.filter(p);",
+					after: ["arr()"]
+				},
+				{
+					before: "const x = arr['filter'](p);",
+					after: []
+				}
+			]
+		},
+		{
+			id: "object-literal",
+			name: "ObjectLiteral",
+			tier: "default",
+			definition: "A non-empty object literal becomes `{}`; an empty one is refused.",
+			examples: [{
+				before: "const x = { a: 1 };",
+				after: ["{}"]
+			}, {
+				before: "const x = {};",
+				after: []
+			}]
+		},
+		{
+			id: "optional-chaining",
+			name: "OptionalChaining",
+			tier: "default",
+			definition: "An optional access becomes the plain one: `a?.b` becomes `a.b`, `a?.[k]` becomes `a[k]` and `a?.()` becomes `a()`. A member that is not optional is refused.",
+			examples: [
+				{
+					before: "const x = a?.b;",
+					after: ["a.b"]
+				},
+				{
+					before: "const x = a?.[k];",
+					after: ["a[k]"]
+				},
+				{
+					before: "const x = a.b;",
+					after: []
+				}
+			]
+		},
+		{
+			id: "regex",
+			name: "Regex",
+			tier: "default",
+			definition: "A regular-expression literal, or the string of `new RegExp(...)`, loses anchors, quantifiers, lookarounds or class negations — one mutant per mutation, emitted anchors first. Alternations and groups are refused.",
+			examples: [{
+				before: "const x = /a+/;",
+				after: ["/a/"]
+			}, {
+				before: "const x = /a|b/;",
+				after: []
+			}]
+		},
+		{
+			id: "string-literal",
+			name: "StringLiteral",
+			tier: "default",
+			definition: "A non-empty string becomes `\"\"` and an empty one becomes 'Stryker was here!'; a template literal's first quasi is mutated. A directive, an import or export specifier, a property key, a JSX attribute and a literal type are refused.",
+			examples: [{
+				before: "const x = \"hello\";",
+				after: ["\"\""]
+			}, {
+				before: "'use strict';",
+				after: []
+			}]
+		},
+		{
+			id: "unary-operator",
+			name: "UnaryOperator",
+			tier: "default",
+			definition: "`+x` becomes `-x`, `-x` becomes `+x` and `~x` becomes `x`. `!`, `typeof`, `void` and `delete` are refused.",
+			examples: [
+				{
+					before: "const x = -a;",
+					after: ["+a"]
+				},
+				{
+					before: "const x = ~a;",
+					after: ["a"]
+				},
+				{
+					before: "const x = typeof y;",
+					after: []
+				}
+			]
+		},
+		{
+			id: "update-operator",
+			name: "UpdateOperator",
+			tier: "default",
+			definition: "`++` becomes `--` and `--` becomes `++`, prefix or postfix.",
+			examples: [{
+				before: "let x = 1; x++;",
+				after: ["x--"]
+			}]
+		},
+		{
+			id: "atomic-update-split",
+			name: "AtomicUpdateSplit",
+			tier: "optIn",
+			definition: "A `Ref` or `SynchronizedRef` atomic update — `modify`, `modifySome`, `update`, `updateSome`, `updateAndGet`, `getAndUpdate` — is split into a read, a snapshot update and a write, so a lost update survives. The `Effect` module has to be in scope, and the reference and the handler have to be movable.",
+			examples: [
+				{
+					before: `import { Effect, Ref } from 'effect'
+
+export const bump = (ref: Ref.Ref<number>): Effect.Effect<void> => Ref.update(ref, (n) => n + 1)
+`,
+					after: ["Effect.flatMap(Effect.succeed(ref), self => Effect.flatMap(Ref.get(self), s => Effect.flatMap(Ref.make(s), snap => Effect.flatMap(Ref.update(snap, n => n + 1), b => Effect.flatMap(Effect.yieldNow, () => Effect.flatMap(Ref.get(snap), a => Effect.as(Ref.set(self, a), b)))))))"]
+				},
+				{
+					before: `import { Effect, pipe, Ref } from 'effect'
+
+export const bumpPiped = (ref: Ref.Ref<number>) => pipe(ref, Ref.update((n: number) => n + 1))
+`,
+					after: ["self => Effect.flatMap(Ref.get(self), s => Effect.flatMap(Ref.make(s), snap => Effect.flatMap(Ref.update(snap, (n: number) => n + 1), b => Effect.flatMap(Effect.yieldNow, () => Effect.flatMap(Ref.get(snap), a => Effect.as(Ref.set(self, a), b))))))"]
+				},
+				{
+					before: `import { Ref } from 'effect'
+
+export const withoutEffect = (ref: Ref.Ref<number>) => Ref.update(ref, (n) => n + 1)
+`,
+					after: []
+				}
+			]
+		},
+		{
+			id: "synchronization-removal",
+			name: "SynchronizationRemoval",
+			tier: "optIn",
+			definition: "The lock a call takes is dropped: `Semaphore.withPermits(sem, n, effect)` and `Semaphore.withPermit(sem, effect)` become the guarded effect, their piped forms become `self => self`, `Effect.uninterruptible(effect)` becomes `effect`, and `Effect.uninterruptibleMask(f)` becomes `Effect.suspend(() => f(Effect.interruptible))`. A guard that is not droppable, and a method-form call whose guard is built on the spot, are refused.",
+			examples: [
+				{
+					before: `import { Effect, Semaphore } from 'effect'
+
+export const guarded = (sem: Semaphore.Semaphore, effect: Effect.Effect<number>) =>
+  Semaphore.withPermits(sem, 1, effect)
+`,
+					after: ["effect"]
+				},
+				{
+					before: `import { Effect, pipe } from 'effect'
+
+export const frozen = (effect: Effect.Effect<number>) => pipe(effect, Effect.uninterruptible)
+`,
+					after: ["self => self"]
+				},
+				{
+					before: `import { Effect } from 'effect'
+
+export const masked = (effect: Effect.Effect<number>) => Effect.uninterruptibleMask((restore) => restore(effect))
+`,
+					after: ["Effect.suspend(() => (restore => restore(effect))(Effect.interruptible))"]
+				},
+				{
+					before: `import { Effect, Semaphore } from 'effect'
+
+export const methodForm = (sem: Semaphore.Semaphore, effect: Effect.Effect<number>) =>
+  sem.withPermits(1)(effect)
+`,
+					after: []
+				}
+			]
+		},
+		{
+			id: "finalizer-escape",
+			name: "FinalizerEscape",
+			tier: "optIn",
+			definition: "A finalizer is kept only for the path that did not interrupt: `Effect.ensuring(effect, fin)` re-runs `fin` when the exit was not an interruption, `Effect.onError(effect, h)` re-runs `h` when the cause carries none, a release bracket wraps its release the same way, and `Effect.onInterrupt(effect, h)` drops the handler. A handler built by a call, and a cleanup that yields while it is moved, are refused.",
+			examples: [
+				{
+					before: `import { Effect, Ref } from 'effect'
+
+export const ensuringDataFirst = (effect: Effect.Effect<number>, closed: Ref.Ref<boolean>) =>
+  Effect.ensuring(effect, Ref.set(closed, true))
+`,
+					after: ["Effect.onExitIf(effect, exit => exit._tag === \"Success\" || !exit.cause.reasons.some(reason => reason._tag === \"Interrupt\"), () => Ref.set(closed, true))"]
+				},
+				{
+					before: `import { Effect, Ref } from 'effect'
+
+export const onErrorDataFirst = (effect: Effect.Effect<number>, closed: Ref.Ref<boolean>) =>
+  Effect.onError(effect, () => Ref.set(closed, true))
+`,
+					after: ["Effect.onErrorIf(effect, cause => !cause.reasons.some(reason => reason._tag === \"Interrupt\"), () => Ref.set(closed, true))"]
+				},
+				{
+					before: `import { Effect, Ref } from 'effect'
+
+export const acquireReleaseTwoArg = (acquire: Effect.Effect<number>, closed: Ref.Ref<boolean>) =>
+  Effect.acquireRelease(acquire, () => Ref.getAndSet(closed, true))
+`,
+					after: ["Effect.flatMap(Effect.interruptible(acquire), a => Effect.acquireRelease(Effect.succeed(a), () => Ref.getAndSet(closed, true)))"]
+				},
+				{
+					before: `import { Effect, Ref } from 'effect'
+
+export const acquireUseReleaseBrackets = (
+  acquire: Effect.Effect<number>,
+  use: (a: number) => Effect.Effect<number>,
+  closed: Ref.Ref<boolean>,
+) => Effect.acquireUseRelease(acquire, use, () => Ref.set(closed, true))
+`,
+					after: ["Effect.acquireUseRelease(acquire, use, (a, exit) => exit._tag === \"Success\" || !exit.cause.reasons.some(reason => reason._tag === \"Interrupt\") ? (() => Ref.set(closed, true))() : Effect.void)"]
+				},
+				{
+					before: `import { Effect, Ref } from 'effect'
+
+const ensuring = (effect: Effect.Effect<number>, cleanup: Effect.Effect<void>) => effect
+
+export const localEnsuringRefusal = (effect: Effect.Effect<number>, closed: Ref.Ref<boolean>) =>
+  ensuring(effect, Ref.set(closed, true))
+`,
+					after: []
+				}
+			]
+		}
+	]
+};
+//#endregion
+//#region src/StockCatalog/mod.ts
+var StockCatalog_exports = /* @__PURE__ */ __exportAll({
+	StockCatalog: () => StockCatalog,
+	StockDefaultName: () => StockDefaultName,
+	StockMutatorName: () => StockMutatorName,
+	StockOptInName: () => StockOptInName
+});
+//#endregion
+export { OutputMode_exports as OutputMode, RunEvent_exports as RunEvent, SpanTaxonomy_exports as SpanTaxonomy, StockCatalog_exports as StockCatalog };