@systemfsoftware/stryker-js-cli-contract 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,1470 @@
+import * as S from "effect/Schema";
+import { Schema } from "effect";
+import { MutatorCatalog, Report } from "@systemfsoftware/stryker-js-plugin-interface";
+//#region src/output-mode.schema.d.ts
+declare const OutputMode: S.Literals<readonly ["human", "machine"]>;
+type OutputMode = typeof OutputMode.Type;
+declare const ModeSignal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+type ModeSignal = typeof ModeSignal.Type;
+declare namespace mod_d_exports {
+  export { ModeSignal, OutputMode };
+}
+//#endregion
+//#region src/plugin-load-failure-reason.schema.d.ts
+declare const PluginLoadFailureReason: Schema.Union<readonly [Schema.TaggedStruct<"PeerMissing", {
+  readonly peer: Schema.String;
+}>, Schema.TaggedStruct<"PeerVersionUnsupported", {
+  readonly peer: Schema.String;
+  readonly detail: Schema.String;
+}>, Schema.TaggedStruct<"PeerUnrecognized", {
+  readonly peer: Schema.String;
+}>, Schema.TaggedStruct<"InvalidContribution", {
+  readonly detail: Schema.String;
+}>, Schema.TaggedStruct<"ImportFailed", {
+  readonly cause: Schema.Unknown;
+}>]>;
+type PluginLoadFailureReason = typeof PluginLoadFailureReason.Type;
+//#endregion
+//#region src/run-event.schema.d.ts
+declare const RunPhase: S.Literals<readonly ["prepare", "instrument", "dry-run", "mutation-test"]>;
+type RunPhase = typeof RunPhase.Type;
+declare const RunId: S.brand<S.String, "RunId">;
+type RunId = typeof RunId.Type;
+declare const RunStarted_base: S.Class<RunStarted, S.TaggedStruct<"stream", {
+  readonly schemaVersion: S.Literal<"2.0">;
+  readonly runId: S.brand<S.String, "RunId">;
+  readonly mode: S.Literals<readonly ["human", "machine"]>;
+  readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+}>, {}>;
+declare class RunStarted extends RunStarted_base {}
+declare const PhaseEntered_base: S.Class<PhaseEntered, S.TaggedStruct<"phase", {
+  readonly phase: S.Literals<readonly ["prepare", "instrument", "dry-run", "mutation-test"]>;
+  readonly elapsedMs: S.Finite;
+}>, {}>;
+declare class PhaseEntered extends PhaseEntered_base {}
+declare const PlanKnown_base: S.Class<PlanKnown, S.TaggedStruct<"plan", {
+  readonly total: S.Int;
+}>, {}>;
+declare class PlanKnown extends PlanKnown_base {}
+declare const MutantCost: S.Struct<{
+  readonly fixedOverheadMs: S.Finite;
+  readonly testBodyMs: S.Finite;
+  readonly testsExecuted: S.Int;
+  readonly shared: S.Boolean;
+}>;
+type MutantCost = typeof MutantCost.Type;
+declare const RunMutantTestedEvent_base: S.Class<RunMutantTestedEvent, S.TaggedStruct<"mutantTested", {
+  readonly id: S.brand<S.String, "MutantId">;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+  readonly fileName: S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>;
+  readonly location: S.decodeTo<S.declare<{
+    readonly start: {
+      readonly line: number;
+      readonly column: number;
+    };
+    readonly end: {
+      readonly line: number;
+      readonly column: number;
+    };
+  }, {
+    readonly start: {
+      readonly line: number;
+      readonly column: number;
+    };
+    readonly end: {
+      readonly line: number;
+      readonly column: number;
+    };
+  }>, S.Struct<{
+    readonly start: S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>;
+    readonly end: S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>;
+  }>, never, never>;
+  readonly mutatorName: S.brand<S.String, "MutatorName">;
+  readonly replacement: S.NullOr<S.String>;
+  readonly completed: S.Int;
+  readonly total: S.Int;
+  readonly static: S.Boolean;
+  readonly cost: S.NullOr<S.Struct<{
+    readonly fixedOverheadMs: S.Finite;
+    readonly testBodyMs: S.Finite;
+    readonly testsExecuted: S.Int;
+    readonly 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).
+ */
+declare class RunMutantTestedEvent extends RunMutantTestedEvent_base {}
+type RunMutantTested = RunMutantTestedEvent;
+declare const MutantTestedWireSchema: S.TaggedStruct<"mutant", {
+  readonly id: S.brand<S.String, "MutantId">;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+  readonly file: S.toType<S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>>;
+  readonly location: S.decodeTo<S.declare<{
+    readonly start: {
+      readonly line: number;
+      readonly column: number;
+    };
+    readonly end: {
+      readonly line: number;
+      readonly column: number;
+    };
+  }, {
+    readonly start: {
+      readonly line: number;
+      readonly column: number;
+    };
+    readonly end: {
+      readonly line: number;
+      readonly column: number;
+    };
+  }>, S.Struct<{
+    readonly start: S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>;
+    readonly end: S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>;
+  }>, never, never>;
+  readonly mutator: S.brand<S.String, "MutatorName">;
+  readonly replacement: S.NullOr<S.String>;
+  readonly completed: S.Int;
+  readonly total: S.Int;
+  readonly static: S.Boolean;
+  readonly cost: S.NullOr<S.Struct<{
+    readonly fixedOverheadMs: S.Finite;
+    readonly testBodyMs: S.Finite;
+    readonly testsExecuted: S.Int;
+    readonly shared: S.Boolean;
+  }>>;
+}>;
+declare const RunMutantTested: S.Codec<RunMutantTested, typeof MutantTestedWireSchema.Encoded>;
+declare const Heartbeat_base: S.Class<Heartbeat, S.TaggedStruct<"tick", {
+  readonly elapsedMs: S.Finite;
+  readonly completed: S.Int;
+  readonly total: S.NullOr<S.Int>;
+}>, {}>;
+declare class Heartbeat extends Heartbeat_base {}
+declare const VerdictLocation: S.Struct<{
+  readonly start: S.Struct<{
+    readonly line: S.Int;
+    readonly column: S.Int;
+  }>;
+  readonly end: S.Struct<{
+    readonly line: S.Int;
+    readonly column: S.Int;
+  }>;
+}>;
+type VerdictLocation = typeof VerdictLocation.Type;
+declare const VerdictThresholds: S.Struct<{
+  readonly high: S.Finite;
+  readonly low: S.Finite;
+  readonly break: S.NullOr<S.Finite>;
+}>;
+type VerdictThresholds = typeof VerdictThresholds.Type;
+declare const VerdictMutant: S.Struct<{
+  readonly id: S.String;
+  readonly file: S.String;
+  readonly location: S.Struct<{
+    readonly start: S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>;
+    readonly end: S.Struct<{
+      readonly line: S.Int;
+      readonly column: S.Int;
+    }>;
+  }>;
+  readonly mutator: S.String;
+  readonly replacement: S.NullOr<S.String>;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+}>;
+type VerdictMutant = typeof VerdictMutant.Type;
+type VerdictCounts = Report.Metrics;
+declare const RunScope: S.Literals<readonly ["full", "diff"]>;
+type RunScope = typeof RunScope.Type;
+declare const MutantSetPolicy: S.Literals<readonly ["default", "full"]>;
+type MutantSetPolicy = typeof MutantSetPolicy.Type;
+declare const PhaseDurations: S.Struct<{
+  readonly prepare: S.Finite;
+  readonly instrument: S.Finite;
+  readonly 'dry-run': S.Finite;
+  readonly 'mutation-test': S.Finite;
+}>;
+type PhaseDurations = typeof PhaseDurations.Type;
+declare const StaticVerdict: S.Struct<{
+  readonly count: S.Int;
+  readonly costMs: S.Finite;
+}>;
+type StaticVerdict = typeof StaticVerdict.Type;
+declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdict", {
+  readonly schemaVersion: S.Literal<"2.0">;
+  readonly runId: S.brand<S.String, "RunId">;
+  readonly mode: S.Literals<readonly ["human", "machine"]>;
+  readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+  readonly score: S.NullOr<S.Finite>;
+  readonly thresholds: S.Struct<{
+    readonly high: S.Finite;
+    readonly low: S.Finite;
+    readonly break: S.NullOr<S.Finite>;
+  }>;
+  readonly reportFile: S.NullOr<S.String>;
+  readonly counts: typeof Report.Metrics;
+  readonly mutants: S.$Array<S.Struct<{
+    readonly id: S.String;
+    readonly file: S.String;
+    readonly location: S.Struct<{
+      readonly start: S.Struct<{
+        readonly line: S.Int;
+        readonly column: S.Int;
+      }>;
+      readonly end: S.Struct<{
+        readonly line: S.Int;
+        readonly column: S.Int;
+      }>;
+    }>;
+    readonly mutator: S.String;
+    readonly replacement: S.NullOr<S.String>;
+    readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+  }>>;
+  readonly scope: S.Literals<readonly ["full", "diff"]>;
+  readonly mutantSetPolicy: S.Literals<readonly ["default", "full"]>;
+  readonly phaseDurations: S.NullOr<S.Struct<{
+    readonly prepare: S.Finite;
+    readonly instrument: S.Finite;
+    readonly 'dry-run': S.Finite;
+    readonly 'mutation-test': S.Finite;
+  }>>;
+  readonly static: S.NullOr<S.Struct<{
+    readonly count: S.Int;
+    readonly costMs: S.Finite;
+  }>>;
+}>, {}>;
+declare class VerdictReached extends VerdictReached_base {}
+declare const FrameworkContributionRow: S.Struct<{
+  readonly name: S.String;
+  readonly formatId: S.String;
+  readonly extensions: S.$Array<S.String>;
+}>;
+type FrameworkContributionRow = typeof FrameworkContributionRow.Type;
+declare const FrameworkModuleRow: S.Struct<{
+  readonly moduleName: S.String;
+  readonly contributions: S.$Array<S.Struct<{
+    readonly name: S.String;
+    readonly formatId: S.String;
+    readonly extensions: S.$Array<S.String>;
+  }>>;
+}>;
+type FrameworkModuleRow = typeof FrameworkModuleRow.Type;
+declare const FormatClaimShadowingRow: S.Struct<{
+  readonly extension: S.String;
+  readonly winner: S.String;
+  readonly loser: S.String;
+}>;
+type FormatClaimShadowingRow = typeof FormatClaimShadowingRow.Type;
+declare const PluginsReported_base: S.Class<PluginsReported, S.TaggedStruct<"plugins", {
+  readonly modules: S.$Array<S.Struct<{
+    readonly moduleName: S.String;
+    readonly contributions: S.$Array<S.Struct<{
+      readonly name: S.String;
+      readonly formatId: S.String;
+      readonly extensions: S.$Array<S.String>;
+    }>>;
+  }>>;
+  readonly shadowings: S.$Array<S.Struct<{
+    readonly extension: S.String;
+    readonly winner: S.String;
+    readonly loser: S.String;
+  }>>;
+}>, {}>;
+declare class PluginsReported extends PluginsReported_base {}
+declare const FormatRegistryRow: S.Struct<{
+  readonly extension: S.String;
+  readonly formatId: S.String;
+  readonly ownerModule: S.String;
+  readonly language: S.String;
+}>;
+type FormatRegistryRow = typeof FormatRegistryRow.Type;
+declare const FormatRegistryResolved_base: S.Class<FormatRegistryResolved, S.TaggedStruct<"formats", {
+  readonly rows: S.$Array<S.Struct<{
+    readonly extension: S.String;
+    readonly formatId: S.String;
+    readonly ownerModule: S.String;
+    readonly language: S.String;
+  }>>;
+}>, {}>;
+declare class FormatRegistryResolved extends FormatRegistryResolved_base {}
+declare const SkippedFileRow: S.Struct<{
+  readonly file: S.String;
+  readonly extension: S.String;
+  readonly reason: S.String;
+}>;
+type SkippedFileRow = typeof SkippedFileRow.Type;
+declare const SkippedReported_base: S.Class<SkippedReported, S.TaggedStruct<"skipped", {
+  readonly files: S.$Array<S.Struct<{
+    readonly file: S.String;
+    readonly extension: S.String;
+    readonly reason: S.String;
+  }>>;
+}>, {}>;
+declare class SkippedReported extends SkippedReported_base {}
+declare const ReuseRefusals: S.Struct<{
+  readonly semanticsChanged: S.Int;
+  readonly policyChanged: S.Int;
+  readonly runInputsChanged: S.Int;
+  readonly closureChanged: S.Int;
+  readonly timeoutUnreproduced: S.Int;
+  readonly flakyDependency: S.Int;
+  readonly noPriorRecord: S.Int;
+}>;
+type ReuseRefusals = typeof ReuseRefusals.Type;
+declare const ReuseReported_base: S.Class<ReuseReported, S.TaggedStruct<"reuse", {
+  readonly reused: S.Int;
+  readonly ran: S.Int;
+  readonly refused: S.Struct<{
+    readonly semanticsChanged: S.Int;
+    readonly policyChanged: S.Int;
+    readonly runInputsChanged: S.Int;
+    readonly closureChanged: S.Int;
+    readonly timeoutUnreproduced: S.Int;
+    readonly flakyDependency: S.Int;
+    readonly noPriorRecord: S.Int;
+  }>;
+}>, {}>;
+declare class ReuseReported extends ReuseReported_base {}
+declare const MutantDetailReported_base: S.Class<MutantDetailReported, S.TaggedStruct<"mutant-detail", {
+  readonly id: S.brand<S.String, "MutantId">;
+  readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+  readonly coveringTests: S.$Array<S.String>;
+  readonly killedBy: S.NullOr<S.String>;
+  readonly reproducer: S.NullOr<S.String>;
+}>, {}>;
+declare class MutantDetailReported extends MutantDetailReported_base {}
+declare const FeedbackJudgment: S.Literals<readonly ["useful", "not-useful"]>;
+type FeedbackJudgment = typeof FeedbackJudgment.Type;
+declare const FeedbackReported_base: S.Class<FeedbackReported, S.TaggedStruct<"feedback", {
+  readonly id: S.brand<S.String, "MutantId">;
+  readonly judgment: S.Literals<readonly ["useful", "not-useful"]>;
+  readonly reason: S.NullOr<S.String>;
+}>, {}>;
+declare class FeedbackReported extends FeedbackReported_base {}
+declare const RunFailed_base: S.Class<RunFailed, S.TaggedStruct<"error", {
+  readonly schemaVersion: S.Literal<"2.0">;
+  readonly code: S.Int;
+  readonly error: S.String;
+  readonly remediation: S.String;
+  readonly reason: S.NullOr<S.Union<readonly [S.TaggedStruct<"PeerMissing", {
+    readonly peer: S.String;
+  }>, S.TaggedStruct<"PeerVersionUnsupported", {
+    readonly peer: S.String;
+    readonly detail: S.String;
+  }>, S.TaggedStruct<"PeerUnrecognized", {
+    readonly peer: S.String;
+  }>, S.TaggedStruct<"InvalidContribution", {
+    readonly detail: S.String;
+  }>, S.TaggedStruct<"ImportFailed", {
+    readonly cause: S.Unknown;
+  }>]>>;
+}>, {}>;
+declare class RunFailed extends RunFailed_base {}
+declare const HelpRendered_base: S.Class<HelpRendered, S.TaggedStruct<"help", {
+  readonly schemaVersion: S.Literal<"2.0">;
+  readonly code: S.Literals<readonly [0]>;
+  readonly help: S.String;
+}>, {}>;
+declare class HelpRendered extends HelpRendered_base {}
+declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, S.Codec<RunMutantTestedEvent, {
+  readonly _tag: "mutant";
+  readonly id: string;
+  readonly status: "CompileError" | "Ignored" | "Killed" | "NoCoverage" | "Pending" | "RuntimeError" | "Survived" | "Timeout";
+  readonly file: string & import("effect/Brand").Brand<"CanonicalFileName">;
+  readonly location: {
+    readonly start: {
+      readonly line: number;
+      readonly column: number;
+    };
+    readonly end: {
+      readonly line: number;
+      readonly column: number;
+    };
+  };
+  readonly mutator: string;
+  readonly replacement: string | null;
+  readonly completed: number;
+  readonly total: number;
+  readonly static: boolean;
+  readonly cost: {
+    readonly fixedOverheadMs: number;
+    readonly testBodyMs: number;
+    readonly testsExecuted: number;
+    readonly shared: boolean;
+  } | null;
+}, never, never>, typeof Heartbeat, typeof PluginsReported, typeof FormatRegistryResolved, typeof SkippedReported, typeof ReuseReported, typeof MutantDetailReported, typeof FeedbackReported, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]> & {
+  QUEUE_BOUND: number;
+};
+type RunEvent = typeof RunEvent.Type;
+type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered;
+//#endregion
+//#region src/run-event-wire.schema.d.ts
+declare const RunEventWireLine: S.decodeTo<S.fromJsonString<S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, S.Codec<RunMutantTestedEvent, {
+  readonly _tag: "mutant";
+  readonly id: string;
+  readonly status: "CompileError" | "Ignored" | "Killed" | "NoCoverage" | "Pending" | "RuntimeError" | "Survived" | "Timeout";
+  readonly file: string & import("effect/Brand").Brand<"CanonicalFileName">;
+  readonly location: {
+    readonly start: {
+      readonly line: number;
+      readonly column: number;
+    };
+    readonly end: {
+      readonly line: number;
+      readonly column: number;
+    };
+  };
+  readonly mutator: string;
+  readonly replacement: string | null;
+  readonly completed: number;
+  readonly total: number;
+  readonly static: boolean;
+  readonly cost: {
+    readonly fixedOverheadMs: number;
+    readonly testBodyMs: number;
+    readonly testsExecuted: number;
+    readonly shared: boolean;
+  } | null;
+}, never, never>, typeof Heartbeat, typeof PluginsReported, typeof FormatRegistryResolved, typeof SkippedReported, typeof ReuseReported, typeof MutantDetailReported, typeof FeedbackReported, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]> & {
+  QUEUE_BOUND: number;
+}>, S.String, never, never>;
+type RunEventWireLine = typeof RunEventWireLine.Type;
+//#endregion
+//#region src/stream-version.schema.d.ts
+declare const StreamSchemaVersion: S.Literal<"2.0">;
+type StreamSchemaVersion = typeof StreamSchemaVersion.Type;
+declare namespace mod_d_exports$1 {
+  export { FeedbackJudgment, FeedbackReported, FormatClaimShadowingRow, FormatRegistryResolved, FormatRegistryRow, FrameworkContributionRow, FrameworkModuleRow, Heartbeat, HelpRendered, MutantCost, MutantDetailReported, MutantSetPolicy, PhaseDurations, PhaseEntered, PlanKnown, PluginLoadFailureReason, PluginsReported, ReuseRefusals, ReuseReported, RunEvent, RunEventWireLine, RunFailed, RunId, RunMutantTested, RunMutantTestedEvent, RunPhase, RunScope, RunStarted, RunTerminalEvent, SkippedFileRow, SkippedReported, StaticVerdict, StreamSchemaVersion, VerdictCounts, VerdictLocation, VerdictMutant, VerdictReached, VerdictThresholds };
+}
+//#endregion
+//#region src/SpanTaxonomy.schema.d.ts
+declare const SpanName: S.brand<S.String, "SpanName">;
+type SpanName = typeof SpanName.Type;
+declare const SpanAttributeKey: S.brand<S.String, "SpanAttributeKey">;
+type SpanAttributeKey = typeof SpanAttributeKey.Type;
+/**
+ * One declared span as the taxonomy carries it: its name and the schema of every
+ * attribute its site sets. `id` is not stored because the published document
+ * derives it from the name, so a rename cannot leave a stale identity behind.
+ */
+interface SpanMember {
+  readonly name: string;
+  readonly attributes: Readonly<Record<string, S.Top>>;
+}
+declare const SpanAttributeText: S.String;
+declare const SpanAttributeCount: S.Finite;
+declare const SpanDocument: S.Struct<{
+  readonly id: S.brand<S.String, "SpanName">;
+  readonly name: S.brand<S.String, "SpanName">;
+  readonly attributes: S.$Record<S.brand<S.String, "SpanAttributeKey">, S.Codec<S.Json, S.Json, never, never>>;
+}>;
+type SpanDocument = typeof SpanDocument.Type;
+declare const SpanDocuments: S.$Array<S.Struct<{
+  readonly id: S.brand<S.String, "SpanName">;
+  readonly name: S.brand<S.String, "SpanName">;
+  readonly attributes: S.$Record<S.brand<S.String, "SpanAttributeKey">, S.Codec<S.Json, S.Json, never, never>>;
+}>>;
+type SpanDocuments = typeof SpanDocuments.Type;
+//#endregion
+//#region src/SpanTaxonomy.d.ts
+declare const Spans: {
+  readonly checkerCheck: {
+    readonly name: 'stryker.checker.check';
+    readonly attributes: {
+      readonly 'stryker.checker.name': S.String;
+      readonly 'stryker.mutants.count': S.Finite;
+    };
+  };
+  readonly checkerCheckPlans: {
+    readonly name: 'stryker.checker.check_plans';
+    readonly attributes: {};
+  };
+  readonly checkerGroup: {
+    readonly name: 'stryker.checker.group';
+    readonly attributes: {
+      readonly 'stryker.checker.name': S.String;
+      readonly 'stryker.mutants.count': S.Finite;
+    };
+  };
+  readonly checkerGroupPlans: {
+    readonly name: 'stryker.checker.group_plans';
+    readonly attributes: {};
+  };
+  readonly checkerLogSkipped: {
+    readonly name: 'stryker.checker.log_skipped';
+    readonly attributes: {};
+  };
+  readonly checkerPoolCheckPlans: {
+    readonly name: 'stryker.checker_pool.check_plans';
+    readonly attributes: {};
+  };
+  readonly checkerPoolSplitChecked: {
+    readonly name: 'stryker.checker_pool.split_checked';
+    readonly attributes: {};
+  };
+  readonly checkerRecordSkipped: {
+    readonly name: 'stryker.checker.record_skipped';
+    readonly attributes: {};
+  };
+  readonly cliRun: {
+    readonly name: 'stryker.cli.run';
+    readonly attributes: {
+      readonly 'stryker.run.outcome': S.String;
+      readonly 'stryker.run.exit_code': S.Finite;
+      readonly 'stryker.run.error': S.String;
+    };
+  };
+  readonly commandRunnerRun: {
+    readonly name: 'stryker.command_runner.run';
+    readonly attributes: {};
+  };
+  readonly concurrency: {
+    readonly name: 'stryker.concurrency';
+    readonly attributes: {};
+  };
+  readonly configDiscover: {
+    readonly name: 'stryker.config.discover';
+    readonly attributes: {};
+  };
+  readonly configExists: {
+    readonly name: 'stryker.config.exists';
+    readonly attributes: {};
+  };
+  readonly configExpectedFile: {
+    readonly name: 'stryker.config.expectedFile';
+    readonly attributes: {};
+  };
+  readonly configExtends: {
+    readonly name: 'stryker.config.extends';
+    readonly attributes: {};
+  };
+  readonly configExtendsChild: {
+    readonly name: 'stryker.config.extendsChild';
+    readonly attributes: {};
+  };
+  readonly configExtendsStep: {
+    readonly name: 'stryker.config.extendsStep';
+    readonly attributes: {};
+  };
+  readonly configLoad: {
+    readonly name: 'stryker.config.load';
+    readonly attributes: {};
+  };
+  readonly configLoadOptions: {
+    readonly name: 'stryker.config.loadOptions';
+    readonly attributes: {};
+  };
+  readonly configRead: {
+    readonly name: 'stryker.config_read';
+    readonly attributes: {};
+  };
+  readonly configReadDocument: {
+    readonly name: 'stryker.config.readDocument';
+    readonly attributes: {};
+  };
+  readonly configReadModule: {
+    readonly name: 'stryker.config.readModule';
+    readonly attributes: {};
+  };
+  readonly configReadRun: {
+    readonly name: 'stryker.config.readRun';
+    readonly attributes: {};
+  };
+  readonly dryRun: {
+    readonly name: 'stryker.dry_run';
+    readonly attributes: {};
+  };
+  readonly dryRunComplete: {
+    readonly name: 'stryker.dry_run.complete';
+    readonly attributes: {};
+  };
+  readonly dryRunPhase: {
+    readonly name: 'dryRun';
+    readonly attributes: {};
+  };
+  readonly dryRunResolveFiles: {
+    readonly name: 'stryker.dry_run.resolve_files';
+    readonly attributes: {};
+  };
+  readonly dryRunWriteFailed: {
+    readonly name: 'stryker.dry_run.write_failed';
+    readonly attributes: {};
+  };
+  readonly dryRunWritePassed: {
+    readonly name: 'stryker.dry_run.write_passed';
+    readonly attributes: {};
+  };
+  readonly frameworkClaimantList: {
+    readonly name: 'stryker.framework_claimant.list';
+    readonly attributes: {};
+  };
+  readonly frameworkClaimantOf: {
+    readonly name: 'stryker.framework_claimant.of';
+    readonly attributes: {};
+  };
+  readonly htmlReportReadBundleFromDisk: {
+    readonly name: 'html_report.read_bundle_from_disk';
+    readonly attributes: {};
+  };
+  readonly htmlReportWrite: {
+    readonly name: 'html_report.write';
+    readonly attributes: {};
+  };
+  readonly htmlReportWriteBundleFromDisk: {
+    readonly name: 'html_report.write_bundle_from_disk';
+    readonly attributes: {};
+  };
+  readonly htmlReportWriteFile: {
+    readonly name: 'html_report.write_file';
+    readonly attributes: {};
+  };
+  readonly incrementalReuse: {
+    readonly name: 'stryker.incremental_reuse';
+    readonly attributes: {};
+  };
+  readonly incrementalReuseRead: {
+    readonly name: 'stryker.incremental_reuse.read';
+    readonly attributes: {};
+  };
+  readonly instrument: {
+    readonly name: 'stryker.instrument';
+    readonly attributes: {};
+  };
+  readonly instrumentDisableTypeChecks: {
+    readonly name: 'stryker.instrument.disableTypeChecks';
+    readonly attributes: {};
+  };
+  readonly instrumentFrameworkEntryParse: {
+    readonly name: 'stryker.instrument.framework_entry.parse';
+    readonly attributes: {};
+  };
+  readonly instrumentFrameworkEntryTransform: {
+    readonly name: 'stryker.instrument.framework_entry.transform';
+    readonly attributes: {};
+  };
+  readonly instrumentGather: {
+    readonly name: 'stryker.instrument.gather';
+    readonly attributes: {};
+  };
+  readonly instrumentOfferSkips: {
+    readonly name: 'stryker.instrument.offer-skips';
+    readonly attributes: {};
+  };
+  readonly instrumentParserParseJS: {
+    readonly name: 'stryker.instrument.parser.parseJS';
+    readonly attributes: {};
+  };
+  readonly instrumentParserParseTS: {
+    readonly name: 'stryker.instrument.parser.parseTS';
+    readonly attributes: {};
+  };
+  readonly instrumentParserParseTsx: {
+    readonly name: 'stryker.instrument.parser.parseTsx';
+    readonly attributes: {};
+  };
+  readonly instrumentParserParseWithOxc: {
+    readonly name: 'stryker.instrument.parser.parseWithOxc';
+    readonly attributes: {};
+  };
+  readonly instrumentPhase: {
+    readonly name: 'instrument';
+    readonly attributes: {
+      readonly fileCount: S.Finite;
+    };
+  };
+  readonly instrumentReadFiles: {
+    readonly name: 'stryker.instrument.read_files';
+    readonly attributes: {};
+  };
+  readonly instrumentReportSkips: {
+    readonly name: 'stryker.instrument.report-skips';
+    readonly attributes: {};
+  };
+  readonly instrumentTransformScript: {
+    readonly name: 'stryker.instrument.transform.script';
+    readonly attributes: {};
+  };
+  readonly loadConfig: {
+    readonly name: 'stryker.load_config';
+    readonly attributes: {};
+  };
+  readonly mergeReports: {
+    readonly name: 'stryker.merge_reports';
+    readonly attributes: {};
+  };
+  readonly mergeReportsCollectPartDirs: {
+    readonly name: 'stryker.merge_reports.collect_part_dirs';
+    readonly attributes: {};
+  };
+  readonly mergeReportsDirectoryExists: {
+    readonly name: 'stryker.merge_reports.directory_exists';
+    readonly attributes: {};
+  };
+  readonly mergeReportsEncodeReport: {
+    readonly name: 'stryker.merge_reports.encode_report';
+    readonly attributes: {};
+  };
+  readonly mergeReportsFail: {
+    readonly name: 'stryker.merge_reports.fail';
+    readonly attributes: {};
+  };
+  readonly mergeReportsGather: {
+    readonly name: 'stryker.merge_reports.gather';
+    readonly attributes: {};
+  };
+  readonly mergeReportsListNames: {
+    readonly name: 'stryker.merge_reports.list_names';
+    readonly attributes: {};
+  };
+  readonly mergeReportsPutFile: {
+    readonly name: 'stryker.merge_reports.put_file';
+    readonly attributes: {};
+  };
+  readonly mergeReportsReadPart: {
+    readonly name: 'stryker.merge_reports.read_part';
+    readonly attributes: {};
+  };
+  readonly mergeReportsReadText: {
+    readonly name: 'stryker.merge_reports.read_text';
+    readonly attributes: {};
+  };
+  readonly mergeReportsRefuseCommand: {
+    readonly name: 'stryker.merge_reports.refuse_command';
+    readonly attributes: {};
+  };
+  readonly mergeReportsRefuseParts: {
+    readonly name: 'stryker.merge_reports.refuse_parts';
+    readonly attributes: {};
+  };
+  readonly mergeReportsRenderHtml: {
+    readonly name: 'stryker.merge_reports.render_html';
+    readonly attributes: {};
+  };
+  readonly mergeReportsWriteAbsent: {
+    readonly name: 'stryker.merge_reports.write_absent';
+    readonly attributes: {};
+  };
+  readonly mergeReportsWriteFiles: {
+    readonly name: 'stryker.merge_reports.write_files';
+    readonly attributes: {};
+  };
+  readonly mergeReportsWriteHtml: {
+    readonly name: 'stryker.merge_reports.write_html';
+    readonly attributes: {};
+  };
+  readonly mergeReportsWriteMerged: {
+    readonly name: 'stryker.merge_reports.write_merged';
+    readonly attributes: {};
+  };
+  readonly mutantRun: {
+    readonly name: 'stryker.mutant_run';
+    readonly attributes: {};
+  };
+  readonly mutationReportingAssembleReport: {
+    readonly name: 'stryker.mutationReporting.assembleReport';
+    readonly attributes: {};
+  };
+  readonly mutationReportingCheckpoint: {
+    readonly name: 'stryker.mutationReporting.checkpoint';
+    readonly attributes: {};
+  };
+  readonly mutationReportingDiscoverDependencies: {
+    readonly name: 'stryker.mutationReporting.discoverDependencies';
+    readonly attributes: {};
+  };
+  readonly mutationReportingEmitVerdict: {
+    readonly name: 'stryker.mutationReporting.emitVerdict';
+    readonly attributes: {};
+  };
+  readonly mutationReportingManifestVersion: {
+    readonly name: 'stryker.mutationReporting.manifestVersion';
+    readonly attributes: {};
+  };
+  readonly mutationReportingMutationTestReport: {
+    readonly name: 'stryker.mutationReporting.mutationTestReport';
+    readonly attributes: {};
+  };
+  readonly mutationReportingReadMutatedSources: {
+    readonly name: 'stryker.mutationReporting.readMutatedSources';
+    readonly attributes: {};
+  };
+  readonly mutationReportingReadTestSources: {
+    readonly name: 'stryker.mutationReporting.readTestSources';
+    readonly attributes: {};
+  };
+  readonly mutationReportingReportAll: {
+    readonly name: 'stryker.mutationReporting.reportAll';
+    readonly attributes: {};
+  };
+  readonly mutationReportingSlimIncrementalReport: {
+    readonly name: 'stryker.mutationReporting.slimIncrementalReport';
+    readonly attributes: {};
+  };
+  readonly mutationReportingWriteAtomic: {
+    readonly name: 'stryker.mutationReporting.writeAtomic';
+    readonly attributes: {};
+  };
+  readonly mutationReportingWriteIncrementalReport: {
+    readonly name: 'stryker.mutationReporting.writeIncrementalReport';
+    readonly attributes: {};
+  };
+  readonly mutationTest: {
+    readonly name: 'stryker.mutation_test';
+    readonly attributes: {};
+  };
+  readonly mutationTestBatch: {
+    readonly name: 'mutationTest.batch';
+    readonly attributes: {
+      readonly total: S.Finite;
+      readonly testRunners: S.Finite;
+    };
+  };
+  readonly mutationTestCheckerScope: {
+    readonly name: 'stryker.mutation_test.checker_scope';
+    readonly attributes: {};
+  };
+  readonly mutationTestDryRunOnly: {
+    readonly name: 'stryker.mutation_test.dry_run_only';
+    readonly attributes: {};
+  };
+  readonly mutationTestEarlyResult: {
+    readonly name: 'stryker.mutation_test.early_result';
+    readonly attributes: {};
+  };
+  readonly mutationTestNoTests: {
+    readonly name: 'stryker.mutation_test.no_tests';
+    readonly attributes: {};
+  };
+  readonly mutationTestPhase: {
+    readonly name: 'mutationTest';
+    readonly attributes: {
+      readonly mutantCount: S.Finite;
+      readonly skippedMutantCount: S.Finite;
+      readonly testCount: S.Finite;
+    };
+  };
+  readonly mutationTestPlan: {
+    readonly name: 'stryker.mutation_test.plan';
+    readonly attributes: {};
+  };
+  readonly mutationTestPlanMutants: {
+    readonly name: 'stryker.mutation_test.plan_mutants';
+    readonly attributes: {};
+  };
+  readonly mutationTestPlanRead: {
+    readonly name: 'stryker.mutation_test.plan.read';
+    readonly attributes: {};
+  };
+  readonly mutationTestReadRelativeFiles: {
+    readonly name: 'stryker.mutation_test.read_relative_files';
+    readonly attributes: {};
+  };
+  readonly mutationTestSandboxFiles: {
+    readonly name: 'stryker.mutation_test.sandbox_files';
+    readonly attributes: {};
+  };
+  readonly outputDrain: {
+    readonly name: 'stryker.output.drain';
+    readonly attributes: {};
+  };
+  readonly outputModeProbe: {
+    readonly name: 'stryker.output_mode_probe';
+    readonly attributes: {};
+  };
+  readonly outputModeProbeRead: {
+    readonly name: 'stryker.outputModeProbe.read';
+    readonly attributes: {};
+  };
+  readonly phaseEntered: {
+    readonly name: 'stryker.phase.entered';
+    readonly attributes: {};
+  };
+  readonly pluginLoadLoad: {
+    readonly name: 'stryker.plugin_load.load';
+    readonly attributes: {};
+  };
+  readonly pluginLoadLoadPlugin: {
+    readonly name: 'stryker.plugin_load.load_plugin';
+    readonly attributes: {};
+  };
+  readonly pluginLoadPackageEntrypoint: {
+    readonly name: 'stryker.plugin_load.package_entrypoint';
+    readonly attributes: {};
+  };
+  readonly pluginLoadReport: {
+    readonly name: 'stryker.pluginLoad.report';
+    readonly attributes: {};
+  };
+  readonly prepare: {
+    readonly name: 'stryker.prepare';
+    readonly attributes: {};
+  };
+  readonly prepareAnnounceSummary: {
+    readonly name: 'stryker.prepare.announce-summary';
+    readonly attributes: {};
+  };
+  readonly prepareApply: {
+    readonly name: 'stryker.prepare.apply';
+    readonly attributes: {};
+  };
+  readonly prepareGather: {
+    readonly name: 'stryker.prepare.gather';
+    readonly attributes: {};
+  };
+  readonly preparePhase: {
+    readonly name: 'prepare';
+    readonly attributes: {};
+  };
+  readonly projectFilesRead: {
+    readonly name: 'stryker.project_files.read';
+    readonly attributes: {};
+  };
+  readonly projectFilesWriteInto: {
+    readonly name: 'stryker.project_files.write-into';
+    readonly attributes: {};
+  };
+  readonly projectRead: {
+    readonly name: 'stryker.project_read';
+    readonly attributes: {};
+  };
+  readonly projectReadFromDisk: {
+    readonly name: 'stryker.project.read';
+    readonly attributes: {};
+  };
+  readonly reportClearText: {
+    readonly name: 'stryker.report.clearText';
+    readonly attributes: {};
+  };
+  readonly reportClearTextWrite: {
+    readonly name: 'stryker.report.clearText.write';
+    readonly attributes: {};
+  };
+  readonly reportJson: {
+    readonly name: 'stryker.report.json';
+    readonly attributes: {};
+  };
+  readonly reportJsonWrite: {
+    readonly name: 'stryker.report.json.write';
+    readonly attributes: {};
+  };
+  readonly reportProgress: {
+    readonly name: 'stryker.report.progress';
+    readonly attributes: {};
+  };
+  readonly reportProgressConsume: {
+    readonly name: 'stryker.report.progress.consume';
+    readonly attributes: {};
+  };
+  readonly reportProgressConsumeEvent: {
+    readonly name: 'stryker.report.progress.consumeEvent';
+    readonly attributes: {};
+  };
+  readonly reporterStreamAttach: {
+    readonly name: 'stryker.reporterStream.attach';
+    readonly attributes: {};
+  };
+  readonly reporterStreamCloseStage: {
+    readonly name: 'stryker.reporterStream.closeStage';
+    readonly attributes: {};
+  };
+  readonly reporterStreamCurrentReporterInit: {
+    readonly name: 'stryker.reporterStream.currentReporterInit';
+    readonly attributes: {};
+  };
+  readonly reporterStreamDetach: {
+    readonly name: 'stryker.reporterStream.detach';
+    readonly attributes: {};
+  };
+  readonly reporterStreamEnvironmentTraceInit: {
+    readonly name: 'stryker.reporterStream.environmentTraceInit';
+    readonly attributes: {};
+  };
+  readonly reporterStreamOfferToChannel: {
+    readonly name: 'stryker.reporterStream.offerToChannel';
+    readonly attributes: {};
+  };
+  readonly reporterStreamSettle: {
+    readonly name: 'stryker.reporterStream.settle';
+    readonly attributes: {};
+  };
+  readonly reporterWiringSpawnPluginReporterFactory: {
+    readonly name: 'stryker.reporterWiring.spawnPluginReporterFactory';
+    readonly attributes: {};
+  };
+  readonly rerun: {
+    readonly name: 'stryker.rerun';
+    readonly attributes: {};
+  };
+  readonly restrictSocket: {
+    readonly name: 'restrictSocket';
+    readonly attributes: {};
+  };
+  readonly rpcCapabilities: {
+    readonly name: 'rpc.capabilities';
+    readonly attributes: {
+      readonly 'rpc.method': S.String;
+    };
+  };
+  readonly rpcCheck: {
+    readonly name: 'rpc.check';
+    readonly attributes: {
+      readonly 'rpc.method': S.String;
+    };
+  };
+  readonly rpcClientCapabilities: {
+    readonly name: 'RpcClient.capabilities';
+    readonly attributes: {};
+  };
+  readonly rpcClientCheck: {
+    readonly name: 'RpcClient.check';
+    readonly attributes: {};
+  };
+  readonly rpcClientDryRun: {
+    readonly name: 'RpcClient.dryRun';
+    readonly attributes: {};
+  };
+  readonly rpcClientFlush: {
+    readonly name: 'RpcClient.flush';
+    readonly attributes: {};
+  };
+  readonly rpcClientGroup: {
+    readonly name: 'RpcClient.group';
+    readonly attributes: {};
+  };
+  readonly rpcClientInit: {
+    readonly name: 'RpcClient.init';
+    readonly attributes: {};
+  };
+  readonly rpcClientMutantRun: {
+    readonly name: 'RpcClient.mutantRun';
+    readonly attributes: {};
+  };
+  readonly rpcClientOnEventBatch: {
+    readonly name: 'RpcClient.onEventBatch';
+    readonly attributes: {};
+  };
+  readonly rpcDryRun: {
+    readonly name: 'rpc.dryRun';
+    readonly attributes: {
+      readonly 'rpc.method': S.String;
+    };
+  };
+  readonly rpcFlush: {
+    readonly name: 'rpc.flush';
+    readonly attributes: {
+      readonly 'rpc.method': S.String;
+    };
+  };
+  readonly rpcGroup: {
+    readonly name: 'rpc.group';
+    readonly attributes: {
+      readonly 'rpc.method': S.String;
+    };
+  };
+  readonly rpcInit: {
+    readonly name: 'rpc.init';
+    readonly attributes: {
+      readonly 'rpc.method': S.String;
+    };
+  };
+  readonly rpcMutantRun: {
+    readonly name: 'rpc.mutantRun';
+    readonly attributes: {
+      readonly 'rpc.method': S.String;
+    };
+  };
+  readonly rpcOnEventBatch: {
+    readonly name: 'rpc.onEventBatch';
+    readonly attributes: {
+      readonly 'rpc.method': S.String;
+    };
+  };
+  readonly rpcServerCapabilities: {
+    readonly name: 'RpcServer.capabilities';
+    readonly attributes: {};
+  };
+  readonly rpcServerCheck: {
+    readonly name: 'RpcServer.check';
+    readonly attributes: {};
+  };
+  readonly rpcServerDryRun: {
+    readonly name: 'RpcServer.dryRun';
+    readonly attributes: {};
+  };
+  readonly rpcServerFlush: {
+    readonly name: 'RpcServer.flush';
+    readonly attributes: {};
+  };
+  readonly rpcServerGroup: {
+    readonly name: 'RpcServer.group';
+    readonly attributes: {};
+  };
+  readonly rpcServerInit: {
+    readonly name: 'RpcServer.init';
+    readonly attributes: {};
+  };
+  readonly rpcServerMutantRun: {
+    readonly name: 'RpcServer.mutantRun';
+    readonly attributes: {};
+  };
+  readonly rpcServerOnEventBatch: {
+    readonly name: 'RpcServer.onEventBatch';
+    readonly attributes: {};
+  };
+  readonly runConclude: {
+    readonly name: 'stryker.run.conclude';
+    readonly attributes: {};
+  };
+  readonly runConclusionRead: {
+    readonly name: 'stryker.run_conclusion.read';
+    readonly attributes: {};
+  };
+  readonly runEventStreamCloseAndDrain: {
+    readonly name: 'stryker.runEventStream.closeAndDrain';
+    readonly attributes: {};
+  };
+  readonly runEventStreamDrainFile: {
+    readonly name: 'stryker.runEventStream.drainFile';
+    readonly attributes: {};
+  };
+  readonly runEventStreamDrainStoredFile: {
+    readonly name: 'stryker.runEventStream.drainStoredFile';
+    readonly attributes: {};
+  };
+  readonly runEventStreamDrainToSinks: {
+    readonly name: 'stryker.runEventStream.drainToSinks';
+    readonly attributes: {};
+  };
+  readonly runEventStreamEmitMachineModeOutput: {
+    readonly name: 'stryker.runEventStream.emitMachineModeOutput';
+    readonly attributes: {};
+  };
+  readonly runEventStreamMake: {
+    readonly name: 'stryker.runEventStream.make';
+    readonly attributes: {};
+  };
+  readonly runEventStreamNullScoreVerdict: {
+    readonly name: 'stryker.runEventStream.nullScoreVerdict';
+    readonly attributes: {};
+  };
+  readonly runEventStreamOpen: {
+    readonly name: 'stryker.runEventStream.open';
+    readonly attributes: {};
+  };
+  readonly runEventStreamOpenHeader: {
+    readonly name: 'stryker.runEventStream.openHeader';
+    readonly attributes: {};
+  };
+  readonly runEventStreamStartDrain: {
+    readonly name: 'stryker.runEventStream.startDrain';
+    readonly attributes: {};
+  };
+  readonly runEventStreamTick: {
+    readonly name: 'stryker.runEventStream.tick';
+    readonly attributes: {};
+  };
+  readonly runRequest: {
+    readonly name: 'stryker.run_request';
+    readonly attributes: {};
+  };
+  readonly runRequestGather: {
+    readonly name: 'stryker.run_request.gather';
+    readonly attributes: {};
+  };
+  readonly sandboxAcquire: {
+    readonly name: 'stryker.sandbox.acquire';
+    readonly attributes: {};
+  };
+  readonly sandboxBuildRun: {
+    readonly name: 'stryker.sandbox.build.run';
+    readonly attributes: {};
+  };
+  readonly sandboxFindNodeModules: {
+    readonly name: 'stryker.sandbox.find_node_modules';
+    readonly attributes: {};
+  };
+  readonly sandboxLinkNodeModules: {
+    readonly name: 'stryker.sandbox.link_node_modules';
+    readonly attributes: {};
+  };
+  readonly sandboxMakeTempDir: {
+    readonly name: 'stryker.sandbox.make_temp_dir';
+    readonly attributes: {};
+  };
+  readonly sandboxMoveDirectory: {
+    readonly name: 'stryker.sandbox.move_directory';
+    readonly attributes: {};
+  };
+  readonly sandboxMoveDirectoryContents: {
+    readonly name: 'stryker.sandbox.move_directory.contents';
+    readonly attributes: {};
+  };
+  readonly sandboxMoveEntry: {
+    readonly name: 'stryker.sandbox.move_entry';
+    readonly attributes: {};
+  };
+  readonly sandboxPreprocessDisableTypeChecks: {
+    readonly name: 'stryker.sandbox.preprocess.disable_type_checks';
+    readonly attributes: {};
+  };
+  readonly sandboxRemoveEmptyParent: {
+    readonly name: 'stryker.sandbox.remove_empty_parent';
+    readonly attributes: {};
+  };
+  readonly sandboxRemoveTempDir: {
+    readonly name: 'stryker.sandbox.remove_temp_dir';
+    readonly attributes: {};
+  };
+  readonly sandboxRestoreOriginal: {
+    readonly name: 'stryker.sandbox.restore_original';
+    readonly attributes: {};
+  };
+  readonly sandboxSymlinkJunction: {
+    readonly name: 'stryker.sandbox.symlink_junction';
+    readonly attributes: {};
+  };
+  readonly sandboxSymlinkNodeModules: {
+    readonly name: 'stryker.sandbox.symlink_node_modules';
+    readonly attributes: {};
+  };
+  readonly sandboxTsconfigRewriteFileArrays: {
+    readonly name: 'stryker.sandbox.tsconfig.rewrite-file-arrays';
+    readonly attributes: {};
+  };
+  readonly survivorsAdmission: {
+    readonly name: 'stryker.survivors_admission';
+    readonly attributes: {};
+  };
+  readonly survivorsAdmissionGather: {
+    readonly name: 'stryker.survivors_admission.gather';
+    readonly attributes: {};
+  };
+  readonly survivorsAdmissionHashSources: {
+    readonly name: 'stryker.survivors_admission.hash_sources';
+    readonly attributes: {};
+  };
+  readonly survivorsAdmissionReadPriorReport: {
+    readonly name: 'stryker.survivors_admission.read_prior_report';
+    readonly attributes: {};
+  };
+  readonly survivorsAdmissionReadSource: {
+    readonly name: 'stryker.survivors_admission.read_source';
+    readonly attributes: {};
+  };
+  readonly survivorsAdmissionResolveOptions: {
+    readonly name: 'stryker.survivors_admission.resolve_options';
+    readonly attributes: {};
+  };
+  readonly testRunnerApplyEnvironmentState: {
+    readonly name: 'stryker.testRunner.applyEnvironmentState';
+    readonly attributes: {};
+  };
+  readonly testRunnerMaxReusePolicy: {
+    readonly name: 'stryker.testRunner.maxReusePolicy';
+    readonly attributes: {};
+  };
+  readonly testRunnerMutantRun: {
+    readonly name: 'stryker.testRunner.mutantRun';
+    readonly attributes: {
+      readonly 'stryker.mutant.file': S.decodeTo<S.brand<S.String, "CanonicalFileName">, S.String, never, never>;
+      readonly 'stryker.mutant.id': S.brand<S.String, "MutantId">;
+      readonly 'stryker.mutant.mutator': S.brand<S.String, "MutatorName">;
+      readonly 'stryker.mutant.status': S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+      readonly 'test.suite.name': S.String;
+      readonly 'test.suite.run.status': S.Literals<readonly ["success", "failure", "timed_out", "aborted", "skipped"]>;
+      readonly 'cicd.pipeline.run.id': S.String;
+      readonly 'cicd.pipeline.name': S.String;
+    };
+  };
+  readonly testRunnerReloadEnvironment: {
+    readonly name: 'stryker.testRunner.reloadEnvironment';
+    readonly attributes: {};
+  };
+  readonly testRunnerWithEnvironmentReload: {
+    readonly name: 'stryker.testRunner.withEnvironmentReload';
+    readonly attributes: {};
+  };
+  readonly testRunnerWithMaxReuse: {
+    readonly name: 'stryker.testRunner.withMaxReuse';
+    readonly attributes: {};
+  };
+  readonly typescriptCheckerCheck: {
+    readonly name: 'typescript-checker.check';
+    readonly attributes: {
+      readonly 'stryker.mutants.count': S.Finite;
+    };
+  };
+  readonly typescriptCheckerCheckMutants: {
+    readonly name: 'stryker.typescript_checker.check_mutants';
+    readonly attributes: {};
+  };
+  readonly typescriptCheckerCompilerCheck: {
+    readonly name: 'typescript-checker.compiler.check';
+    readonly attributes: {};
+  };
+  readonly typescriptCheckerCompilerClose: {
+    readonly name: 'typescript-checker.compiler.close';
+    readonly attributes: {};
+  };
+  readonly typescriptCheckerCompilerDryRun: {
+    readonly name: 'typescript-checker.compiler.dryRun';
+    readonly attributes: {};
+  };
+  readonly typescriptCheckerCompilerGroups: {
+    readonly name: 'typescript-checker.compiler.groups';
+    readonly attributes: {};
+  };
+  readonly typescriptCheckerCompilerInit: {
+    readonly name: 'typescript-checker.compiler.init';
+    readonly attributes: {};
+  };
+  readonly typescriptCheckerCompilerLineAndCharacter: {
+    readonly name: 'typescript-checker.compiler.lineAndCharacter';
+    readonly attributes: {};
+  };
+  readonly typescriptCheckerCompilerMake: {
+    readonly name: 'typescript-checker.compiler.make';
+    readonly attributes: {};
+  };
+  readonly typescriptCheckerCompilerNodes: {
+    readonly name: 'typescript-checker.compiler.nodes';
+    readonly attributes: {};
+  };
+  readonly typescriptCheckerCompilerScoped: {
+    readonly name: 'typescript-checker.compiler.scoped';
+    readonly attributes: {};
+  };
+  readonly typescriptCheckerRuntimeMakeChecker: {
+    readonly name: 'typescript-checker.runtime.makeChecker';
+    readonly attributes: {};
+  };
+  readonly typescriptCheckerSoloRound: {
+    readonly name: 'typescript-checker.soloRound';
+    readonly attributes: {
+      readonly 'stryker.mutant.id': S.brand<S.String, "MutantId">;
+    };
+  };
+  readonly validateOptions: {
+    readonly name: 'stryker.validate_options';
+    readonly attributes: {};
+  };
+  readonly vitestMutantRun: {
+    readonly name: 'stryker.vitest.mutant_run';
+    readonly attributes: {};
+  };
+  readonly vitestMutantRunRead: {
+    readonly name: 'vitest.mutant_run.read';
+    readonly attributes: {};
+  };
+  readonly vitestRunnerCollectRaw: {
+    readonly name: 'vitest.runner.collect_raw';
+    readonly attributes: {};
+  };
+  readonly vitestRunnerCompleteDryRun: {
+    readonly name: 'vitest.runner.complete_dry_run';
+    readonly attributes: {};
+  };
+  readonly vitestRunnerCoverageOfFile: {
+    readonly name: 'vitest.runner.coverage_of_file';
+    readonly attributes: {};
+  };
+  readonly vitestRunnerMake: {
+    readonly name: 'vitest.runner.make';
+    readonly attributes: {};
+  };
+  readonly vitestRuntimeAcquire: {
+    readonly name: 'vitest.runtime.acquire';
+    readonly attributes: {};
+  };
+  readonly vitestRuntimeApplyRunFilter: {
+    readonly name: 'vitest.runtime.apply_run_filter';
+    readonly attributes: {};
+  };
+  readonly vitestRuntimeClose: {
+    readonly name: 'vitest.runtime.close';
+    readonly attributes: {};
+  };
+  readonly vitestRuntimeOpen: {
+    readonly name: 'vitest.runtime.open';
+    readonly attributes: {};
+  };
+  readonly vitestRuntimeReadSandboxSelfAliases: {
+    readonly name: 'vitest.runtime.read_sandbox_self_aliases';
+    readonly attributes: {};
+  };
+  readonly vitestRuntimeStart: {
+    readonly name: 'vitest.runtime.start';
+    readonly attributes: {};
+  };
+  readonly vitestStandbyPoolClaim: {
+    readonly name: 'vitest.standby_pool.claim';
+    readonly attributes: {};
+  };
+  readonly vitestStandbyPoolDispose: {
+    readonly name: 'vitest.standby_pool.dispose';
+    readonly attributes: {};
+  };
+  readonly vitestStandbyPoolMake: {
+    readonly name: 'vitest.standby_pool.make';
+    readonly attributes: {};
+  };
+  readonly vitestStandbyPoolRelease: {
+    readonly name: 'vitest.standby_pool.release';
+    readonly attributes: {};
+  };
+  readonly workerIdGeneratorMake: {
+    readonly name: 'stryker.worker.idGenerator.make';
+    readonly attributes: {};
+  };
+  readonly workerProtocolFailInFlight: {
+    readonly name: 'stryker.worker.protocol.failInFlight';
+    readonly attributes: {};
+  };
+  readonly workerProtocolMake: {
+    readonly name: 'stryker.worker.protocol.make';
+    readonly attributes: {};
+  };
+  readonly workerSpawn: {
+    readonly name: 'stryker.worker.spawn';
+    readonly attributes: {};
+  };
+};
+declare const spanMembers: ReadonlyArray<SpanMember>;
+declare const rpcServedSpanOf: (method: string) => SpanMember | undefined;
+declare namespace mod_d_exports$2 {
+  export { SpanAttributeCount, SpanAttributeKey, SpanAttributeText, SpanDocument, SpanDocuments, SpanMember, SpanName, Spans, rpcServedSpanOf, spanMembers };
+}
+//#endregion
+//#region src/StockCatalog.d.ts
+declare const StockCatalog: typeof MutatorCatalog.Catalog.Encoded;
+//#endregion
+//#region src/StockCatalog.schema.d.ts
+declare const StockDefaultName: S.Literals<readonly ["ArithmeticOperator", "ArrayDeclaration", "ArrowFunction", "AssignmentOperator", "BlockStatement", "BooleanLiteral", "ConditionalExpression", "EqualityOperator", "LogicalOperator", "MethodExpression", "ObjectLiteral", "OptionalChaining", "Regex", "StringLiteral", "UnaryOperator", "UpdateOperator"]>;
+type StockDefaultName = typeof StockDefaultName.Type;
+declare const StockOptInName: S.Literals<readonly ["AtomicUpdateSplit", "SynchronizationRemoval", "FinalizerEscape"]>;
+type StockOptInName = typeof StockOptInName.Type;
+declare const StockMutatorName: S.Union<readonly [S.Literals<readonly ["ArithmeticOperator", "ArrayDeclaration", "ArrowFunction", "AssignmentOperator", "BlockStatement", "BooleanLiteral", "ConditionalExpression", "EqualityOperator", "LogicalOperator", "MethodExpression", "ObjectLiteral", "OptionalChaining", "Regex", "StringLiteral", "UnaryOperator", "UpdateOperator"]>, S.Literals<readonly ["AtomicUpdateSplit", "SynchronizationRemoval", "FinalizerEscape"]>]>;
+type StockMutatorName = typeof StockMutatorName.Type;
+declare namespace mod_d_exports$3 {
+  export { StockCatalog, StockDefaultName, StockMutatorName, StockOptInName };
+}
+//#endregion
+export { mod_d_exports as OutputMode, mod_d_exports$1 as RunEvent, mod_d_exports$2 as SpanTaxonomy, mod_d_exports$3 as StockCatalog };