@fairfox/polly 0.91.0 → 0.92.0

package/dist/tools/mutate/src/ingest.d.ts

@@ -1,5 +1,5 @@
 /**
- * Ingest a Stryker mutation report (mutation-testing-report-schema) into a
+ * Ingest a mutation report (mutation-testing-report-schema) into a
  * regenerable SQLite database holding the kill matrix.
  *
  * The tool consumes the *schema*, never a specific runner — so the same
@@ -16,6 +16,8 @@ export interface MutationReport {
     testFiles?: Record<string, {
         tests: TestDef[];
     }>;
+    /** Written by the bun engine; absent from Stryker-era reports. */
+    contracts?: ReportContracts;
 }
 interface Mutant {
     id: string;
@@ -29,6 +31,33 @@ interface Mutant {
     };
     killedBy?: string[];
     coveredBy?: string[];
+    /** Contract ids (`<file>:<line>`) a killing test's failure named. */
+    killedByContract?: string[];
+    /** Every killer failed through a contract: no assertion caught the mutant. */
+    contractOnly?: boolean;
+}
+/** The engine's contracts block: how the run enforced requires/ensures, and what it found. */
+export interface ReportContracts {
+    mode: "off" | "ensures" | "all";
+    runner: "bun-test" | "command";
+    sites: ContractSiteDef[];
+    violations: {
+        target: string;
+        test: string;
+        contracts: string[];
+    }[];
+}
+export interface ContractSiteDef {
+    /** `<file>:<line>`, what `killedByContract` holds. */
+    id: string;
+    file: string;
+    line: number;
+    primitive: "requires" | "ensures";
+    message?: string;
+    handler?: {
+        from: number;
+        to: number;
+    };
 }
 interface TestDef {
     id: string;

package/dist/tools/mutate/src/init.d.ts

@@ -2,7 +2,8 @@ export interface InitResult {
     configPath: string;
     /** false when a config already existed and --force was not passed. */
     created: boolean;
-    pluginRef: string;
+    /** Where `defineMutation` is imported from. */
+    specifier: string;
     mutate: string[];
     testGlob: string;
     warnings: string[];

package/dist/tools/mutate/src/migrate.d.ts

@@ -0,0 +1,32 @@
+import { type MutationConfig } from "./define.ts";
+export interface Migration {
+    config: MutationConfig;
+    notes: string[];
+}
+/** `--preload <p>` / `--preload=<p>` values from the bun runner's `nodeArgs`, as written. */
+export declare function preloadArgs(nodeArgs: string[]): string[];
+/** A Stryker command string as argv; anything shell-shaped goes through `sh -c`. */
+export declare function commandArgv(command: string): string[];
+/** Map a parsed Stryker config to a `MutationConfig`, with a note per dropped key. */
+export declare function strykerToMutation(raw: unknown, where: string): Migration;
+export declare function readStrykerConfig(path: string): Promise<Migration>;
+/**
+ * The specifier a config in `dir` imports `defineMutation` from: the package
+ * export when it resolves there, else this source tree's own module (polly's
+ * monorepo root has no `@fairfox/polly` in its node_modules).
+ */
+export declare function defineImportSpecifier(dir: string): string;
+export declare function renderMutationConfig(config: MutationConfig, specifier: string): string;
+export interface MigrateResult {
+    /** Where the config goes (next to the Stryker config). */
+    path: string;
+    source: string;
+    notes: string[];
+    /** false when `write` was off or a config was already there without `force`. */
+    written: boolean;
+    existed: boolean;
+}
+export declare function migrateConfig(strykerPath: string, opts?: {
+    write?: boolean;
+    force?: boolean;
+}): Promise<MigrateResult>;

package/dist/tools/mutate/src/report.d.ts

@@ -5,6 +5,9 @@
  *   redundancy  tests/files whose every kill is also caught elsewhere
  *   theatre     covered-but-survived — code a test runs but no test detects
  *               (the Survived status under coverageAnalysis "all")
+ *   contracts   (bun engine, contracts on) mutants only a requires/ensures
+ *               caught, kills per contract, and contracts whose handler was
+ *               exercised yet never fired — a contract without teeth
  *
  * Redundancy is reported at BOTH file and case level. Decisions are keyed at
  * file level (stable identity); case level is the drill-down.

package/dist/tools/mutate/src/run.d.ts

@@ -1,11 +1,20 @@
+import type { MutateArgs } from "./args.ts";
 import type { MutateConfig } from "./config.ts";
-/** Run Stryker against the resolved config. Inherits stdio for the live reporter; returns the exit code. */
-export declare function runStryker(cfg: MutateConfig): Promise<number>;
-/** Build the useless-test report from an existing mutation.json (no Stryker run). */
-export declare function reportFromFile(cfg: MutateConfig): Promise<string>;
+import type { EngineResult } from "./engine/types.ts";
+/** `--engine` survives for scripts that pass `--engine bun`; Stryker is gone. */
+export declare function resolveEngine(args: MutateArgs): "bun";
+/** The notice printed when the bun engine reads a Stryker config; null for polly.mutate.ts. */
+export declare function deprecationNotice(cfg: MutateConfig): string | null;
+/** `thresholds.break` failure line, or null when the score clears it (or none is set). */
+export declare function thresholdFailure(score: number | null, cfg: MutateConfig): string | null;
+/** Run the Bun-native engine and print a per-target summary. Returns the exit code. */
+export declare function runBunEngine(cfg: MutateConfig, args: MutateArgs): Promise<number>;
 /**
- * If the Stryker config doesn't already load polly's verify-primitive ignorer,
- * return a one-line tip. The ignorer must be in the config before the run (it's
- * read at Stryker startup), so this advises rather than mutating the user's config.
+ * The block printed when a baseline failed through a contract: the unmutated
+ * code, under one of its own tests, falsified a requires/ensures. That is a
+ * finding about the test or the handler, not about any mutant, so the run
+ * stops instead of scoring the target.
  */
-export declare function presetAdvisory(cfg: MutateConfig): Promise<string | null>;
+export declare function contractViolationsBlock(result: EngineResult, cwd: string): string;
+/** Build the useless-test report from an existing mutation.json (no engine run). */
+export declare function reportFromFile(cfg: MutateConfig): Promise<string>;

package/dist/tools/mutate/src/verify-matrix.d.ts

@@ -1,20 +1,20 @@
 /**
  * Verification artefact for the kill-matrix contract.
  *
- * The whole useless-test analysis rests on one fact: the patched bun runner
- * emits a COMPLETE kill matrix — every test that detects a mutant appears in
- * killedBy, not just the first. That depends on a pinned pair: (Bun version,
- * plugin version + our patch). A Bun upgrade that changes JUnit output, or a
- * patch that stops applying, would silently collapse killedBy to one id each —
- * a green board with the redundancy signal quietly dead (the classic trap).
+ * The whole useless-test analysis rests on one fact: matrix mode emits a
+ * COMPLETE kill matrix — every test that detects a mutant appears in killedBy,
+ * not just the first. That depends on Bun's junit output (engine/junit.ts). A
+ * Bun upgrade that changes it, or a `--bail` that creeps back into matrix runs,
+ * would silently collapse killedBy to one id each — a green board with the
+ * redundancy signal quietly dead (the classic trap).
  *
  * `verifyMatrix` runs the full contract and returns the result; `isMatrixComplete`
  * is the side-effect-free gate the report path consults to decide whether the
  * redundancy/subsumption sections are trustworthy. Run the CLI form after any
- * bump of Bun or the plugin:
+ * Bun bump:
  *
  *   polly mutate verify          # uses the existing report
- *   polly mutate verify --run    # runs stryker first
+ *   polly mutate verify --run    # runs the engine in matrix mode first
  */
 import { type MutationReport } from "./ingest.ts";
 export interface MatrixCheck {
@@ -28,7 +28,7 @@ export interface MatrixCheck {
 /**
  * Side-effect-free gate: is the kill matrix trustworthy for redundancy /
  * subsumption analysis? True only when
- *   (a) some killed mutant has >1 killer — proof the no-bail patched runner
+ *   (a) some killed mutant has >1 killer — proof the no-bail matrix run
  *       recorded EVERY killer, not just the first (verifyMatrix check #4), and
  *   (b) coverage was collected — not every mutant is NoCoverage, which would
  *       mean the coverage dump broke (verifyMatrix check #5).
@@ -37,13 +37,10 @@ export interface MatrixCheck {
  */
 export declare function isMatrixComplete(report: MutationReport): boolean;
 /**
- * Run the full kill-matrix contract (all five checks), optionally running a
- * fresh Stryker pass first. Returns the result rather than exiting, so callers
- * decide what to do with it; the `import.meta.main` wrapper prints and sets the
- * exit code.
+ * Run the full kill-matrix contract (all five checks) on a report. Returns the
+ * result rather than exiting, so callers decide what to do with it.
+ * `polly mutate verify --run` writes a fresh matrix-mode report first.
  */
 export declare function verifyMatrix(opts?: {
     reportPath?: string;
-    run?: boolean;
-    strykerConfig?: string;
 }): Promise<MatrixCheck>;

package/dist/tools/quality/src/cli.js

@@ -2643,9 +2643,9 @@ var noRawHttp = {
     return { ok: violations.length === 0, messages: violations };
   }
 };
-async function runTscFor(packagePath, rootDir) {
-  const proc = Bun.spawn(["bunx", "tsc", "--noEmit", "-p", packagePath], {
-    cwd: rootDir,
+async function runTypecheckFor(packagePath) {
+  const proc = Bun.spawn(["bun", "--check"], {
+    cwd: packagePath,
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -2668,7 +2668,7 @@ async function findWorkspaces(rootDir, patterns) {
 }
 var types = {
   id: "polly:types",
-  description: "Run `tsc --noEmit` against each workspace package in parallel",
+  description: "Run `bun check` (tsc-compatible) against each workspace package in parallel",
   filesRead: async () => {
     return [];
   },
@@ -2677,12 +2677,12 @@ var types = {
     const packages = await findWorkspaces(rootDir, patterns);
     if (packages.length === 0)
       return { ok: true, messages: ["no workspace packages found"] };
-    const results = await Promise.all(packages.map((p) => runTscFor(p, rootDir)));
+    const results = await Promise.all(packages.map((p) => runTypecheckFor(p)));
     return aggregateTypesResults(packages, results, rootDir);
   }
 };
-function appendTscFailure(messages, relPkg, output) {
-  messages.push(`${relPkg}: tsc --noEmit failed`);
+function appendTypecheckFailure(messages, relPkg, output) {
+  messages.push(`${relPkg}: bun check failed`);
   const trimmed = output.trim();
   if (!trimmed)
     return;
@@ -2699,7 +2699,7 @@ function aggregateTypesResults(packages, results, rootDir) {
     if (!pkg || !r || r.ok)
       continue;
     ok = false;
-    appendTscFailure(messages, relative6(rootDir, pkg) || ".", r.output);
+    appendTypecheckFailure(messages, relative6(rootDir, pkg) || ".", r.output);
   }
   return { ok, messages };
 }
@@ -3333,4 +3333,4 @@ switch (subcommand) {
 }
 process.exit(exitCode);
 
-//# debugId=2457D8123B12C85564756E2164756E21
+//# debugId=E090B73AFCD635EC64756E2164756E21