@application-kit/testing 0.4.0 → 0.6.0

package/dist/cjs/stryker/define-stryker-layers.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineStrykerLayers = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = __importDefault(require("node:process"));
+const DEFAULT_LAYER_VARIABLE = 'TYPESCRIPT_MUTATION_LAYER';
+const TEMPLATE_LAYER_SENTINEL = 'all';
+const MATRIX_PATTERN = (variable) => {
+    const source = [variable, ':\\p{White_Space}*\\[([^\\]]*)\\]'].join('');
+    return new RegExp(source, 'u');
+};
+const sorted = (values) => [...values].toSorted((left, right) => left.localeCompare(right));
+const isUnderDirectory = (file, directory) => file.startsWith(`${directory}/`);
+const rootsOf = (options) => [
+    ...options.scope.directories,
+    ...options.scope.parents.flatMap((parent) => (0, node_fs_1.readdirSync)(node_path_1.default.join(options.root, parent), { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => `${parent}/${entry.name}`)),
+];
+const assertLayout = (layers, roots, configName) => {
+    const paths = Object.values(layers).flatMap((layer) => layer.paths);
+    const unassigned = roots.filter((root) => !paths.includes(root));
+    const duplicated = paths.filter((entry, index) => paths.indexOf(entry) !== index);
+    const orphaned = paths.filter((entry) => roots.every((root) => !(entry === root || isUnderDirectory(entry, root))));
+    if (unassigned.length > 0 || duplicated.length > 0 || orphaned.length > 0) {
+        throw new Error(`${configName}: каталог обязан быть ровно в одной группе — без группы: [${unassigned.join(', ')}], `
+            + `в двух: [${duplicated.join(', ')}], вне корней: [${orphaned.join(', ')}]`);
+    }
+};
+const assertMatrix = (options, variable, configName) => {
+    const matrix = MATRIX_PATTERN(variable).exec((0, node_fs_1.readFileSync)(options.ciFile).toString());
+    const matrixLayers = sorted((matrix?.[1] ?? '').split(',').map((name) => name.trim())
+        .filter(Boolean));
+    const layerNames = sorted(Object.keys(options.layers));
+    if (matrixLayers.join(',') !== layerNames.join(',')) {
+        throw new Error(`${configName}: матрица [${matrixLayers.join(', ')}] в ${node_path_1.default.basename(options.ciFile)} `
+            + `расходится с группами [${layerNames.join(', ')}]`);
+    }
+};
+const carvedOutOf = (allPaths, layer) => {
+    const isCarvedOut = (entry) => {
+        const isOwn = layer.paths.includes(entry);
+        return !isOwn && layer.paths.some((own) => isUnderDirectory(entry, own));
+    };
+    return allPaths.filter((entry) => isCarvedOut(entry));
+};
+const pruneIncrementalReport = (incrementalFile, isInScope, configName) => {
+    if (!(0, node_fs_1.existsSync)(incrementalFile)) {
+        return;
+    }
+    const report = JSON.parse((0, node_fs_1.readFileSync)(incrementalFile, 'utf8'));
+    const files = report.files ?? {};
+    const foreign = Object.keys(files).filter((file) => !isInScope(file));
+    if (foreign.length === 0) {
+        return;
+    }
+    report.files = Object.fromEntries(Object.entries(files).filter(([file]) => isInScope(file)));
+    (0, node_fs_1.writeFileSync)(`${incrementalFile}.tmp`, JSON.stringify(report));
+    (0, node_fs_1.renameSync)(`${incrementalFile}.tmp`, incrementalFile);
+    console.error(`${configName}: из ${incrementalFile} убрано файлов вне области группы: ${foreign.length}`);
+};
+const defineStrykerLayers = (options) => {
+    const variable = options.layerVariable ?? DEFAULT_LAYER_VARIABLE;
+    const configName = options.configName ?? 'stryker layers';
+    const names = Object.keys(options.layers);
+    const allPaths = Object.values(options.layers).flatMap((layer) => layer.paths);
+    const roots = rootsOf(options);
+    assertLayout(options.layers, roots, configName);
+    assertMatrix(options, variable, configName);
+    const layerOf = (name) => {
+        const layer = options.layers[String(name)];
+        if (layer === undefined) {
+            throw new Error(`${variable}=${String(name)}: ожидается одна из ${names.join(', ')}`);
+        }
+        return { layer, name: String(name) };
+    };
+    const pathsOf = (name) => {
+        const { layer } = layerOf(name);
+        return [...layer.paths, ...carvedOutOf(allPaths, layer).map((entry) => `!${entry}`)];
+    };
+    const raw = node_process_1.default.env[variable];
+    const isLoadedByStryker = node_process_1.default.argv.some((argument) => argument.includes('@stryker-mutator'));
+    const isUnset = raw === undefined || (!isLoadedByStryker && raw === TEMPLATE_LAYER_SENTINEL);
+    const { layer, name } = layerOf(isUnset ? options.defaultLayer : raw);
+    const carvedOut = carvedOutOf(allPaths, layer);
+    const incrementalFile = `.stryker-cache/incremental-${name}.json`;
+    if (isLoadedByStryker) {
+        pruneIncrementalReport(node_path_1.default.join(options.root, incrementalFile), (file) => layer.paths.some((own) => isUnderDirectory(file, own))
+            && carvedOut.every((entry) => !isUnderDirectory(file, entry)), configName);
+    }
+    const exclusions = options.base.mutate.filter((pattern) => pattern.startsWith('!'));
+    return {
+        config: {
+            ...options.base,
+            incrementalFile,
+            mutate: [
+                ...layer.paths.map((entry) => `${entry}/**/*.ts`),
+                ...carvedOut.map((entry) => `!${entry}/**`),
+                ...exclusions,
+            ],
+            thresholds: { ...options.base.thresholds, break: layer.break },
+        },
+        names,
+        paths: pathsOf,
+        roots,
+        skip: options.skip,
+    };
+};
+exports.defineStrykerLayers = defineStrykerLayers;

package/dist/cjs/stryker/index.d.ts

@@ -0,0 +1,7 @@
+export * from './code-without-logic.js';
+export * from './decide-layer-run.js';
+export * from './define-stryker-config.js';
+export * from './define-stryker-layers.js';
+export * from './mutation-layer-cli.js';
+export * from './stryker-config.interface.js';
+export * from './stryker-layers.interface.js';

package/dist/cjs/stryker/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./code-without-logic.js"), exports);
+__exportStar(require("./decide-layer-run.js"), exports);
+__exportStar(require("./define-stryker-config.js"), exports);
+__exportStar(require("./define-stryker-layers.js"), exports);
+__exportStar(require("./mutation-layer-cli.js"), exports);
+__exportStar(require("./stryker-config.interface.js"), exports);
+__exportStar(require("./stryker-layers.interface.js"), exports);

package/dist/cjs/stryker/mutation-layer-cli.d.ts

@@ -0,0 +1,9 @@
+import type { StrykerLayersInterface } from './stryker-layers.interface.js';
+export interface MutationLayerCliDependenciesInterface {
+    changedFiles(base: string): string[];
+    env: Readonly<Record<string, string | undefined>>;
+    loadLayers(config: string): Promise<StrykerLayersInterface>;
+    print(line: string): void;
+    run(command: string): number;
+}
+export declare const executeMutationLayerCli: (argv: readonly string[], dependencies: MutationLayerCliDependenciesInterface) => Promise<number>;

package/dist/cjs/stryker/mutation-layer-cli.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeMutationLayerCli = void 0;
+const decide_layer_run_js_1 = require("./decide-layer-run.js");
+const DEFAULT_CONFIG = 'stryker.layer.conf.mjs';
+const DEFAULT_LAYER_VARIABLE = 'TYPESCRIPT_MUTATION_LAYER';
+const defaultCommand = (config) => `yarn stryker run ${config} --logLevel info --concurrency 2`;
+const parse = (argv) => {
+    const positional = argv.filter((argument) => !argument.startsWith('--'));
+    const flag = argv.find((argument) => argument.startsWith('--config='));
+    return { base: positional[1], command: positional[0], config: flag?.slice('--config='.length) ?? DEFAULT_CONFIG };
+};
+const NO_BASE_REASON = 'базы диффа нет (не MR-пайплайн)';
+const changedFilesOf = (dependencies, base) => {
+    try {
+        return dependencies.changedFiles(base);
+    }
+    catch (error) {
+        return Error.isError(error) ? error : new Error(String(error));
+    }
+};
+const labelOf = (cell) => `ts:test:mutation [${String(cell.layer)}]`;
+const launch = (cell, reason) => {
+    cell.dependencies.print(`${labelOf(cell)}: прогон — ${reason}`);
+    return cell.dependencies.run(cell.dependencies.env.MUTATION_LAYER_COMMAND ?? defaultCommand(cell.config));
+};
+const runCell = (cell) => {
+    const { dependencies, layer, layers } = cell;
+    const diffBase = cell.base ?? dependencies.env.CI_MERGE_REQUEST_DIFF_BASE_SHA;
+    if (diffBase === undefined || diffBase === '') {
+        return launch(cell, NO_BASE_REASON);
+    }
+    const changed = changedFilesOf(dependencies, diffBase);
+    if (Error.isError(changed)) {
+        return launch(cell, `дифф к ${diffBase} не читается: ${changed.message.replace(/\n[\s\S]*/u, '')}`);
+    }
+    const decision = (0, decide_layer_run_js_1.decideLayerRun)({ ...layers.skip, changed, layerPaths: layers.paths(layer), roots: layers.roots });
+    if (!decision.run) {
+        dependencies.print(`${labelOf(cell)}: дифф MR (база ${diffBase}) группу не трогает — прогон пропущен, кеш и score группы без изменений`);
+        return 0;
+    }
+    if (decision.touched.length > 0) {
+        dependencies.print(`${labelOf(cell)}: дифф MR трогает группу:\n${decision.touched.map((file) => `  ${file}`).join('\n')}`);
+    }
+    return launch(cell, decision.reason);
+};
+const executeMutationLayerCli = async (argv, dependencies) => {
+    const { base, command, config } = parse(argv);
+    const layers = await dependencies.loadLayers(config);
+    if (command === 'names') {
+        dependencies.print(layers.names.join(' '));
+        return 0;
+    }
+    if (command === 'paths') {
+        dependencies.print(layers.paths(dependencies.env[DEFAULT_LAYER_VARIABLE]).join('\n'));
+        return 0;
+    }
+    if (command === 'run') {
+        return runCell({ base, config, dependencies, layer: dependencies.env[DEFAULT_LAYER_VARIABLE], layers });
+    }
+    dependencies.print(`application-mutation-layer: ожидается names | paths | run, получено ${String(command)}`);
+    return 2;
+};
+exports.executeMutationLayerCli = executeMutationLayerCli;

package/dist/cjs/stryker/stryker-config.interface.d.ts

@@ -0,0 +1,23 @@
+export interface StrykerConfigInterface {
+    readonly incrementalFile: string;
+    readonly mutate: readonly string[];
+    readonly [option: string]: unknown;
+    readonly thresholds: StrykerThresholdsInterface;
+}
+export interface StrykerConfigOptionsInterface {
+    ignorePatterns?: readonly string[];
+    incrementalFile?: string;
+    mutate: StrykerMutateScopeInterface;
+    tempDirName?: string;
+    thresholds: StrykerThresholdsInterface;
+    vitestConfigFile: string;
+}
+export interface StrykerMutateScopeInterface {
+    exclude?: readonly string[];
+    include: readonly string[];
+}
+export interface StrykerThresholdsInterface {
+    readonly break: number;
+    readonly high: number;
+    readonly low: number;
+}

package/dist/cjs/stryker/stryker-config.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/stryker/stryker-layers.interface.d.ts

@@ -0,0 +1,31 @@
+import type { StrykerConfigInterface } from './stryker-config.interface.js';
+export interface StrykerLayerInterface {
+    break: number;
+    paths: readonly string[];
+}
+export interface StrykerLayersInterface {
+    config: StrykerConfigInterface;
+    names: readonly string[];
+    paths(name: string | undefined): string[];
+    roots: readonly string[];
+    skip: StrykerLayerSkipOptionsInterface;
+}
+export interface StrykerLayerSkipOptionsInterface {
+    configFiles: RegExp;
+    sharedDirectories: readonly string[];
+    sourceRoot: string;
+}
+export interface StrykerLayersOptionsInterface {
+    base: StrykerConfigInterface;
+    ciFile: string;
+    configName?: string;
+    defaultLayer: string;
+    layers: Readonly<Record<string, StrykerLayerInterface>>;
+    layerVariable?: string;
+    root: string;
+    scope: {
+        directories: readonly string[];
+        parents: readonly string[];
+    };
+    skip: StrykerLayerSkipOptionsInterface;
+}

package/dist/cjs/stryker/stryker-layers.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/vitest/setup/fast-bcrypt-cost.d.ts

@@ -0,0 +1,5 @@
+export interface BcryptInterface {
+    compare(data: Buffer | string, encrypted: string): Promise<boolean>;
+    hash(data: Buffer | string, saltOrRounds: number | string): Promise<string>;
+}
+export declare const withFastBcryptCost: (bcrypt: BcryptInterface) => BcryptInterface;

package/dist/cjs/vitest/setup/fast-bcrypt-cost.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withFastBcryptCost = void 0;
+const FAST_ROUNDS = 4;
+const COST_FIELD_WIDTH = 2;
+const COST_FIELD = /^(?<prefix>\$2[aby]\$)\d{2}\$/u;
+const withCost = (hashed, rounds) => {
+    const cost = String(rounds).padStart(COST_FIELD_WIDTH, '0');
+    return hashed.replace(COST_FIELD, (_match, prefix) => `${prefix}${cost}$`);
+};
+const withFastBcryptCost = (bcrypt) => ({
+    compare: async (data, encrypted) => bcrypt.compare(data, withCost(encrypted, FAST_ROUNDS)),
+    hash: async (data, saltOrRounds) => (typeof saltOrRounds === 'number'
+        ? withCost(await bcrypt.hash(data, Math.min(saltOrRounds, FAST_ROUNDS)), saltOrRounds)
+        : bcrypt.hash(data, saltOrRounds)),
+});
+exports.withFastBcryptCost = withFastBcryptCost;

package/dist/cjs/vitest/setup/fast-bcrypt.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/vitest/setup/fast-bcrypt.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fast_bcrypt_cost_js_1 = require("./fast-bcrypt-cost.js");
+vitest_1.vi.mock('bcrypt', async (importOriginal) => {
+    const bcrypt = await importOriginal();
+    const fast = (0, fast_bcrypt_cost_js_1.withFastBcryptCost)(bcrypt);
+    return { ...bcrypt, ...fast, default: { ...bcrypt.default, ...fast } };
+});

package/dist/cjs/vitest/setup/index.d.ts

@@ -0,0 +1,2 @@
+export * from './fast-bcrypt.js';
+export * from './fast-bcrypt-cost.js';

package/dist/cjs/vitest/setup/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./fast-bcrypt.js"), exports);
+__exportStar(require("./fast-bcrypt-cost.js"), exports);

package/dist/esm/index.d.ts

@@ -1,6 +1,7 @@
 export * from './fake-microservice/index.js';
 export * from './postgres/index.js';
 export * from './build-web-application.js';
+export * from './replace-process-environment.js';
 export * from './test-command-bus.js';
 export * from './test-event-bus.js';
 export * from './test-logger.js';

package/dist/esm/index.js

@@ -1,6 +1,7 @@
 export * from './fake-microservice/index.js';
 export * from './postgres/index.js';
 export * from './build-web-application.js';
+export * from './replace-process-environment.js';
 export * from './test-command-bus.js';
 export * from './test-event-bus.js';
 export * from './test-logger.js';

package/dist/esm/postgres/index.d.ts

@@ -1 +1,2 @@
+export * from './start-postgres-web-application.js';
 export * from './test-data-source.js';

package/dist/esm/postgres/index.js

@@ -1 +1,2 @@
+export * from './start-postgres-web-application.js';
 export * from './test-data-source.js';

package/dist/esm/postgres/start-postgres-web-application.d.ts

@@ -0,0 +1,15 @@
+import type { InjectionToken, ModuleMetadata } from '@nestjs/common';
+import type { NestFastifyApplication } from '@nestjs/platform-fastify';
+import type { NamingStrategyInterface } from 'typeorm';
+import type { BuildWebApplicationOptionsInterface } from '../build-web-application.js';
+export interface PostgresWebApplicationOptionsInterface extends BuildWebApplicationOptionsInterface {
+    databaseConfigToken: InjectionToken;
+    image: string;
+    imports: NonNullable<ModuleMetadata['imports']>;
+    namingStrategy: NamingStrategyInterface;
+}
+export interface StartedWebApplicationInterface {
+    app: NestFastifyApplication;
+    stop(): Promise<void>;
+}
+export declare const startPostgresWebApplication: (options: PostgresWebApplicationOptionsInterface) => Promise<StartedWebApplicationInterface>;

package/dist/esm/postgres/start-postgres-web-application.js

@@ -0,0 +1,32 @@
+import { buildWebApplication } from '../build-web-application.js';
+import { postgresContainerDataSourceOptions, startPostgresContainer } from './test-data-source.js';
+export const startPostgresWebApplication = async (options) => {
+    const { databaseConfigToken, image, imports, namingStrategy, ...buildOptions } = options;
+    const container = await startPostgresContainer(image);
+    const dataSourceOptions = {
+        ...postgresContainerDataSourceOptions(container, namingStrategy),
+        migrationsRun: false,
+        synchronize: true,
+    };
+    try {
+        const app = await buildWebApplication(imports, [
+            {
+                provide: databaseConfigToken,
+                useValue: { createDataSourceOptions: () => dataSourceOptions },
+            },
+        ], buildOptions);
+        await app.getHttpAdapter().getInstance()
+            .ready();
+        return {
+            app,
+            stop: async () => {
+                await app.close();
+                await container.stop();
+            },
+        };
+    }
+    catch (error) {
+        await container.stop();
+        throw error;
+    }
+};

package/dist/esm/postgres/test-data-source.d.ts

@@ -1,9 +1,10 @@
 import type { StartedTestContainer } from 'testcontainers';
-import type { EntitySchema, MixedList, NamingStrategyInterface, QueryRunner } from 'typeorm';
+import type { DataSourceOptions, EntitySchema, MixedList, NamingStrategyInterface, QueryRunner } from 'typeorm';
 import { DataSource } from 'typeorm';
 export declare const TEST_DATABASE_NAME = "db";
 export declare const TEST_DATABASE_PORT = 5432;
 export declare const startPostgresContainer: (image: string) => Promise<StartedTestContainer>;
+export declare const postgresContainerDataSourceOptions: (container: StartedTestContainer, namingStrategy: NamingStrategyInterface) => DataSourceOptions;
 export interface TestDataSourceOptionsInterface {
     entities: MixedList<EntitySchema | Function | string>;
     image: string;

package/dist/esm/postgres/test-data-source.js

@@ -12,28 +12,29 @@ export const startPostgresContainer = async (image) => new GenericContainer(imag
 })
     .withExposedPorts(TEST_DATABASE_PORT)
     .start();
+export const postgresContainerDataSourceOptions = (container, namingStrategy) => ({
+    database: TEST_DATABASE_NAME,
+    host: container.getHost(),
+    logging: false,
+    namingStrategy,
+    password: TEST_DATABASE_NAME,
+    port: container.getMappedPort(TEST_DATABASE_PORT),
+    ssl: false,
+    subscribers: [],
+    type: 'postgres',
+    username: TEST_DATABASE_NAME,
+});
 export const testDataSource = async ({ entities, image, isLogging = false, migrations, namingStrategy, shouldSynchronize = false, }) => {
-    const databaseName = TEST_DATABASE_NAME;
-    const databasePort = TEST_DATABASE_PORT;
     const container = await startPostgresContainer(image);
-    const databaseConfig = {
-        database: databaseName,
+    const dataSource = new DataSource({
+        ...postgresContainerDataSourceOptions(container, namingStrategy),
         entities,
-        host: container.getHost(),
         logging: isLogging,
         maxQueryExecutionTime: 1000,
         migrations,
         migrationsRun: !shouldSynchronize,
-        namingStrategy,
-        password: databaseName,
-        port: container.getMappedPort(databasePort),
-        ssl: false,
-        subscribers: [],
         synchronize: shouldSynchronize,
-        type: 'postgres',
-        username: databaseName,
-    };
-    const dataSource = new DataSource(databaseConfig);
+    });
     await dataSource.initialize();
     const queryRunner = dataSource.createQueryRunner();
     Object.assign(dataSource.manager, { queryRunner });

package/dist/esm/replace-process-environment.d.ts

@@ -0,0 +1 @@
+export declare const replaceProcessEnvironment: (environment: Readonly<Record<string, string>>) => void;

package/dist/esm/replace-process-environment.js

@@ -0,0 +1,53 @@
+import process from 'node:process';
+const TOOLCHAIN_NAMES = new Set([
+    '_',
+    'CI',
+    'COLORTERM',
+    'FORCE_COLOR',
+    'HOME',
+    'HOSTNAME',
+    'INIT_CWD',
+    'LANG',
+    'OLDPWD',
+    'PATH',
+    'PROJECT_CWD',
+    'PWD',
+    'SHELL',
+    'SHLVL',
+    'TEMP',
+    'TERM',
+    'TMP',
+    'TMPDIR',
+    'TZ',
+    'USER',
+]);
+const TOOLCHAIN_PREFIXES = [
+    'BERRY_',
+    'DOCKER_',
+    'HTTP_PROXY',
+    'HTTPS_PROXY',
+    'LC_',
+    'NODE_',
+    'NO_PROXY',
+    'NPM_',
+    'npm_',
+    'TESTCONTAINERS_',
+    'VITE_',
+    'VITEST_',
+    'XDG_',
+    'YARN_',
+    'http_proxy',
+    'https_proxy',
+    'no_proxy',
+];
+const isToolchainVariable = (name) => TOOLCHAIN_NAMES.has(name)
+    || TOOLCHAIN_PREFIXES.some((prefix) => name.startsWith(prefix));
+export const replaceProcessEnvironment = (environment) => {
+    const runtimeEnvironment = process.env;
+    for (const name of Object.keys(runtimeEnvironment)) {
+        if (!isToolchainVariable(name)) {
+            Reflect.deleteProperty(runtimeEnvironment, name);
+        }
+    }
+    Object.assign(runtimeEnvironment, environment);
+};

package/dist/esm/stryker/bin/application-mutation-layer.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/esm/stryker/bin/application-mutation-layer.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { execFileSync, spawnSync } from 'node:child_process';
+import path from 'node:path';
+import process from 'node:process';
+import { pathToFileURL } from 'node:url';
+import { executeMutationLayerCli } from '../mutation-layer-cli.js';
+const changedFiles = (base) => execFileSync('git', ['diff', '--name-only', `${base}...HEAD`], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] })
+    .split('\n')
+    .filter(Boolean);
+const loadLayers = async (config) => {
+    const loaded = (await import(pathToFileURL(path.resolve(config)).href));
+    return loaded.layers;
+};
+const main = async () => {
+    const code = await executeMutationLayerCli(process.argv.slice(2), {
+        changedFiles,
+        env: process.env,
+        loadLayers,
+        print: (line) => {
+            console.log(line);
+        },
+        run: (command) => spawnSync(command, { shell: true, stdio: 'inherit' }).status ?? 1,
+    });
+    process.exitCode = code;
+};
+void main();

