@systemfsoftware/stryker-js 3.0.2 → 5.0.0

package/dist/index.d.mts

@@ -1,8 +1,1009 @@
-import { i as Checker_d_exports } from "./Checker-A8o5B3Ub.mjs";
-import { X as TestRunner_d_exports, v as Mutant_d_exports } from "./Mutant-Ci25PsWA.mjs";
-import { r as Ignorer_d_exports } from "./Ignorer-BUY68FZQ.mjs";
-import { a as Schema_d_exports } from "./Schema-4oCWQ0P0.mjs";
-import { s as Plugin_d_exports } from "./Plugin-BtItMchw.mjs";
-import { n as Reporter_d_exports } from "./Reporter-C7ysGxqX.mjs";
-import { a as Run_d_exports } from "./Run-BUpNSmcM.mjs";
-export { Checker_d_exports as Checker, Ignorer_d_exports as Ignorer, Mutant_d_exports as Mutant, Plugin_d_exports as Plugin, Reporter_d_exports as Reporter, Run_d_exports as Run, Schema_d_exports as Schema, TestRunner_d_exports as TestRunner };
+import * as Cause from 'effect/Cause';
+import { Cell } from '@systemfsoftware/effect-cell-types';
+import { CheckResult } from '@systemfsoftware/stryker-js-plugin-interface';
+import * as ChildProcessSpawner from 'effect/unstable/process/ChildProcessSpawner';
+import { CompleteDryRunResult } from '@systemfsoftware/stryker-js-plugin-interface';
+import * as Context from 'effect/Context';
+import { CoverageData } from '@systemfsoftware/stryker-js-instrumenter/mutants';
+import * as DateTime from 'effect/DateTime';
+import { DryRunOptions } from '@systemfsoftware/stryker-js-plugin-interface';
+import { DryRunResult } from '@systemfsoftware/stryker-js-plugin-interface';
+import * as Duration from 'effect/Duration';
+import { Duration as Duration_2 } from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import { ExitClass } from '@systemfsoftware/stryker-js-plugin-interface';
+import { FileDescription } from '@systemfsoftware/stryker-js-instrumenter/mutants';
+import { FileDescriptions } from '@systemfsoftware/stryker-js-instrumenter/mutants';
+import { FileResult } from '@systemfsoftware/stryker-js-plugin-interface';
+import * as FileSystem from 'effect/FileSystem';
+import * as HashMap from 'effect/HashMap';
+import { Ignorer } from '@systemfsoftware/stryker-ignorer-interface';
+import * as Layer from 'effect/Layer';
+import { Metrics } from '@systemfsoftware/stryker-js-plugin-interface';
+import { MetricsResult } from '@systemfsoftware/stryker-js-plugin-interface';
+import * as MutableHashMap from 'effect/MutableHashMap';
+import * as MutableHashSet from 'effect/MutableHashSet';
+import { Mutant } from '@systemfsoftware/stryker-js-instrumenter/mutants';
+import { MutantResult } from '@systemfsoftware/stryker-js-plugin-interface';
+import { MutantRunOptions } from '@systemfsoftware/stryker-js-instrumenter/mutants';
+import { MutantRunResult } from '@systemfsoftware/stryker-js-plugin-interface';
+import * as mutants from '@systemfsoftware/stryker-js-instrumenter/mutants';
+import { MutantStatus } from '@systemfsoftware/stryker-js-instrumenter/mutants';
+import { MutateDescription } from '@systemfsoftware/stryker-js-instrumenter/mutants';
+import { MutationTestResult } from '@systemfsoftware/stryker-js-plugin-interface';
+import { PartialStrykerOptions } from '@systemfsoftware/stryker-js-plugin-interface';
+import * as Path from 'effect/Path';
+import { PlatformError } from 'effect/PlatformError';
+import * as Queue from 'effect/Queue';
+import { ReporterFactory } from '@systemfsoftware/stryker-js-plugin-interface';
+import { ReporterRpcs } from '@systemfsoftware/stryker-js-plugin-interface';
+import * as Rpc from 'effect/unstable/rpc/Rpc';
+import * as RpcClient from 'effect/unstable/rpc/RpcClient';
+import { RpcClientError } from 'effect/unstable/rpc/RpcClientError';
+import * as RpcGroup from 'effect/unstable/rpc/RpcGroup';
+import { RunMutantResult } from '@systemfsoftware/stryker-js-instrumenter/mutants';
+import { RunPlan } from '@systemfsoftware/stryker-js-instrumenter/mutants';
+import * as S from 'effect/Schema';
+import * as Schedule from 'effect/Schedule';
+import { Schema } from 'effect';
+import * as schema from '@systemfsoftware/stryker-js-plugin-interface';
+import * as Scope from 'effect/Scope';
+import * as Socket from 'effect/unstable/socket/Socket';
+import * as Stdio from 'effect/Stdio';
+import { StrykerOptions } from '@systemfsoftware/stryker-js-plugin-interface';
+import { TestResult } from '@systemfsoftware/stryker-js-plugin-interface';
+import { TestRunnerCapabilities } from '@systemfsoftware/stryker-js-plugin-interface';
+import { TestRunnerFailed } from '@systemfsoftware/stryker-js-plugin-interface';
+import { WorkerPluginKind } from '@systemfsoftware/stryker-js-plugin-interface';
+import { YieldableError } from 'effect/Cause';
+
+export declare const ACTIONABLE_STATUSES: readonly ['Survived', 'NoCoverage', 'Timeout', 'RuntimeError'];
+
+declare type AnyPluginDescriptor = AnyWorkerPluginDescriptor | EvaluatorPluginDescriptor;
+
+declare type AnyWorkerPluginDescriptor = { [K in WorkerPluginKind]: WorkerPluginDescriptor<K>; }[WorkerPluginKind];
+
+declare type AnyWorkerPluginSource = { [K in WorkerPluginKind]: WorkerPluginSource<K>; }[WorkerPluginKind];
+
+export declare const buildTestRunner: <ChildRunnerError>(context: TestRunnerBuildContext, childProcessRunner: Effect.Effect<PooledTestRunner, ChildRunnerError, Scope.Scope | WorkerLauncher>) => Effect.Effect<PooledTestRunner, PooledTestRunnerError | ChildRunnerError, ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Scope.Scope | WorkerLauncher>;
+
+export declare function buildVerdictEnvelope(report: schema.MutationTestResult, mode: OutputMode, signal: ModeSignal, runId: string, basePath: string, pathService: Path.Path): VerdictEnvelope;
+
+export declare const calculateMetrics: (files: Readonly<Record<string, FileResult>>) => MetricsResult;
+
+declare class CheckerAnsweredUnrequested extends CheckerAnsweredUnrequested_base {}
+
+declare const CheckerAnsweredUnrequested_base: S.Class<CheckerAnsweredUnrequested, S.TaggedStruct<"CheckerAnsweredUnrequested", {
+    readonly checkerName: S.String;
+    readonly phase: S.Literals<readonly ["check", "group"]>;
+    readonly unrequestedIds: S.$Array<S.String>;
+    readonly requestedIds: S.$Array<S.String>;
+}>, YieldableError>;
+
+declare type CheckerContractBroken = CheckerAnsweredUnrequested | CheckerSkippedRequested;
+
+declare type CheckerCrash = ChildProcessCrashedError | OutOfMemoryError;
+
+/**
+ * A checker held by the pool.
+ *
+ * The pool must be able to interrupt a checker mid-call when the run is
+ * cancelled, so the port uses Effect, which can be interrupted, where a Promise
+ * cannot. The error channel names both crash variants rather than `unknown`,
+ * which lets the retry combinator prove it handles every one of them.
+ */
+export declare interface CheckerResourceService {
+    readonly check: (checkerName: string, mutants: readonly Mutant[]) => Effect.Effect<Record<string, CheckResult>, CheckerCrash>;
+    /**
+     * Partition mutants into groups that can be checked together.
+     *
+     * A checker with no grouping opinion returns one group per mutant — the
+     * identity partition — rather than leaving the member off, which is what
+     * every call site used to synthesise for itself.
+     */
+    readonly group: (checkerName: string, mutants: readonly Mutant[]) => Effect.Effect<readonly (readonly string[])[], CheckerCrash>;
+}
+
+declare class CheckerSkippedRequested extends CheckerSkippedRequested_base {}
+
+declare const CheckerSkippedRequested_base: S.Class<CheckerSkippedRequested, S.TaggedStruct<"CheckerSkippedRequested", {
+    readonly checkerName: S.String;
+    readonly phase: S.Literals<readonly ["check", "group"]>;
+    readonly missingIds: S.$Array<S.String>;
+}>, YieldableError>;
+
+export declare const checkGroupedPlans: (checker: CheckerResourceService, checkerName: string, plans: readonly RunPlan[]) => Effect.Effect<readonly (readonly [RunPlan, CheckResult])[], CheckerCrash | CheckerContractBroken>;
+
+/**
+ * The child process hosting a worker ended when it was not supposed to.
+ */
+export declare class ChildProcessCrashedError extends ChildProcessCrashedError_base {
+    readonly exitClass: 'InternalError';
+}
+
+declare const ChildProcessCrashedError_base: Schema.Class<ChildProcessCrashedError, Schema.TaggedStruct<"ChildProcessCrashedError", {
+    readonly pid: Schema.Int;
+    readonly exit: Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.Literals<readonly ["Code"]>;
+        readonly code: Schema.Int;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.Literals<readonly ["Signal"]>;
+        readonly signal: Schema.String;
+    }>]>;
+    readonly cause: Schema.optional<Schema.String>;
+}>, YieldableError>;
+
+export declare const classifyWorkerExit: (pid: number, exitCode: number) => ChildProcessCrashedError | OutOfMemoryError;
+
+export declare interface CompiledTests {
+    readonly fileName: string;
+    readonly script: VmScript;
+}
+
+export declare const CONFIG_SYNTAX_HELP: string;
+
+export declare const ConfigDocumentSchema: S.$Record<S.String, S.Unknown>;
+
+declare interface ConfigEnv {
+    readonly command: 'run' | 'merge-reports';
+    readonly isDryRun: boolean;
+    readonly mode: OutputMode;
+    readonly isCi: boolean;
+}
+
+export declare class ConfigError extends ConfigError_base {
+    readonly exitClass: 'ConfigError';
+}
+
+declare const ConfigError_base: S.Class<ConfigError, S.TaggedStruct<"ConfigError", {
+    readonly message: S.String;
+}>, YieldableError>;
+
+export declare class ConfigFileInvalidError extends ConfigFileInvalidError_base {
+    readonly exitClass: 'ConfigError';
+}
+
+declare const ConfigFileInvalidError_base: S.Class<ConfigFileInvalidError, S.TaggedStruct<"ConfigFileInvalidError", {
+    readonly file: S.String;
+    readonly cause: S.Unknown;
+}>, YieldableError>;
+
+export declare class ConfigFileNotFoundError extends ConfigFileNotFoundError_base {
+    readonly exitClass: 'ConfigError';
+}
+
+declare const ConfigFileNotFoundError_base: S.Class<ConfigFileNotFoundError, S.TaggedStruct<"ConfigFileNotFoundError", {
+    readonly file: S.String;
+}>, YieldableError>;
+
+export declare class ConfigFileUnreadableError extends ConfigFileUnreadableError_base {
+    readonly exitClass: 'ConfigError';
+}
+
+declare const ConfigFileUnreadableError_base: S.Class<ConfigFileUnreadableError, S.TaggedStruct<"ConfigFileUnreadableError", {
+    readonly file: S.String;
+    readonly cause: S.Unknown;
+}>, YieldableError>;
+
+export declare class ConfigFileUnsupportedError extends ConfigFileUnsupportedError_base {
+    readonly exitClass: 'ConfigError';
+    get message(): string;
+}
+
+declare const ConfigFileUnsupportedError_base: S.Class<ConfigFileUnsupportedError, S.TaggedStruct<"ConfigFileUnsupportedError", {
+    readonly file: S.String;
+    readonly hint: S.String;
+}>, YieldableError>;
+
+export declare interface ConfigInvocation {
+    readonly command: 'run' | 'merge-reports';
+    readonly mode: OutputMode;
+}
+
+export declare const connectRetry: Schedule.Schedule<Duration_2, unknown, never, never>;
+
+export declare const countMutants: (mutants: readonly MutantResult[]) => Metrics;
+
+export declare const createDefaultOptions: Effect.Effect<StrykerOptions>;
+
+export declare function createFileMatcher(pattern: boolean | string, pathService: Path.Path, allowHiddenFiles?: boolean): (fileName: string) => boolean;
+
+export declare const decideExtendsStep: (state: ExtendsStepState, document: PartialStrykerOptions, file: string, pathService: Path.Path) => ExtendsStepDecision;
+
+export declare function deepFreeze<T>(target: T): Immutable<T>;
+
+export declare const defaultOptions: Effect.Effect<Immutable<StrykerOptions>, never, never>;
+
+export declare function describeErrors(error: S.SchemaError): string[];
+
+declare const DoneTag: {
+    readonly _tag: 'done';
+};
+
+declare type DoneTag = typeof DoneTag;
+
+export declare interface DryRunDone extends InstrumentDone {
+    readonly dryRunResult: CompleteDryRunResult;
+    readonly testCoverage: TestCoverage;
+    readonly timeOverhead: Duration.Duration;
+}
+
+export declare type EnginePorts = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | Path.Path | Stdio.Stdio | WorkerLauncher;
+
+declare interface EvaluatorPluginDescriptor {
+    readonly kind: 'Evaluator';
+    readonly name: string;
+}
+
+declare interface EvaluatorPluginSource {
+    readonly kind: 'Evaluator';
+    readonly name: string;
+    readonly modulePath: string;
+}
+
+export declare const EXIT_CODE: Record<ExitClass, number>;
+
+export { ExitClass }
+
+export declare const extendsPropertySchema: S.optionalKey<S.String>;
+
+export declare type ExtendsRefusalReason = 'cycle' | 'non-string-extends';
+
+export declare type ExtendsStepDecision = (DoneTag & {
+    readonly options: PartialStrykerOptions;
+}) | (ReadTag & {
+    readonly path: string;
+    readonly state: ExtendsStepState;
+}) | (ResolveTag & {
+    readonly specifier: string;
+    readonly state: ExtendsStepState;
+}) | (RefusedTag & {
+    readonly reason: ExtendsRefusalReason;
+    readonly file: string;
+});
+
+export declare interface ExtendsStepDocument {
+    readonly path: string;
+    readonly options: PartialStrykerOptions;
+}
+
+export declare interface ExtendsStepState {
+    readonly visited: readonly string[];
+    readonly documents: readonly ExtendsStepDocument[];
+}
+
+export declare function findUnserializables(thing: unknown): UnserializableDescription[] | undefined;
+
+export declare const forkCoreSchema: Record<string, unknown>;
+
+export declare const forkOptionsSchema: S.StructWithRest<S.Struct<{
+    readonly allowConsoleColors: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly buildCommand: S.optional<S.String>;
+    readonly checkers: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly checkerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly concurrency: S.optional<S.Union<readonly [S.Finite, S.String]>>;
+    readonly commandRunner: S.withDecodingDefaultKey<S.StructWithRest<S.Struct<{
+        readonly command: S.withDecodingDefaultKey<S.String, never>;
+    }>, readonly [S.$Record<S.String, S.Unknown>]>, never>;
+    readonly coverageAnalysis: S.withDecodingDefaultKey<S.Literals<readonly ["off", "all", "perTest"]>, never>;
+    readonly clearTextReporter: S.withDecodingDefaultKey<S.StructWithRest<S.Struct<{
+        readonly allowColor: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly allowEmojis: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly logTests: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly maxTestsToLog: S.withDecodingDefaultKey<S.Finite, never>;
+        readonly reportTests: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly reportMutants: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly reportScoreTable: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly skipFull: S.withDecodingDefaultKey<S.Boolean, never>;
+    }>, readonly [S.$Record<S.String, S.Unknown>]>, never>;
+    readonly dryRunOnly: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly ignorePatterns: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly ignoreStatic: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly incremental: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly incrementalFile: S.withDecodingDefaultKey<S.String, never>;
+    readonly progressStreamFile: S.withDecodingDefaultKey<S.String, never>;
+    readonly force: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly fileLogLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
+    readonly inPlace: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly logLevel: S.withDecodingDefaultKey<S.Literals<readonly ["off", "fatal", "error", "warn", "info", "debug", "trace"]>, never>;
+    readonly maxConcurrentTestRunners: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly maxTestRunnerReuse: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly mutate: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly mutator: S.withDecodingDefaultKey<S.Struct<{
+        readonly excludedMutations: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    }>, never>;
+    readonly packageManager: S.optional<S.Literals<readonly ["npm", "yarn", "pnpm"]>>;
+    readonly plugins: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly appendPlugins: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly reporters: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly htmlReporter: S.withDecodingDefaultKey<S.Struct<{
+        readonly fileName: S.withDecodingDefaultKey<S.String, never>;
+    }>, never>;
+    readonly jsonReporter: S.withDecodingDefaultKey<S.Struct<{
+        readonly fileName: S.withDecodingDefaultKey<S.String, never>;
+    }>, never>;
+    readonly disableTypeChecks: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean, S.String]>, never>;
+    readonly symlinkNodeModules: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly tempDirName: S.withDecodingDefaultKey<S.String, never>;
+    readonly cleanTempDir: S.withDecodingDefaultKey<S.Literals<readonly ["always", false, true]>, never>;
+    readonly testRunner: S.withDecodingDefaultKey<S.String, never>;
+    readonly testRunnerNodeArgs: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly thresholds: S.withDecodingDefaultKey<S.Struct<{
+        readonly high: S.withDecodingDefaultKey<S.Finite, never>;
+        readonly low: S.withDecodingDefaultKey<S.Finite, never>;
+        readonly break: S.withDecodingDefaultKey<S.NullOr<S.Finite>, never>;
+    }>, never>;
+    readonly timeoutFactor: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly timeoutMS: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly dryRunTimeoutMinutes: S.withDecodingDefaultKey<S.Finite, never>;
+    readonly tsconfigFile: S.withDecodingDefaultKey<S.String, never>;
+    readonly warnings: S.withDecodingDefaultKey<S.Union<readonly [S.Boolean, S.StructWithRest<S.Struct<{
+        readonly unknownOptions: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly preprocessorErrors: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly unserializableOptions: S.withDecodingDefaultKey<S.Boolean, never>;
+        readonly slow: S.withDecodingDefaultKey<S.Boolean, never>;
+    }>, readonly [S.$Record<S.String, S.Unknown>]>]>, never>;
+    readonly disableBail: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly allowEmpty: S.withDecodingDefaultKey<S.Boolean, never>;
+    readonly ignorers: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly testFiles: S.withDecodingDefaultKey<S.$Array<S.String>, never>;
+    readonly survivorsPriorReport: S.optionalKey<S.String>;
+    readonly extends: S.optionalKey<S.String>;
+}>, readonly [S.$Record<S.String, S.Unknown>]>;
+
+export declare function generateRunId(now: DateTime.Utc): string;
+
+export declare class Heartbeat extends Heartbeat_base {}
+
+declare const Heartbeat_base: S.Class<Heartbeat, S.TaggedStruct<"tick", {
+    readonly elapsedMs: S.Finite;
+    readonly completed: S.Finite;
+    readonly total: S.NullOr<S.Finite>;
+}>, {}>;
+
+export declare class HelpRendered extends HelpRendered_base {}
+
+declare const HelpRendered_base: S.Class<HelpRendered, S.TaggedStruct<"help", {
+    readonly schemaVersion: S.String;
+    readonly code: S.Literals<readonly [0]>;
+    readonly help: S.String;
+}>, {}>;
+
+export declare function highestExitClass(pending: Iterable<ExitClass>): ExitClass | null;
+
+declare class IdGenerator extends IdGenerator_base {}
+
+declare const IdGenerator_base: Context.ServiceClass<IdGenerator, "@systemfsoftware/stryker-js/Worker/IdGenerator", IdGeneratorShape>;
+
+declare interface IdGeneratorShape {
+    readonly next: Effect.Effect<number>;
+}
+
+export declare type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U> ? ReadonlyArray<Immutable<U>> : T extends Map<infer K, infer V> ? ReadonlyMap<Immutable<K>, Immutable<V>> : T extends Set<infer M> ? ReadonlySet<Immutable<M>> : T extends RegExp ? Readonly<RegExp> : { readonly [K in keyof T]: Immutable<T[K]>; };
+
+declare type ImmutablePrimitive = Primitive | ((...args: never[]) => unknown);
+
+export declare const ImportedModuleSchema: S.Struct<{
+    readonly default: S.optional<S.Unknown>;
+}>;
+
+export declare function importModule(moduleName: string): Effect.Effect<unknown, StrykerError>;
+
+export declare const IncrementalReportSchema: S.StructWithRest<S.Struct<{
+    readonly schemaVersion: S.String;
+    readonly thresholds: S.Struct<{
+        readonly high: S.Finite;
+        readonly low: S.Finite;
+    }>;
+    readonly files: S.$Record<S.String, S.Struct<{
+        readonly language: S.String;
+        readonly source: S.String;
+        readonly mutants: S.$Array<S.Struct<{
+            readonly id: S.String;
+            readonly mutatorName: S.String;
+            readonly replacement: S.String;
+            readonly location: S.Struct<{
+                readonly start: S.Struct<{
+                    readonly line: S.Finite;
+                    readonly column: S.Finite;
+                }>;
+                readonly end: S.Struct<{
+                    readonly line: S.Finite;
+                    readonly column: S.Finite;
+                }>;
+            }>;
+            readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "Timeout", "CompileError", "RuntimeError", "Ignored", "Pending"]>;
+            readonly killedBy: S.optional<S.$Array<S.String>>;
+            readonly coveredBy: S.optional<S.$Array<S.String>>;
+            readonly static: S.optional<S.Boolean>;
+            readonly statusReason: S.optional<S.String>;
+            readonly testsCompleted: S.optional<S.Finite>;
+            readonly description: S.optional<S.String>;
+            readonly duration: S.optional<S.Finite>;
+        }>>;
+    }>>;
+    readonly testFiles: S.optional<S.$Record<S.String, S.Struct<{
+        readonly source: S.optional<S.String>;
+        readonly tests: S.$Array<S.Struct<{
+            readonly id: S.String;
+            readonly name: S.String;
+            readonly location: S.optional<S.Struct<{
+                readonly start: S.Struct<{
+                    readonly line: S.Finite;
+                    readonly column: S.Finite;
+                }>;
+                readonly end: S.optional<S.Struct<{
+                    readonly line: S.Finite;
+                    readonly column: S.Finite;
+                }>>;
+            }>>;
+        }>>;
+    }>>>;
+}>, readonly [S.$Record<S.String, S.Unknown>]>;
+
+export declare const initialExtendsStepState: ExtendsStepState;
+
+export declare interface InstrumentDone extends PrepareDone {
+    readonly mutants: readonly Mutant[];
+    readonly sandbox: SandboxHandle;
+    readonly concurrency: {
+        readonly testRunners: number;
+        readonly checkers: number;
+    };
+}
+
+export declare function isActionableStatus(status: MutantStatus): boolean;
+
+/** Whether a configured runner name selects this runner. */
+export declare const isCommandRunner: (name: string) => name is 'command';
+
+export declare function isModuleSpecifier(value: string): boolean;
+
+export declare const isVmRunner: (name: string) => name is 'vm';
+
+export declare function isWarningEnabled(warningType: KnownKeys<WarningOptions>, warningOptions: WarningOptions | boolean): boolean;
+
+declare type KnownKeys<T> = keyof { [P in keyof T as string extends P ? never : number extends P ? never : P]: T[P]; };
+
+export declare const loadConfigCell: typeof readConfig;
+
+declare interface LoadedPlugins {
+    readonly schemaContributions: readonly Record<string, unknown>[];
+    readonly pluginsByKind: HashMap.HashMap<PluginKind, readonly PluginDescriptor[]>;
+    readonly pluginModulePaths: readonly string[];
+    readonly pluginSources: readonly PluginSource[];
+    readonly ignorers: readonly Ignorer[];
+}
+
+export declare const makeRunLayer: (env: RunEnvironmentShape, events?: Queue.Queue<RunEvent, Cause.Done>) => Layer.Layer<RunStageServices, never, EnginePorts>;
+
+export declare const makeWorkerClient: <Rpcs extends Rpc.Any>(params: WorkerClientParams<Rpcs>) => Effect.Effect<RpcClient.RpcClient<Rpcs, RpcClientError>, WorkerBootError, Scope.Scope | WorkerLauncher>;
+
+export declare function matchesFile(pattern: boolean | string, fileName: string, pathService: Path.Path, allowHiddenFiles?: boolean): boolean;
+
+export declare class MergeCommand extends MergeCommand_base {}
+
+declare const MergeCommand_base: S.Class<MergeCommand, S.TaggedStruct<"MergeCommand", {
+    readonly base: S.$Record<S.String, S.Unknown>;
+    readonly overrides: S.$Record<S.String, S.Unknown>;
+}>, {}>;
+
+export declare function mergeConfigs(parent: PartialStrykerOptions, child: PartialStrykerOptions): PartialStrykerOptions;
+
+export declare class MergeResult extends MergeResult_base {}
+
+declare const MergeResult_base: S.Class<MergeResult, S.TaggedStruct<"MergeResult", {
+    readonly merged: S.$Record<S.String, S.Unknown>;
+}>, {}>;
+
+export declare type ModeSignal = 'flag' | 'env' | 'tty' | 'agent' | 'tool';
+
+export declare const mutationTestCell: Cell.Cell<PrepareExecutorArgs, MutationTestDone, StageError, StageServices>;
+
+export declare interface MutationTestDone {
+    readonly results: readonly RunMutantResult[];
+    readonly verdict: ExitClass | null;
+}
+
+export declare const optionsPath: (...path: string[]) => string;
+
+export declare class OutOfMemoryError extends OutOfMemoryError_base {
+    readonly exitClass: 'RuntimeError';
+}
+
+declare const OutOfMemoryError_base: Schema.Class<OutOfMemoryError, Schema.TaggedStruct<"OutOfMemoryError", {
+    readonly pid: Schema.Int;
+    readonly exitCode: Schema.Int;
+}>, YieldableError>;
+
+/**
+ * Mode type vocabulary shared with the CLI package. Runtime resolution
+ * (`resolveMode`) and gate functions (`isProgressEnabled`, `isColorEnabled`)
+ * live in the CLI; the `ResolvedMode` fields (`mode`, `signal`,
+ * `stdoutIsTTY`) ride along in `VerdictEnvelope` (`verdict-envelope.ts`),
+ * so the types stay where the data does.
+ */
+export declare type OutputMode = 'human' | 'machine';
+
+export declare class PhaseEntered extends PhaseEntered_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;
+}>, {}>;
+
+export declare class PlanKnown extends PlanKnown_base {}
+
+declare const PlanKnown_base: S.Class<PlanKnown, S.TaggedStruct<"plan", {
+    readonly total: S.Finite;
+}>, {}>;
+
+declare type PluginDescriptor<K extends PluginKind = PluginKind> = PluginDescriptorOf<K>;
+
+declare type PluginDescriptorOf<K extends PluginKind> = Extract<AnyPluginDescriptor, {
+    readonly kind: K;
+}>;
+
+declare type PluginKind = WorkerPluginKind | 'Evaluator';
+
+declare type PluginSource = AnyWorkerPluginSource | EvaluatorPluginSource;
+
+/**
+ * A test runner in a child process, whose calls can fail the way a child process
+ * fails.
+ *
+ * Wider than `TestRunnerService` on purpose. That port's error channel is
+ * `TestRunnerFailed`, which is right for a runner living in this process — but
+ * folding a crash into it erases the tag a pool retires a worker on, so
+ * `Pool.invalidate` could never fire and a dead worker would be handed out again.
+ * A `WorkerMethodError` is the runner genuinely failing and does become a
+ * `TestRunnerFailed`; a crash or an OOM is the worker dying, and stays itself.
+ */
+export declare interface PooledTestRunner {
+    readonly capabilities: Effect.Effect<TestRunnerCapabilities, PooledTestRunnerError>;
+    readonly init: Effect.Effect<void, PooledTestRunnerError>;
+    readonly dryRun: (options: DryRunOptions) => Effect.Effect<DryRunResult, PooledTestRunnerError>;
+    readonly mutantRun: (options: MutantRunOptions) => Effect.Effect<MutantRunResult, PooledTestRunnerError>;
+}
+
+/** How a call on a pooled worker can fail. */
+export declare type PooledTestRunnerError = TestRunnerFailed | ChildProcessCrashedError | OutOfMemoryError;
+
+export declare interface PrepareDone {
+    readonly project: Project;
+    readonly loadedPlugins: LoadedPlugins;
+    readonly ignorers: readonly Ignorer[];
+    readonly options: StrykerOptions;
+    readonly temporaryDirectoryPath: string;
+    readonly reporterStage: ReporterStage;
+}
+
+export declare interface PrepareExecutorArgs {
+    cliOptions: PartialStrykerOptions;
+    targetMutatePatterns: string[] | undefined;
+}
+
+export declare type Primitive = boolean | number | string | null | undefined;
+
+declare interface Project {
+    readonly fileDescriptions: FileDescriptions;
+    readonly incrementalReport: MutationTestResult | undefined;
+    readonly testFiles: readonly string[];
+    readonly files: MutableHashMap.MutableHashMap<string, ProjectFile>;
+    readonly filesToMutate: MutableHashMap.MutableHashMap<string, ProjectFile>;
+}
+
+declare interface ProjectFile extends FileDescription {
+    readonly name: string;
+    readonly mutate: MutateDescription;
+    readonly content: string | undefined;
+    readonly originalContent: string | undefined;
+}
+
+export declare function readConfig(cliOptions: PartialStrykerOptions, invocation: ConfigInvocation): Effect.Effect<StrykerOptions, ConfigFileNotFoundError | ConfigFileUnreadableError | ConfigFileInvalidError | ConfigFileUnsupportedError, FileSystem.FileSystem | Path.Path>;
+
+export declare class ReadConfigCommand extends ReadConfigCommand_base {}
+
+declare const ReadConfigCommand_base: S.Class<ReadConfigCommand, S.TaggedStruct<"ReadConfigCommand", {
+    readonly cliOptions: S.$Record<S.String, S.Unknown>;
+    readonly basePath: S.String;
+}>, {}>;
+
+declare const ReadTag: {
+    readonly _tag: 'read';
+};
+
+declare type ReadTag = typeof ReadTag;
+
+declare const RefusedTag: {
+    readonly _tag: 'refused';
+};
+
+declare type RefusedTag = typeof RefusedTag;
+
+export declare const REPORTER_EVENT_BATCH_BOUND = 128;
+
+/**
+ * An attached reporter stage, opaque at the engine boundary: the published
+ * phase types carry this handle so the attachment machinery (queues, fibers,
+ * the state latch) never reaches an adopter's compiler. Constructed only by
+ * `attachReporterFactories`.
+ */
+declare interface ReporterStage {
+    readonly [ReporterStageTypeId]: typeof ReporterStageTypeId;
+}
+
+declare const ReporterStageTypeId: unique symbol;
+
+export declare type ReporterWorkerClient = RpcClient.RpcClient<RpcGroup.Rpcs<typeof ReporterRpcs>, RpcClientError>;
+
+export declare const reporterWorkerFactory: (client: ReporterWorkerClient) => ReporterFactory;
+
+export declare interface ResolvedMode {
+    readonly mode: OutputMode;
+    readonly signal: ModeSignal;
+    readonly stdoutIsTTY: boolean;
+}
+
+export declare function resolveExitCode(pending: Iterable<ExitClass>, signal: number | null): number;
+
+export declare function resolveExtends(configFile: string, document: PartialStrykerOptions, configEnv: ConfigEnv): Effect.Effect<PartialStrykerOptions, ConfigFileUnreadableError | ConfigFileInvalidError | ConfigFileUnsupportedError, Path.Path>;
+
+declare const ResolveTag: {
+    readonly _tag: 'resolve';
+};
+
+declare type ResolveTag = typeof ResolveTag;
+
+export declare const RUN_EVENTS_QUEUE_BOUND = 256;
+
+export declare class RunEnvironment extends RunEnvironment_base {}
+
+declare const RunEnvironment_base: Context.ServiceClass<RunEnvironment, "@systemfsoftware/stryker-js/run/RunEnvironment", RunEnvironmentShape>;
+
+export declare interface RunEnvironmentShape {
+    readonly runId: string;
+    readonly resolvedMode: ResolvedMode;
+    readonly runStartedAt: number;
+    readonly basePath: string;
+    readonly builtinReporters: Readonly<Record<string, ReporterFactory>>;
+    readonly allowConsoleColors: boolean;
+}
+
+export declare const RunEvent: S.Union<readonly [typeof RunStarted, typeof PhaseEntered, typeof PlanKnown, typeof RunMutantTested, typeof Heartbeat, typeof VerdictReached, typeof RunFailed, typeof HelpRendered]>;
+
+export declare type RunEvent = typeof RunEvent.Type;
+
+export declare class RunEvents extends RunEvents_base {}
+
+declare const RunEvents_base: Context.ServiceClass<RunEvents, "@systemfsoftware/stryker-js/RunEvents", Queue.Queue<Heartbeat | HelpRendered | PhaseEntered | PlanKnown | RunFailed | RunMutantTested | RunStarted | VerdictReached, Cause.Done<void>>>;
+
+export declare class RunFailed extends RunFailed_base {}
+
+declare const RunFailed_base: S.Class<RunFailed, S.TaggedStruct<"error", {
+    readonly schemaVersion: S.String;
+    readonly code: S.Finite;
+    readonly error: S.String;
+    readonly remediation: S.String;
+}>, {}>;
+
+export declare class RunIdentity extends RunIdentity_base {}
+
+declare const RunIdentity_base: Context.ServiceClass<RunIdentity, "@systemfsoftware/stryker-js/RunEvents/RunIdentity", RunIdentityShape>;
+
+export declare interface RunIdentityShape {
+    readonly runId: string;
+    readonly basePath: string;
+}
+
+export declare class RunMutantTested extends RunMutantTested_base {}
+
+declare const RunMutantTested_base: S.Class<RunMutantTested, S.TaggedStruct<"mutant", {
+    readonly id: S.String;
+    readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+    readonly file: S.String;
+    readonly location: S.Struct<{
+        readonly start: S.Struct<{
+            readonly line: S.Finite;
+            readonly column: S.Finite;
+        }>;
+        readonly end: S.Struct<{
+            readonly line: S.Finite;
+            readonly column: S.Finite;
+        }>;
+    }>;
+    readonly mutator: S.String;
+    readonly replacement: S.NullOr<S.String>;
+    readonly completed: S.Finite;
+    readonly total: S.Finite;
+}>, {}>;
+
+export declare const RunPhase: S.Literals<readonly ["prepare", "instrument", "dry-run", "mutation-test"]>;
+
+export declare type RunPhase = typeof RunPhase.Type;
+
+export declare type RunStageServices = RunEnvironment | RunEvents | IdGenerator | Scope.Scope;
+
+export declare class RunStarted extends RunStarted_base {}
+
+declare const RunStarted_base: S.Class<RunStarted, S.TaggedStruct<"stream", {
+    readonly schemaVersion: S.String;
+    readonly runId: S.String;
+    readonly mode: S.Literals<readonly ["human", "machine"]>;
+    readonly signal: S.Literals<readonly ["flag", "env", "tty", "agent", "tool"]>;
+}>, {}>;
+
+export declare type RunTerminalEvent = VerdictReached | RunFailed | HelpRendered;
+
+declare interface SandboxHandle {
+    readonly workingDirectory: string;
+    readonly sandboxFileFor: (fileName: string) => string;
+    readonly originalFileFor: (sandboxFileName: string) => string;
+}
+
+export declare const shouldKeepTempDir: (exit: Exit.Exit<unknown, unknown>, cleanTempDir: 'always' | boolean) => boolean;
+
+export declare interface SpawnedSocketWorker {
+    readonly pid: number;
+    readonly clientLayer: Layer.Layer<RpcClient.Protocol, Socket.SocketError>;
+    readonly exited: Effect.Effect<never, WorkerExit>;
+}
+
+export declare const spawnReporterWorker: (params: SpawnReporterWorkerParams) => Effect.Effect<ReporterWorkerClient, WorkerBootError, Scope.Scope | WorkerLauncher>;
+
+export declare interface SpawnReporterWorkerParams {
+    readonly entrypoint: string;
+    readonly projectBasePath: string;
+    readonly execArgv: readonly string[];
+    readonly options: StrykerOptions;
+    readonly tempDirPrefix: string;
+}
+
+export declare class StageError extends StageError_base {
+    readonly [TypeId]: "~stryker/mutation-run/StageError";
+    get exitClass(): ExitClass;
+    get message(): string;
+}
+
+declare const StageError_base: S.Class<StageError, S.TaggedStruct<"StageError", {
+    readonly stage: S.Literals<readonly ["prepare", "instrument", "dryRun", "dryRunNoTests", "mutationTest"]>;
+    readonly reason: S.String;
+    readonly cause: S.optional<S.Defect>;
+    readonly command: S.optional<S.String>;
+}>, YieldableError>;
+
+declare type StageServices = ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem | IdGenerator | Path.Path | RunEnvironment | RunEvents | Scope.Scope | Stdio.Stdio | WorkerLauncher;
+
+export declare const strykerCell: (options: PartialStrykerOptions, targetMutatePatterns?: readonly string[]) => Effect.Effect<MutationTestDone, StageError | PlatformError, FileSystem.FileSystem | Path.Path | Stdio.Stdio>;
+
+export declare class StrykerError extends StrykerError_base {}
+
+declare const StrykerError_base: Schema.Class<StrykerError, Schema.TaggedStruct<"StrykerError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Unknown>;
+}>, YieldableError>;
+
+export declare type StrykerRun = (options: PartialStrykerOptions, targetMutatePatterns?: string[]) => Effect.Effect<MutationTestDone, StageError, never>;
+
+export declare const strykerVersion: string;
+
+export declare const SUPPORTED_CONFIG_FILE_NAMES: readonly string[];
+
+export declare const survivorsPriorReport: S.optionalKey<S.String>;
+
+declare interface TestCoverage {
+    readonly testsByMutantId: MutableHashMap.MutableHashMap<string, MutableHashSet.MutableHashSet<TestResult>>;
+    readonly testsById: MutableHashMap.MutableHashMap<string, TestResult>;
+    readonly staticCoverage: CoverageData | undefined;
+    readonly hitsByMutantId: MutableHashMap.MutableHashMap<string, number>;
+}
+
+/** What building a runner for this run needs. */
+export declare interface TestRunnerBuildContext {
+    readonly options: StrykerOptions;
+    readonly fileDescriptions: FileDescriptions;
+    readonly sandboxWorkingDirectory: string;
+    readonly idGenerator: IdGeneratorShape;
+    /**
+     * Retire this runner's worker. Supplied by whoever owns the worker's
+     * lifetime — the pool — so a combinator never restarts a process the pool
+     * still believes it owns.
+     */
+    readonly retire: Effect.Effect<void>;
+    readonly testFiles: readonly string[];
+}
+
+export declare const toRelativeNormalizedFileName: (fileName: string | undefined, basePath: string) => string;
+
+declare const TypeId: '~stryker/mutation-run/StageError';
+
+export declare interface UnserializableDescription {
+    path: string[];
+    reason: string;
+}
+
+export declare function validateOptions(options: Record<string, unknown>, schema: ValidationSchemaDocument): Effect.Effect<StrykerOptions, ConfigError>;
+
+export declare type ValidationSchemaDocument = {
+    readonly properties?: unknown;
+    readonly [key: string]: unknown;
+};
+
+export declare const VERDICT_ENVELOPE_SCHEMA_VERSION = "1.1";
+
+export declare interface VerdictCounts {
+    readonly killed: number;
+    readonly timeout: number;
+    readonly survived: number;
+    readonly noCoverage: number;
+    readonly runtimeErrors: number;
+    readonly compileErrors: number;
+    readonly ignored: number;
+    readonly pending: number;
+}
+
+export declare interface VerdictEnvelope {
+    readonly schemaVersion: string;
+    readonly runId: string;
+    readonly mode: OutputMode;
+    readonly signal: ModeSignal;
+    readonly score: number | null;
+    readonly thresholds: VerdictThresholds;
+    readonly counts: VerdictCounts;
+    readonly reportFile: string | null;
+    readonly mutants: readonly VerdictMutant[];
+}
+
+export declare function verdictExitClass(score: number | null, breakingThreshold: number | null): ExitClass | null;
+
+export declare interface VerdictMutant {
+    readonly id: string;
+    readonly file: string;
+    readonly location: mutants.Location;
+    readonly mutator: string;
+    readonly replacement: string | null;
+    readonly status: MutantStatus;
+}
+
+export declare class VerdictReached extends VerdictReached_base {}
+
+declare const VerdictReached_base: S.Class<VerdictReached, S.TaggedStruct<"verdict", {
+    readonly schemaVersion: S.String;
+    readonly runId: S.String;
+    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: S.Struct<{
+        readonly killed: S.Finite;
+        readonly timeout: S.Finite;
+        readonly survived: S.Finite;
+        readonly noCoverage: S.Finite;
+        readonly runtimeErrors: S.Finite;
+        readonly compileErrors: S.Finite;
+        readonly ignored: S.Finite;
+        readonly pending: S.Finite;
+    }>;
+    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.Finite;
+                readonly column: S.Finite;
+            }>;
+            readonly end: S.Struct<{
+                readonly line: S.Finite;
+                readonly column: S.Finite;
+            }>;
+        }>;
+        readonly mutator: S.String;
+        readonly replacement: S.NullOr<S.String>;
+        readonly status: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+    }>>;
+}>, {}>;
+
+export declare interface VerdictThresholds {
+    readonly high: number;
+    readonly low: number;
+    readonly break: number | null;
+}
+
+export declare interface VmModule {
+    readonly createContext: (sandbox: object) => object;
+    readonly Script: new (code: string, options?: {
+        readonly filename?: string;
+    }) => VmScript;
+}
+
+export declare interface VmModuleBuiltin {
+    readonly createRequire: (fileName: string | URL) => VmRequire;
+    readonly stripTypeScriptTypes: (source: string, options?: {
+        readonly mode?: 'strip' | 'transform';
+    }) => string;
+}
+
+export declare interface VmPlatform {
+    readonly module: VmModuleBuiltin;
+    readonly vm: VmModule;
+}
+
+declare type VmRequire = (specifier: string) => unknown;
+
+export declare class VmRunner extends VmRunner_base {}
+
+declare const VmRunner_base: Context.ServiceClass<VmRunner, "@systemfsoftware/stryker-js/VmRunner", VmPlatform>;
+
+export declare const vmRunnerCapabilities: {
+    readonly reloadEnvironment: true;
+};
+
+export declare const vmRunnerName = "vm";
+
+export declare interface VmScript {
+    readonly runInContext: (context: object) => unknown;
+}
+
+export declare const vmTestRunner: (config: VmTestRunnerConfig) => Effect.Effect<PooledTestRunner, TestRunnerFailed, FileSystem.FileSystem | VmRunner>;
+
+export declare interface VmTestRunnerConfig {
+    readonly testFiles: readonly string[];
+}
+
+export declare type WarningOptions = Exclude<StrykerOptions['warnings'], boolean>;
+
+export declare type WiredRunLayer = Layer.Layer<RunStageServices | EnginePorts, never, never>;
+
+export declare type WorkerBootError = WorkerExit | WorkerBootTimeoutError;
+
+export declare class WorkerBootTimeoutError extends WorkerBootTimeoutError_base {
+    readonly exitClass: 'InternalError';
+}
+
+declare const WorkerBootTimeoutError_base: Schema.Class<WorkerBootTimeoutError, Schema.TaggedStruct<"WorkerBootTimeoutError", {
+    readonly pid: Schema.Int;
+}>, YieldableError>;
+
+export declare interface WorkerClientParams<Rpcs extends Rpc.Any> extends WorkerSpawnParams {
+    readonly rpcs: RpcGroup.RpcGroup<Rpcs>;
+}
+
+export declare type WorkerExit = ChildProcessCrashedError | OutOfMemoryError;
+
+export declare class WorkerLauncher extends WorkerLauncher_base {}
+
+declare const WorkerLauncher_base: Context.ServiceClass<WorkerLauncher, "@systemfsoftware/stryker-js/WorkerLauncher", WorkerLauncherShape>;
+
+export declare interface WorkerLauncherShape {
+    readonly spawn: (params: WorkerSpawnParams) => Effect.Effect<SpawnedSocketWorker, ChildProcessCrashedError, Scope.Scope>;
+}
+
+declare interface WorkerPluginDescriptor<K extends WorkerPluginKind = WorkerPluginKind> {
+    readonly kind: K;
+    readonly name: string;
+    readonly workerEntry: string;
+}
+
+declare interface WorkerPluginSource<K extends WorkerPluginKind = WorkerPluginKind> {
+    readonly kind: K;
+    readonly name: string;
+    readonly modulePath: string;
+    readonly workerEntry: string;
+}
+
+export declare interface WorkerSpawnParams {
+    readonly entrypoint: string;
+    readonly workingDirectory: string;
+    readonly execArgv: readonly string[];
+    readonly optionsJson: string;
+    readonly tempDirPrefix: string;
+    readonly env?: Readonly<Record<string, string>> | undefined;
+}
+
+export { }