testing-conventions 0.0.44 → 0.0.46

package/dist/bin/index.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { fileURLToPath } from 'node:url';
+import { main } from 'bin-shim';
+// The TypeScript `unit mutation` arm runs Stryker through the bundled Node adapter (#246): the
+// rust binary spawns `node` on it, but a Rust binary can't reliably locate a JS file in the npm
+// tree. The Node launcher — which knows its own `dist/` — hands the binary the adapter's path as
+// an explicit `--ts-mutation-adapter` CLI argument, appended only to a `unit mutation` invocation
+// (the only command that reads it). The binary errors clearly if the arm runs without it.
+const args = process.argv.slice(2);
+const isUnitMutation = args[0] === 'unit' && args[1] === 'mutation';
+const adapter = fileURLToPath(new URL('../mutation/main.js', import.meta.url));
+const argv = isUnitMutation ? [...args, '--ts-mutation-adapter', adapter] : args;
+main({
+    scope: 'testing-conventions',
+    binaryName: 'testing-conventions',
+    from: import.meta.url,
+    argv,
+    platformPackage: '@{scope}/{triple}',
+    triples: {
+        'linux-x64': 'x86_64-unknown-linux-gnu',
+        'linux-arm64': 'aarch64-unknown-linux-gnu',
+        'darwin-x64': 'x86_64-apple-darwin',
+        'darwin-arm64': 'aarch64-apple-darwin',
+        'win32-x64': 'x86_64-pc-windows-msvc',
+    },
+})
+    .then((code) => process.exit(code))
+    .catch((err) => {
+    process.stderr.write(`${err.message}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/bin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/bin/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAEhC,+FAA+F;AAC/F,gGAAgG;AAChG,iGAAiG;AACjG,kGAAkG;AAClG,0FAA0F;AAC1F,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACnC,MAAM,cAAc,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC;AACpE,MAAM,OAAO,GAAG,aAAa,CAAC,IAAI,GAAG,CAAC,qBAAqB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAC/E,MAAM,IAAI,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,EAAE,uBAAuB,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAEjF,IAAI,CAAC;IACH,KAAK,EAAE,qBAAqB;IAC5B,UAAU,EAAE,qBAAqB;IACjC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG;IACrB,IAAI;IACJ,eAAe,EAAE,mBAAmB;IACpC,OAAO,EAAE;QACP,WAAW,EAAE,0BAA0B;QACvC,aAAa,EAAE,2BAA2B;QAC1C,YAAY,EAAE,qBAAqB;QACnC,cAAc,EAAE,sBAAsB;QACtC,WAAW,EAAE,wBAAwB;KACtC;CACF,CAAC;KACC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;KAClC,KAAK,CAAC,CAAC,GAAU,EAAE,EAAE;IACpB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,OAAO,IAAI,CAAC,CAAC;IACzC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/dist/mutation/main.d.ts

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

package/dist/mutation/main.js

@@ -0,0 +1,10 @@
+import { mutationCLI } from './mutation-cli.js';
+// The executable the rust binary spawns for the TS mutation arm (#246): `dist/mutation/main.js`
+// runs `mutationCLI` over the process arguments and maps a failed run onto a non-zero exit code.
+// Kept separate from `mutation-cli.ts` so the orchestration stays a pure, importable function with
+// no process side effects (and each stays fully covered).
+mutationCLI(process.argv.slice(2)).catch((err) => {
+    process.stderr.write(`${err.message}\n`);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=main.js.map

package/dist/mutation/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","sourceRoot":"","sources":["../../src/mutation/main.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,gGAAgG;AAChG,iGAAiG;AACjG,mGAAmG;AACnG,0DAA0D;AAC1D,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAU,EAAE,EAAE;IACtD,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,OAAO,IAAI,CAAC,CAAC;IACzC,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;AACvB,CAAC,CAAC,CAAC"}

package/dist/mutation/mutation-cli.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The TypeScript mutation adapter (#239 / #246). The rust binary spawns the built executable
+ * (`main.ts` → `dist/mutation/main.js`) on the TS arm — its path comes from the launcher's
+ * `--ts-mutation-adapter` argument, so the binary never hunts the filesystem for it. This runs
+ * Stryker through the Node API and emits the normalized results as JSON. `--out <path>` writes
+ * them to a file (the rule passes a temp file, so Stryker's own stdout logging can't corrupt
+ * them); without it, the JSON goes to stdout. `--mutate <a,b,...>` scopes the run to those Stryker
+ * mutate patterns. Rejects on a failed run; `main.ts` maps that onto a non-zero exit code.
+ */
+export declare function mutationCLI(argv: string[]): Promise<void>;

package/dist/mutation/mutation-cli.js

@@ -0,0 +1,24 @@
+import { writeFile } from 'node:fs/promises';
+import { parseArgs } from './parse-args.js';
+import { runStryker } from './run-stryker.js';
+/**
+ * The TypeScript mutation adapter (#239 / #246). The rust binary spawns the built executable
+ * (`main.ts` → `dist/mutation/main.js`) on the TS arm — its path comes from the launcher's
+ * `--ts-mutation-adapter` argument, so the binary never hunts the filesystem for it. This runs
+ * Stryker through the Node API and emits the normalized results as JSON. `--out <path>` writes
+ * them to a file (the rule passes a temp file, so Stryker's own stdout logging can't corrupt
+ * them); without it, the JSON goes to stdout. `--mutate <a,b,...>` scopes the run to those Stryker
+ * mutate patterns. Rejects on a failed run; `main.ts` maps that onto a non-zero exit code.
+ */
+export async function mutationCLI(argv) {
+    const { mutate, out } = parseArgs(argv);
+    const results = await runStryker(mutate === undefined ? {} : { mutate });
+    const json = `${JSON.stringify(results)}\n`;
+    if (out === undefined) {
+        process.stdout.write(json);
+    }
+    else {
+        await writeFile(out, json);
+    }
+}
+//# sourceMappingURL=mutation-cli.js.map

package/dist/mutation/mutation-cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-cli.js","sourceRoot":"","sources":["../../src/mutation/mutation-cli.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,IAAc;IAC9C,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IACxC,MAAM,OAAO,GAAG,MAAM,UAAU,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;IACzE,MAAM,IAAI,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC;IAC5C,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC;SAAM,CAAC;QACN,MAAM,SAAS,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAC7B,CAAC;AACH,CAAC"}

package/dist/mutation/normalize-status.d.ts

@@ -0,0 +1,9 @@
+import type { MutantStatus } from '@stryker-mutator/api/core';
+/** The normalized status vocabulary shared with the Rust core (`snake_case` on the wire). */
+export type NormalizedStatus = 'survived' | 'killed' | 'no_coverage' | 'timeout' | 'compile_error' | 'runtime_error';
+/**
+ * Map a Stryker `MutantStatus` onto the normalized vocabulary, or `null` for the two
+ * non-outcomes the gate doesn't model: `Ignored` (excluded by config) and `Pending` (never
+ * ran). Every other Stryker status has a 1:1 normalized counterpart.
+ */
+export declare function normalizeStatus(status: MutantStatus): NormalizedStatus | null;

package/dist/mutation/normalize-status.js

@@ -0,0 +1,25 @@
+/**
+ * Map a Stryker `MutantStatus` onto the normalized vocabulary, or `null` for the two
+ * non-outcomes the gate doesn't model: `Ignored` (excluded by config) and `Pending` (never
+ * ran). Every other Stryker status has a 1:1 normalized counterpart.
+ */
+export function normalizeStatus(status) {
+    switch (status) {
+        case 'Survived':
+            return 'survived';
+        case 'Killed':
+            return 'killed';
+        case 'NoCoverage':
+            return 'no_coverage';
+        case 'Timeout':
+            return 'timeout';
+        case 'CompileError':
+            return 'compile_error';
+        case 'RuntimeError':
+            return 'runtime_error';
+        case 'Ignored':
+        case 'Pending':
+            return null;
+    }
+}
+//# sourceMappingURL=normalize-status.js.map

package/dist/mutation/normalize-status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-status.js","sourceRoot":"","sources":["../../src/mutation/normalize-status.ts"],"names":[],"mappings":"AAWA;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,MAAoB;IAClD,QAAQ,MAAM,EAAE,CAAC;QACf,KAAK,UAAU;YACb,OAAO,UAAU,CAAC;QACpB,KAAK,QAAQ;YACX,OAAO,QAAQ,CAAC;QAClB,KAAK,YAAY;YACf,OAAO,aAAa,CAAC;QACvB,KAAK,SAAS;YACZ,OAAO,SAAS,CAAC;QACnB,KAAK,cAAc;YACjB,OAAO,eAAe,CAAC;QACzB,KAAK,cAAc;YACjB,OAAO,eAAe,CAAC;QACzB,KAAK,SAAS,CAAC;QACf,KAAK,SAAS;YACZ,OAAO,IAAI,CAAC;IAChB,CAAC;AACH,CAAC"}

package/dist/mutation/parse-args.d.ts

@@ -0,0 +1,14 @@
+/** The CLI arguments the TypeScript mutation adapter understands. */
+export interface AdapterArgs {
+    /** Stryker `mutate` patterns (`--mutate a,b,...`), or `undefined` for the default set. */
+    mutate?: string[];
+    /** File to write the normalized-results JSON to (`--out <path>`); stdout when absent. */
+    out?: string;
+}
+/**
+ * Parse the adapter's CLI arguments with Node's built-in `util.parseArgs`: `--out <path>` (where
+ * to write the normalized JSON — the rule passes a temp file so Stryker's own stdout logging can't
+ * corrupt the results) and `--mutate <a,b,...>` (Stryker mutate patterns, comma-split into a list).
+ * Both are optional; the rust binary supplies the argv, so it stays a fixed, controlled shape.
+ */
+export declare function parseArgs(argv: string[]): AdapterArgs;

package/dist/mutation/parse-args.js

@@ -0,0 +1,26 @@
+import { parseArgs as parseNodeArgs } from 'node:util';
+/**
+ * Parse the adapter's CLI arguments with Node's built-in `util.parseArgs`: `--out <path>` (where
+ * to write the normalized JSON — the rule passes a temp file so Stryker's own stdout logging can't
+ * corrupt the results) and `--mutate <a,b,...>` (Stryker mutate patterns, comma-split into a list).
+ * Both are optional; the rust binary supplies the argv, so it stays a fixed, controlled shape.
+ */
+export function parseArgs(argv) {
+    const { values } = parseNodeArgs({
+        args: argv,
+        options: {
+            mutate: { type: 'string' },
+            out: { type: 'string' },
+        },
+        allowPositionals: true,
+    });
+    const result = {};
+    if (values.mutate !== undefined) {
+        result.mutate = values.mutate.split(',');
+    }
+    if (values.out !== undefined) {
+        result.out = values.out;
+    }
+    return result;
+}
+//# sourceMappingURL=parse-args.js.map

package/dist/mutation/parse-args.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-args.js","sourceRoot":"","sources":["../../src/mutation/parse-args.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,WAAW,CAAC;AAUvD;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAC,IAAc;IACtC,MAAM,EAAE,MAAM,EAAE,GAAG,aAAa,CAAC;QAC/B,IAAI,EAAE,IAAI;QACV,OAAO,EAAE;YACP,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;YAC1B,GAAG,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;SACxB;QACD,gBAAgB,EAAE,IAAI;KACvB,CAAC,CAAC;IAEH,MAAM,MAAM,GAAgB,EAAE,CAAC;IAC/B,IAAI,MAAM,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAChC,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC3C,CAAC;IACD,IAAI,MAAM,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;QAC7B,MAAM,CAAC,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC;IAC1B,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/mutation/run-stryker.d.ts

@@ -0,0 +1,18 @@
+import { type NormalizedMutant } from './to-normalized.js';
+/** Options for {@link runStryker}. */
+export interface RunStrykerOptions {
+    /**
+     * Stryker `mutate` patterns to scope the run to (e.g. `<file>:<start>-<end>` ranges for a
+     * diff-scoped gate). Omitted ⇒ Stryker's configured/default `mutate` set.
+     */
+    mutate?: string[];
+}
+/**
+ * Run Stryker over the project in the current working directory via its Node API (#239) and
+ * return the normalized results. Selects the **bundled** vitest runner explicitly by path (so
+ * the unit-scoped runner is always used rather than Stryker's default `npm test` command
+ * runner, #240, and resolves regardless of the project's location); results come from
+ * `runMutationTest()` directly, so there is no report file. Because this runs inside the npm
+ * package, `@stryker-mutator/core` resolves natively.
+ */
+export declare function runStryker(options?: RunStrykerOptions): Promise<NormalizedMutant[]>;

package/dist/mutation/run-stryker.js

@@ -0,0 +1,32 @@
+import { createRequire } from 'node:module';
+import { Stryker } from '@stryker-mutator/core';
+import { toNormalized } from './to-normalized.js';
+// The bundled vitest runner plugin's absolute path. Stryker discovers plugins relative to the
+// *project* under test, not to where it was imported from — so when the rule runs the engine
+// over a consumer project, our bundled `@stryker-mutator/vitest-runner` isn't on that search
+// path. Passing its resolved path as an explicit plugin makes Stryker load our copy regardless
+// of the project's location (#246). `vitest` itself stays the consumer's (the runner's peer).
+const vitestRunnerPlugin = createRequire(import.meta.url).resolve('@stryker-mutator/vitest-runner');
+/**
+ * Run Stryker over the project in the current working directory via its Node API (#239) and
+ * return the normalized results. Selects the **bundled** vitest runner explicitly by path (so
+ * the unit-scoped runner is always used rather than Stryker's default `npm test` command
+ * runner, #240, and resolves regardless of the project's location); results come from
+ * `runMutationTest()` directly, so there is no report file. Because this runs inside the npm
+ * package, `@stryker-mutator/core` resolves natively.
+ */
+export async function runStryker(options = {}) {
+    const cliOptions = {
+        testRunner: 'vitest',
+        plugins: [vitestRunnerPlugin],
+        // Results come from runMutationTest()'s return value, so no file/stdout reporter is needed.
+        reporters: [],
+        ...(options.mutate ? { mutate: options.mutate } : {}),
+    };
+    const results = await new Stryker(cliOptions).runMutationTest();
+    const projectRoot = process.cwd();
+    return results
+        .map((result) => toNormalized(result, projectRoot))
+        .filter((mutant) => mutant !== null);
+}
+//# sourceMappingURL=run-stryker.js.map

package/dist/mutation/run-stryker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-stryker.js","sourceRoot":"","sources":["../../src/mutation/run-stryker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAGhD,OAAO,EAAE,YAAY,EAAyB,MAAM,oBAAoB,CAAC;AAWzE,8FAA8F;AAC9F,6FAA6F;AAC7F,6FAA6F;AAC7F,+FAA+F;AAC/F,8FAA8F;AAC9F,MAAM,kBAAkB,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC;AAEpG;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,UAA6B,EAAE;IAC9D,MAAM,UAAU,GAA0B;QACxC,UAAU,EAAE,QAAQ;QACpB,OAAO,EAAE,CAAC,kBAAkB,CAAC;QAC7B,4FAA4F;QAC5F,SAAS,EAAE,EAAE;QACb,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACtD,CAAC;IACF,MAAM,OAAO,GAAG,MAAM,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC,eAAe,EAAE,CAAC;IAChE,MAAM,WAAW,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;IAClC,OAAO,OAAO;SACX,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;SAClD,MAAM,CAAC,CAAC,MAAM,EAA8B,EAAE,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC;AACrE,CAAC"}

package/dist/mutation/to-normalized.d.ts

@@ -0,0 +1,28 @@
+import type { MutantResult } from '@stryker-mutator/api/core';
+import { type NormalizedStatus } from './normalize-status.js';
+/**
+ * One mutant in the normalized result set — the engine-agnostic shape the Rust core reads
+ * (`mutation::NormalizedMutant`). The adapter emits an array of these so the core never sees
+ * a Stryker-specific report.
+ */
+export interface NormalizedMutant {
+    /** Project-relative, `/`-separated path of the mutated file. */
+    file: string;
+    /** 1-based line the mutant starts on. */
+    line: number;
+    /** The outcome, normalized across engines. */
+    status: NormalizedStatus;
+    /** Stryker's mutator name (e.g. `ConditionalExpression`). */
+    mutator: string;
+    /** The replacement text, when Stryker reports one. */
+    replacement?: string;
+}
+/**
+ * Map one Stryker `MutantResult` to a {@link NormalizedMutant}, or `null` when its status is
+ * one the gate ignores (see {@link normalizeStatus}).
+ *
+ * Stryker reports `fileName` as an absolute path, but the gate keys on project-relative,
+ * `/`-separated paths (so exemptions and the `--base` diff match), so it's made relative to
+ * `projectRoot` and separators are normalized.
+ */
+export declare function toNormalized(result: MutantResult, projectRoot: string): NormalizedMutant | null;

package/dist/mutation/to-normalized.js

@@ -0,0 +1,27 @@
+import { isAbsolute, relative, sep } from 'node:path';
+import { normalizeStatus } from './normalize-status.js';
+/**
+ * Map one Stryker `MutantResult` to a {@link NormalizedMutant}, or `null` when its status is
+ * one the gate ignores (see {@link normalizeStatus}).
+ *
+ * Stryker reports `fileName` as an absolute path, but the gate keys on project-relative,
+ * `/`-separated paths (so exemptions and the `--base` diff match), so it's made relative to
+ * `projectRoot` and separators are normalized.
+ */
+export function toNormalized(result, projectRoot) {
+    const status = normalizeStatus(result.status);
+    if (status === null) {
+        return null;
+    }
+    const file = (isAbsolute(result.fileName) ? relative(projectRoot, result.fileName) : result.fileName)
+        .split(sep)
+        .join('/');
+    return {
+        file,
+        line: result.location.start.line,
+        status,
+        mutator: result.mutatorName,
+        ...(result.replacement === undefined ? {} : { replacement: result.replacement }),
+    };
+}
+//# sourceMappingURL=to-normalized.js.map

package/dist/mutation/to-normalized.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-normalized.js","sourceRoot":"","sources":["../../src/mutation/to-normalized.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAGtD,OAAO,EAAE,eAAe,EAAyB,MAAM,uBAAuB,CAAC;AAoB/E;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAAC,MAAoB,EAAE,WAAmB;IACpE,MAAM,MAAM,GAAG,eAAe,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC9C,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,IAAI,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;SAClG,KAAK,CAAC,GAAG,CAAC;SACV,IAAI,CAAC,GAAG,CAAC,CAAC;IACb,OAAO;QACL,IAAI;QACJ,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI;QAChC,MAAM;QACN,OAAO,EAAE,MAAM,CAAC,WAAW;QAC3B,GAAG,CAAC,MAAM,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC;KACjF,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "testing-conventions",
-  "version": "0.0.44",
+  "version": "0.0.46",
   "description": "Enforce testing conventions in libraries (Python, TypeScript, and Rust).",
   "license": "MIT",
   "repository": "https://github.com/thekevinscott/testing-conventions",
   "type": "module",
   "bin": {
-    "testing-conventions": "dist/bin.js"
+    "testing-conventions": "dist/bin/index.js"
   },
   "exports": {
     ".": {
@@ -43,13 +43,14 @@
     }
   },
   "optionalDependencies": {
-    "@testing-conventions/x86_64-unknown-linux-gnu": "0.0.44",
-    "@testing-conventions/aarch64-unknown-linux-gnu": "0.0.44",
-    "@testing-conventions/x86_64-apple-darwin": "0.0.44",
-    "@testing-conventions/aarch64-apple-darwin": "0.0.44",
-    "@testing-conventions/x86_64-pc-windows-msvc": "0.0.44"
+    "@testing-conventions/x86_64-unknown-linux-gnu": "0.0.46",
+    "@testing-conventions/aarch64-unknown-linux-gnu": "0.0.46",
+    "@testing-conventions/x86_64-apple-darwin": "0.0.46",
+    "@testing-conventions/aarch64-apple-darwin": "0.0.46",
+    "@testing-conventions/x86_64-pc-windows-msvc": "0.0.46"
   },
   "devDependencies": {
+    "@stryker-mutator/api": "^9.6.0",
     "@types/node": "^22.9.0",
     "@typescript-eslint/eslint-plugin": "^8.15.0",
     "@typescript-eslint/parser": "^8.15.0",

package/dist/bin.js

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-import { main } from 'bin-shim';
-main({
-    scope: 'testing-conventions',
-    binaryName: 'testing-conventions',
-    from: import.meta.url,
-    platformPackage: '@{scope}/{triple}',
-    triples: {
-        'linux-x64': 'x86_64-unknown-linux-gnu',
-        'linux-arm64': 'aarch64-unknown-linux-gnu',
-        'darwin-x64': 'x86_64-apple-darwin',
-        'darwin-arm64': 'aarch64-apple-darwin',
-        'win32-x64': 'x86_64-pc-windows-msvc',
-    },
-})
-    .then((code) => process.exit(code))
-    .catch((err) => {
-    process.stderr.write(`${err.message}\n`);
-    process.exit(1);
-});
-//# sourceMappingURL=bin.js.map

package/dist/bin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bin.js","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAEhC,IAAI,CAAC;IACH,KAAK,EAAE,qBAAqB;IAC5B,UAAU,EAAE,qBAAqB;IACjC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG;IACrB,eAAe,EAAE,mBAAmB;IACpC,OAAO,EAAE;QACP,WAAW,EAAE,0BAA0B;QACvC,aAAa,EAAE,2BAA2B;QAC1C,YAAY,EAAE,qBAAqB;QACnC,cAAc,EAAE,sBAAsB;QACtC,WAAW,EAAE,wBAAwB;KACtC;CACF,CAAC;KACC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;KAClC,KAAK,CAAC,CAAC,GAAU,EAAE,EAAE;IACpB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,OAAO,IAAI,CAAC,CAAC;IACzC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}