package/dist/esm/stryker/bin/index.d.ts

@@ -0,0 +1 @@
+export * from './application-mutation-layer.js';

package/dist/esm/stryker/bin/index.js

@@ -0,0 +1 @@
+export * from './application-mutation-layer.js';

package/dist/esm/stryker/code-without-logic.d.ts

@@ -0,0 +1 @@
+export declare const CODE_WITHOUT_LOGIC: readonly string[];

package/dist/esm/stryker/code-without-logic.js

@@ -0,0 +1,28 @@
+export const CODE_WITHOUT_LOGIC = [
+    'src/**/*.command.ts',
+    'src/**/*.config.ts',
+    'src/**/*.d.ts',
+    'src/**/*.dto.ts',
+    'src/**/*.environment.ts',
+    'src/**/*.error.ts',
+    'src/**/*.fake.ts',
+    'src/**/*.interface.ts',
+    'src/**/*.mock.ts',
+    'src/**/*.module.ts',
+    'src/**/*.query.ts',
+    'src/**/*.type.ts',
+    'src/**/*constants.ts',
+    'src/**/entry.*.ts',
+    'src/**/errors/*',
+    'src/**/graphql/**/*.input.ts',
+    'src/**/graphql/**/*.output.ts',
+    'src/**/mappers/*',
+    'src/**/module.cli.ts',
+    'src/**/module.consumers.ts',
+    'src/**/module.manifest.ts',
+    'src/**/typeorm/entities/*.ts',
+    'src/**/typeorm/migrations/*.ts',
+    'src/**/user-interface/client/app/navigation.ts',
+    'src/**/user-interface/client/app/plugins/*-widget.plugin.ts',
+    'src/**/user-interface/client/app/plugins/container-plugin.ts',
+];

package/dist/esm/stryker/decide-layer-run.d.ts

@@ -0,0 +1,12 @@
+import type { StrykerLayerSkipOptionsInterface } from './stryker-layers.interface.js';
+export interface LayerRunDecisionInterface {
+    readonly reason: string;
+    readonly run: boolean;
+    readonly touched: readonly string[];
+}
+export interface LayerRunInputInterface extends StrykerLayerSkipOptionsInterface {
+    changed: readonly string[];
+    layerPaths: readonly string[];
+    roots: readonly string[];
+}
+export declare const decideLayerRun: (input: LayerRunInputInterface) => LayerRunDecisionInterface;