apex-mutation-testing 1.6.0 → 1.7.0

package/lib/service/mutationGrouper.js

@@ -0,0 +1,130 @@
+import { buildAdjacency } from './exactColoring.js';
+// Partition mutations into the smallest number of conflict-free groups using
+// DSATUR (Brélaz, 1979): the strongest polynomial-time graph-coloring
+// heuristic. At each step, color the uncolored vertex whose **saturation**
+// (count of distinct colors already used by its colored neighbors) is highest;
+// tiebreak on raw degree, then input order. Provably optimal on bipartite
+// graphs and several other structured classes; near-optimal on the rest.
+//
+// Each color = one batched deployment + one batched test run. Two mutations
+// share a color iff their covering tests are pairwise disjoint, so test
+// outcomes can be reverse-mapped per mutation without ambiguity.
+//
+// The conflict graph is the intersection graph of per-mutation test sets:
+// every test method T induces a clique among the mutations it covers. The
+// largest such test-induced set is a free lower bound on the chromatic
+// number; pre-coloring it before DSATUR runs both gives the heuristic a
+// maximally-constrained start and surfaces an optimality certificate
+// (groups.length === lowerBound implies provably optimal).
+export const groupMutations = (mutations, testMethodsPerLine) => {
+    const { groups, lowerBound } = groupMutationsWithInternals(mutations, testMethodsPerLine);
+    return { groups, lowerBound };
+};
+// Like `groupMutations` but additionally exposes the conflict graph, witness
+// clique, DSATUR coloring, and per-mutation test sets. Used by the optional
+// SAT-based exact-coloring path so it can re-use the work without rebuilding
+// the graph.
+export const groupMutationsWithInternals = (mutations, testMethodsPerLine) => {
+    const n = mutations.length;
+    if (n === 0) {
+        return {
+            groups: [],
+            lowerBound: 0,
+            internals: { adjacency: [], witness: [], coloring: [], tests: [] },
+        };
+    }
+    const tests = mutations.map(m => testMethodsPerLine.get(m.target.startToken.line) ?? new Set());
+    const adjacency = buildAdjacency(tests);
+    const degree = adjacency.map(neighbors => neighbors.length);
+    const witness = computeLowerBoundClique(tests);
+    const color = new Array(n).fill(-1);
+    const saturation = new Array(n).fill(0);
+    const neighborColors = Array.from({ length: n }, () => new Set());
+    for (let k = 0; k < witness.length; ++k) {
+        const v = witness[k];
+        color[v] = k;
+        propagate(v, k, adjacency, color, neighborColors, saturation);
+    }
+    for (let step = 0; step < n - witness.length; ++step) {
+        const pick = pickNextVertex(color, saturation, degree);
+        const chosenColor = pickSmallestAvailableColor(neighborColors[pick]);
+        color[pick] = chosenColor;
+        propagate(pick, chosenColor, adjacency, color, neighborColors, saturation);
+    }
+    return {
+        groups: assembleGroups(mutations, tests, color),
+        lowerBound: witness.length,
+        internals: { adjacency, witness, coloring: color, tests },
+    };
+};
+// Returns the indices of the largest test-induced clique. Each test method T
+// induces a clique among {m : T ∈ tests(m)}; we pick the largest such bucket.
+// O(n · k) where k = avg tests per mutation. Indexes by mutation (not by
+// line) so two mutations sharing the same Set reference still produce two
+// distinct witness entries.
+const computeLowerBoundClique = (tests) => {
+    const testToMutations = new Map();
+    for (let i = 0; i < tests.length; ++i) {
+        for (const t of tests[i]) {
+            const bucket = testToMutations.get(t);
+            if (bucket === undefined)
+                testToMutations.set(t, [i]);
+            else
+                bucket.push(i);
+        }
+    }
+    let best = [];
+    for (const indices of testToMutations.values()) {
+        if (indices.length > best.length)
+            best = indices;
+    }
+    // Stable canonical order: ascending by mutation index. Combined with the
+    // strict-`>` tiebreak in pickNextVertex, makes the entire pipeline
+    // deterministic for fixed input.
+    return best.slice().sort((a, b) => a - b);
+};
+const propagate = (v, c, adjacency, color, neighborColors, saturation) => {
+    for (const neighbor of adjacency[v]) {
+        if (color[neighbor] === -1 && !neighborColors[neighbor].has(c)) {
+            neighborColors[neighbor].add(c);
+            ++saturation[neighbor];
+        }
+    }
+};
+// Strict `>` comparisons mean equal-key candidates retain the first-encountered
+// pick — which is the lowest unprocessed index. Switching to `>=` would
+// silently invert determinism on every tied pair; keep the contract.
+const pickNextVertex = (color, saturation, degree) => {
+    let pick = -1;
+    for (let i = 0; i < color.length; ++i) {
+        if (color[i] !== -1)
+            continue;
+        if (pick === -1 ||
+            saturation[i] > saturation[pick] ||
+            (saturation[i] === saturation[pick] && degree[i] > degree[pick])) {
+            pick = i;
+        }
+    }
+    return pick;
+};
+const pickSmallestAvailableColor = (neighborColors) => {
+    let candidate = 0;
+    while (neighborColors.has(candidate)) {
+        ++candidate;
+    }
+    return candidate;
+};
+export const assembleGroups = (mutations, tests, color) => {
+    const groups = [];
+    for (let i = 0; i < mutations.length; ++i) {
+        const c = color[i];
+        while (groups.length <= c) {
+            groups.push({ mutations: [], testMethods: new Set() });
+        }
+        groups[c].mutations.push(mutations[i]);
+        for (const t of tests[i])
+            groups[c].testMethods.add(t);
+    }
+    return groups;
+};
+//# sourceMappingURL=mutationGrouper.js.map

package/lib/service/mutationGrouper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutationGrouper.js","sourceRoot":"","sources":["../../src/service/mutationGrouper.ts"],"names":[],"mappings":"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"}

package/lib/service/mutationLocation.d.ts

@@ -0,0 +1,12 @@
+import { ApexMutation } from '../type/ApexMutation.js';
+export declare const calculateMutationPosition: (mutation: ApexMutation) => {
+    start: {
+        line: number;
+        column: number;
+    };
+    end: {
+        line: number;
+        column: number;
+    };
+};
+export declare const extractMutationOriginalText: (mutation: ApexMutation, sourceContent: string) => string;

package/lib/service/mutationLocation.js

@@ -0,0 +1,54 @@
+// Advance a 1-indexed (line, column) cursor through `text`, returning the
+// position immediately AFTER the last character. Handles tokens whose text
+// spans newlines (multi-line string literals, block comments).
+//
+// Used to compute the Stryker `end` position for a mutation: ANTLR tokens
+// expose `line` and `charPositionInLine` for the START of the token but not
+// past the end; walking `endToken.text` closes that gap without needing a
+// separate line-offset index over the whole source.
+const advancePosition = (text, startLine, startColumn) => {
+    let line = startLine;
+    let column = startColumn;
+    for (let i = 0; i < text.length; i++) {
+        if (text.charCodeAt(i) === 10 /* \n */) {
+            line++;
+            column = 1;
+        }
+        else {
+            column++;
+        }
+    }
+    return { line, column };
+};
+export const calculateMutationPosition = (mutation) => {
+    const start = mutation.target.startToken;
+    const end = mutation.target.endToken;
+    if (start.startIndex === undefined ||
+        end.stopIndex === undefined ||
+        end.text === undefined) {
+        throw new Error(`Failed to calculate position for mutation: ${mutation.mutationName}`);
+    }
+    // ANTLR tokens expose the position of the FIRST character directly.
+    // The Stryker `end` position is exclusive (one past the last char), so
+    // we walk endToken.text to advance from the end token's own start.
+    // This correctly handles tokens that span newlines (multi-line string
+    // literals, block comments).
+    return {
+        start: {
+            line: start.line,
+            column: start.charPositionInLine + 1,
+        },
+        end: advancePosition(end.text, end.line, end.charPositionInLine + 1),
+    };
+};
+export const extractMutationOriginalText = (mutation, sourceContent) => {
+    const start = mutation.target.startToken;
+    const end = mutation.target.endToken;
+    if (start.startIndex !== undefined &&
+        end.stopIndex !== undefined &&
+        sourceContent) {
+        return sourceContent.substring(start.startIndex, end.stopIndex + 1);
+    }
+    throw new Error(`Failed to extract original text for mutation: ${mutation.mutationName}`);
+};
+//# sourceMappingURL=mutationLocation.js.map

package/lib/service/mutationLocation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutationLocation.js","sourceRoot":"","sources":["../../src/service/mutationLocation.ts"],"names":[],"mappings":"AAEA,0EAA0E;AAC1E,2EAA2E;AAC3E,+DAA+D;AAC/D,EAAE;AACF,0EAA0E;AAC1E,4EAA4E;AAC5E,0EAA0E;AAC1E,oDAAoD;AACpD,MAAM,eAAe,GAAG,CACtB,IAAY,EACZ,SAAiB,EACjB,WAAmB,EACe,EAAE;IACpC,IAAI,IAAI,GAAG,SAAS,CAAA;IACpB,IAAI,MAAM,GAAG,WAAW,CAAA;IACxB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,CAAC;YACvC,IAAI,EAAE,CAAA;YACN,MAAM,GAAG,CAAC,CAAA;QACZ,CAAC;aAAM,CAAC;YACN,MAAM,EAAE,CAAA;QACV,CAAC;IACH,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAA;AACzB,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACvC,QAAsB,EAItB,EAAE;IACF,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAA;IACxC,MAAM,GAAG,GAAG,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAA;IAEpC,IACE,KAAK,CAAC,UAAU,KAAK,SAAS;QAC9B,GAAG,CAAC,SAAS,KAAK,SAAS;QAC3B,GAAG,CAAC,IAAI,KAAK,SAAS,EACtB,CAAC;QACD,MAAM,IAAI,KAAK,CACb,8CAA8C,QAAQ,CAAC,YAAY,EAAE,CACtE,CAAA;IACH,CAAC;IAED,oEAAoE;IACpE,uEAAuE;IACvE,mEAAmE;IACnE,sEAAsE;IACtE,6BAA6B;IAC7B,OAAO;QACL,KAAK,EAAE;YACL,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,MAAM,EAAE,KAAK,CAAC,kBAAkB,GAAG,CAAC;SACrC;QACD,GAAG,EAAE,eAAe,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,kBAAkB,GAAG,CAAC,CAAC;KACrE,CAAA;AACH,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,2BAA2B,GAAG,CACzC,QAAsB,EACtB,aAAqB,EACb,EAAE;IACV,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAA;IACxC,MAAM,GAAG,GAAG,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAA;IAEpC,IACE,KAAK,CAAC,UAAU,KAAK,SAAS;QAC9B,GAAG,CAAC,SAAS,KAAK,SAAS;QAC3B,aAAa,EACb,CAAC;QACD,OAAO,aAAa,CAAC,SAAS,CAAC,KAAK,CAAC,UAAU,EAAE,GAAG,CAAC,SAAS,GAAG,CAAC,CAAC,CAAA;IACrE,CAAC;IAED,MAAM,IAAI,KAAK,CACb,iDAAiD,QAAQ,CAAC,YAAY,EAAE,CACzE,CAAA;AACH,CAAC,CAAA"}

package/lib/service/mutationTestingService.d.ts

@@ -16,13 +16,12 @@ export declare class MutationTestingService {
     protected readonly excludeTestMethods: string[] | undefined;
     private readonly skipPatterns;
     private readonly allowedLines;
+    private readonly mutationGroupingEnabled;
     private apexClassContent;
-    constructor(progress: Progress, spinner: Spinner, connection: Connection, { apexClassName, apexTestClassName, dryRun, includeMutators, excludeMutators, includeTestMethods, excludeTestMethods, skipPatterns, lines, }: ApexMutationParameter, messages: Messages<string>);
+    constructor(progress: Progress, spinner: Spinner, connection: Connection, { apexClassName, apexTestClassName, dryRun, includeMutators, excludeMutators, includeTestMethods, excludeTestMethods, skipPatterns, lines, mutationGrouping, }: ApexMutationParameter, messages: Messages<string>);
     process(): Promise<ApexMutationTestResult>;
+    private planGroups;
     calculateScore(mutationResult: ApexMutationTestResult): number;
-    private buildMutantResult;
-    private calculateMutationPosition;
-    private convertAbsoluteIndexToLineColumn;
     private filterTestMethods;
     private createAdapters;
     private fetchApexClass;
@@ -36,8 +35,5 @@ export declare class MutationTestingService {
     private displayTimeEstimate;
     private buildDryRunResult;
     private executeMutationLoop;
-    private evaluateMutation;
-    private formatRemainingTime;
     private rollback;
-    private extractMutationOriginalText;
 }

package/lib/service/mutationTestingService.js

@@ -2,35 +2,14 @@ import { ApexClassRepository } from '../adapter/apexClassRepository.js';
 import { ApexTestRunner } from '../adapter/apexTestRunner.js';
 import { SObjectDescribeRepository } from '../adapter/sObjectDescribeRepository.js';
 import { ConfigReader } from './configReader.js';
+import { decideExactOutcome, solveColoring } from './exactColoring.js';
+import { GroupExecutor } from './groupExecutor.js';
 import { MutantGenerator } from './mutantGenerator.js';
+import { assembleGroups, groupMutationsWithInternals, } from './mutationGrouper.js';
+import { calculateMutationPosition, extractMutationOriginalText, } from './mutationLocation.js';
 import { formatDuration, timeExecution } from './timeUtils.js';
 import { TypeDiscoverer } from './typeDiscoverer.js';
 import { ApexClassTypeMatcher, SObjectTypeMatcher } from './typeMatcher.js';
-const errorStrategies = [
-    {
-        matches: msg => msg.startsWith('Deployment failed:'),
-        classify: (msg, targetInfo) => ({
-            status: 'CompileError',
-            statusReason: msg,
-            progressMessage: `Mutation result: compile error at line ${targetInfo.line}`,
-        }),
-    },
-    {
-        matches: msg => msg.includes('LIMIT_USAGE_FOR_NS'),
-        classify: msg => ({
-            status: 'Killed',
-            progressMessage: `Mutation result: mutant killed (${msg})`,
-        }),
-    },
-    {
-        matches: () => true,
-        classify: msg => ({
-            status: 'RuntimeError',
-            statusReason: msg,
-            progressMessage: `Mutation result: runtime error (${msg})`,
-        }),
-    },
-];
 export class MutationTestingService {
     progress;
     spinner;
@@ -45,8 +24,9 @@ export class MutationTestingService {
     excludeTestMethods;
     skipPatterns;
     allowedLines;
+    mutationGroupingEnabled;
     apexClassContent = '';
-    constructor(progress, spinner, connection, { apexClassName, apexTestClassName, dryRun, includeMutators, excludeMutators, includeTestMethods, excludeTestMethods, skipPatterns, lines, }, messages) {
+    constructor(progress, spinner, connection, { apexClassName, apexTestClassName, dryRun, includeMutators, excludeMutators, includeTestMethods, excludeTestMethods, skipPatterns, lines, mutationGrouping, }, messages) {
         this.progress = progress;
         this.spinner = spinner;
         this.connection = connection;
@@ -60,24 +40,66 @@ export class MutationTestingService {
         this.excludeTestMethods = excludeTestMethods;
         this.skipPatterns = ConfigReader.compileSkipPatterns(skipPatterns);
         this.allowedLines = ConfigReader.parseLineRanges(lines);
+        this.mutationGroupingEnabled = mutationGrouping ?? false;
     }
     async process() {
         const { apexClassRepository, apexTestRunner } = this.createAdapters();
         const apexClass = await this.fetchApexClass(apexClassRepository);
-        const typeRegistry = await this.discoverTypes(apexClass, apexClassRepository);
+        const typeAnalysis = await this.discoverTypes(apexClass, apexClassRepository);
         const deployTime = await this.verifyCompilation(apexClass, apexClassRepository);
         await this.verifyTestClassCompilation(apexClassRepository);
         const { testMethodsPerLine, testTime } = await this.runBaselineTests(apexTestRunner);
         const coveredLines = this.extractCoveredLines(testMethodsPerLine);
-        const { mutations, mutantGenerator } = this.generateMutations(apexClass, coveredLines, typeRegistry);
-        this.displayTimeEstimate(deployTime, testTime, mutations.length);
+        const { mutations, mutantGenerator, tokenStream } = this.generateMutations(apexClass, coveredLines, typeAnalysis);
         if (this.dryRun) {
+            this.displayTimeEstimate(deployTime, testTime, mutations.length, mutations.length);
             return this.buildDryRunResult(apexClass, mutations);
         }
-        const result = await this.executeMutationLoop(apexClass, mutations, mutantGenerator, testMethodsPerLine, apexTestRunner, apexClassRepository);
+        const groups = await this.planGroups(mutations, testMethodsPerLine);
+        this.displayTimeEstimate(deployTime, testTime, mutations.length, groups.length);
+        const result = await this.executeMutationLoop(apexClass, mutations, groups, mutantGenerator, tokenStream, testMethodsPerLine, apexTestRunner, apexClassRepository);
         await this.rollback(apexClass, apexClassRepository);
         return result;
     }
+    async planGroups(mutations, testMethodsPerLine) {
+        if (!this.mutationGroupingEnabled) {
+            // No grouping: one mutation per group. Inlined here rather than going
+            // through groupMutations to avoid building the conflict graph for the
+            // common (default-off) case.
+            return mutations.map(m => ({
+                mutations: [m],
+                // extractCoveredLines guarantees the line is in the map.
+                testMethods: testMethodsPerLine.get(m.target.startToken.line),
+            }));
+        }
+        this.spinner.start(`Grouping ${mutations.length} mutations to minimize deployments`, undefined, { stdout: true });
+        const { groups: dsaturGroups, lowerBound, internals, } = groupMutationsWithInternals(mutations, testMethodsPerLine);
+        let groups = dsaturGroups;
+        const exact = solveColoring({
+            adjacency: internals.adjacency,
+            n: mutations.length,
+            lowerBound,
+            dsaturColors: dsaturGroups.length,
+            witness: internals.witness,
+            dsaturColoring: internals.coloring,
+        });
+        const decision = decideExactOutcome(exact, dsaturGroups.length);
+        const exactSuffix = decision.suffix;
+        if (decision.useGroups === 'exact') {
+            groups = assembleGroups(mutations, internals.tests, exact.coloring);
+        }
+        // Division is safe: generateMutations throws when mutations is empty,
+        // so planGroups is never reached with mutations.length === 0.
+        const savingsPct = Math.round((1 - groups.length / mutations.length) * 100);
+        this.spinner.stop(this.messages.getMessage('info.groupingPlan', [
+            String(mutations.length),
+            String(groups.length),
+            String(savingsPct),
+            String(lowerBound),
+            exactSuffix,
+        ]));
+        return groups;
+    }
     calculateScore(mutationResult) {
         const validMutants = mutationResult.mutants.filter(mutant => mutant.status !== 'CompileError');
         if (validMutants.length === 0) {
@@ -88,37 +110,6 @@ export class MutationTestingService {
             validMutants.length) *
             100);
     }
-    buildMutantResult(mutation, testResult, targetInfo) {
-        const mutationStatus = testResult.summary.outcome === 'Passed' ? 'Survived' : 'Killed';
-        const location = this.calculateMutationPosition(mutation, this.apexClassContent);
-        const originalText = this.extractMutationOriginalText(mutation);
-        return {
-            id: `${this.apexClassName}-${targetInfo.line}-${targetInfo.column}-${targetInfo.tokenIndex}-${Date.now()}`,
-            mutatorName: mutation.mutationName,
-            status: mutationStatus,
-            location,
-            replacement: mutation.replacement,
-            original: originalText,
-        };
-    }
-    calculateMutationPosition(mutation, sourceContent) {
-        const start = mutation.target.startToken;
-        const end = mutation.target.endToken;
-        if (start.startIndex !== undefined && end.stopIndex !== undefined) {
-            const startPos = this.convertAbsoluteIndexToLineColumn(sourceContent, start.startIndex);
-            const endPos = this.convertAbsoluteIndexToLineColumn(sourceContent, end.stopIndex + 1);
-            return { start: startPos, end: endPos };
-        }
-        throw new Error(`Failed to calculate position for mutation: ${mutation.mutationName}`);
-    }
-    convertAbsoluteIndexToLineColumn(sourceContent, absoluteIndex) {
-        const textBeforeIndex = sourceContent.substring(0, absoluteIndex);
-        const lines = textBeforeIndex.split('\n');
-        return {
-            line: lines.length,
-            column: lines[lines.length - 1].length + 1,
-        };
-    }
     filterTestMethods(testMethodsPerLine) {
         const filterSet = this.includeTestMethods
             ? new Set(this.includeTestMethods)
@@ -170,9 +161,9 @@ export class MutationTestingService {
         const typeDiscoverer = new TypeDiscoverer()
             .withMatcher(apexClassMatcher)
             .withMatcher(sObjectMatcher);
-        const typeRegistry = await typeDiscoverer.analyze(apexClass.Body);
+        const analysis = await typeDiscoverer.analyzeFull(apexClass.Body);
         this.spinner.stop('Done');
-        return typeRegistry;
+        return analysis;
     }
     async verifyCompilation(apexClass, apexClassRepository) {
         this.spinner.start(`Verifying "${this.apexClassName}" apex class compilation`, undefined, { stdout: true });
@@ -237,11 +228,11 @@ export class MutationTestingService {
         }
         return coveredLines;
     }
-    generateMutations(apexClass, coveredLines, typeRegistry) {
+    generateMutations(apexClass, coveredLines, typeAnalysis) {
         this.spinner.start(`Generating mutants for "${this.apexClassName}" ApexClass`, undefined, { stdout: true });
         const mutantGenerator = new MutantGenerator();
         const mutatorFilter = this.buildMutatorFilter();
-        const mutations = mutantGenerator.compute(apexClass.Body, coveredLines, typeRegistry, mutatorFilter, this.skipPatterns, this.allowedLines);
+        const { mutations, tokenStream } = mutantGenerator.compute(apexClass.Body, coveredLines, typeAnalysis.typeRegistry, mutatorFilter, this.skipPatterns, this.allowedLines, { tree: typeAnalysis.tree, tokenStream: typeAnalysis.tokenStream });
         if (mutations.length === 0) {
             this.spinner.stop('0 mutations generated');
             throw new Error(this.messages.getMessage('error.noMutations', [
@@ -250,7 +241,7 @@ export class MutationTestingService {
             ]));
         }
         this.spinner.stop(`${mutations.length} mutations generated`);
-        return { mutations, mutantGenerator };
+        return { mutations, mutantGenerator, tokenStream };
     }
     buildMutatorFilter() {
         if (this.includeMutators)
@@ -259,8 +250,8 @@ export class MutationTestingService {
             return { exclude: this.excludeMutators };
         return undefined;
     }
-    displayTimeEstimate(deployTime, testTime, mutationCount) {
-        const totalEstimateMs = (deployTime + testTime) * mutationCount;
+    displayTimeEstimate(deployTime, testTime, mutationCount, groupCount) {
+        const totalEstimateMs = (deployTime + testTime) * groupCount;
         this.spinner.start(this.messages.getMessage('info.timeEstimate', [
             formatDuration(totalEstimateMs),
         ]), undefined, { stdout: true });
@@ -268,6 +259,7 @@ export class MutationTestingService {
             formatDuration(deployTime),
             formatDuration(testTime),
             String(mutationCount),
+            String(groupCount),
         ]));
     }
     buildDryRunResult(apexClass, mutations) {
@@ -279,116 +271,49 @@ export class MutationTestingService {
                 id: `${this.apexClassName}-${mutation.target.startToken.line}-${mutation.target.startToken.charPositionInLine}-${mutation.target.startToken.tokenIndex}-${Date.now()}`,
                 mutatorName: mutation.mutationName,
                 status: 'Pending',
-                location: this.calculateMutationPosition(mutation, apexClass.Body),
+                location: calculateMutationPosition(mutation),
                 replacement: mutation.replacement,
-                original: this.extractMutationOriginalText(mutation),
+                original: extractMutationOriginalText(mutation, this.apexClassContent),
             })),
         };
     }
-    async executeMutationLoop(apexClass, mutations, mutantGenerator, testMethodsPerLine, apexTestRunner, apexClassRepository) {
-        const mutationResults = {
-            sourceFile: this.apexClassName,
-            sourceFileContent: apexClass.Body,
-            testFile: this.apexTestClassName,
-            mutants: [],
-        };
+    async executeMutationLoop(apexClass, mutations, groups, mutantGenerator, tokenStream, testMethodsPerLine, apexTestRunner, apexClassRepository) {
         this.progress.start(mutations.length, { info: 'Starting mutation testing' }, {
             title: 'MUTATION TESTING PROGRESS',
             format: '%s | {bar} | {value}/{total} {info}',
         });
-        let mutationCount = 0;
+        const executor = new GroupExecutor(apexClass, this.apexClassName, this.apexTestClassName, this.apexClassContent, tokenStream, testMethodsPerLine, mutantGenerator, apexTestRunner, apexClassRepository, this.progress, this.messages);
+        const indexByMutation = new Map(mutations.map((m, i) => [m, i]));
+        const orderedResults = new Array(mutations.length).fill(null);
+        let completed = 0;
         const loopStartTime = performance.now();
-        for (const mutation of mutations) {
-            const remainingText = this.formatRemainingTime(loopStartTime, mutationCount, mutations.length);
-            this.progress.update(mutationCount, {
-                info: `${remainingText}Deploying "${mutation.replacement}" mutation at line ${mutation.target.startToken.line}`,
-            });
-            const testMethods = testMethodsPerLine.get(mutation.target.startToken.line);
-            if (testMethods) {
-                this.progress.update(mutationCount, {
-                    info: `${remainingText}Running ${testMethods.size} tests methods for "${mutation.replacement}" mutation at line ${mutation.target.startToken.line}`,
-                });
+        for (const group of groups) {
+            const mutantResults = await executor.evaluate(group, completed, loopStartTime, mutations.length);
+            for (let i = 0; i < group.mutations.length; ++i) {
+                const idx = indexByMutation.get(group.mutations[i]);
+                orderedResults[idx] = mutantResults[i];
             }
-            const { mutantResult, progressMessage } = await this.evaluateMutation(mutation, mutantGenerator, apexClass, testMethodsPerLine, apexTestRunner, apexClassRepository);
-            mutationResults.mutants.push(mutantResult);
-            ++mutationCount;
-            const updatedRemainingText = this.formatRemainingTime(loopStartTime, mutationCount, mutations.length);
-            this.progress.update(mutationCount, {
-                info: `${updatedRemainingText}${progressMessage}`,
-            });
+            completed += group.mutations.length;
         }
         this.progress.finish({ info: 'All mutations evaluated' });
-        return mutationResults;
-    }
-    async evaluateMutation(mutation, mutantGenerator, apexClass, testMethodsPerLine, apexTestRunner, apexClassRepository) {
-        const mutatedVersion = mutantGenerator.mutate(mutation);
-        const targetInfo = {
-            line: mutation.target.startToken.line,
-            column: mutation.target.startToken.charPositionInLine,
-            tokenIndex: mutation.target.startToken.tokenIndex,
-            text: mutation.target.text,
+        return {
+            sourceFile: this.apexClassName,
+            sourceFileContent: apexClass.Body,
+            testFile: this.apexTestClassName,
+            mutants: orderedResults.filter((r) => r !== null),
         };
-        try {
-            await apexClassRepository.update({
-                Id: apexClass.Id,
-                Body: mutatedVersion,
-            });
-            const testMethods = testMethodsPerLine.get(targetInfo.line);
-            const testResult = await apexTestRunner.runTestMethods(this.apexTestClassName, testMethods);
-            return {
-                mutantResult: this.buildMutantResult(mutation, testResult, targetInfo),
-                progressMessage: `Mutation result: ${testResult.summary.outcome === 'Passed' ? 'zombie' : 'mutant killed'}`,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const location = this.calculateMutationPosition(mutation, this.apexClassContent);
-            const originalText = this.extractMutationOriginalText(mutation);
-            const strategy = errorStrategies.find(s => s.matches(errorMessage));
-            const classification = strategy.classify(errorMessage, targetInfo);
-            return {
-                mutantResult: {
-                    id: `${this.apexClassName}-${targetInfo.line}-${targetInfo.column}-${targetInfo.tokenIndex}-${Date.now()}`,
-                    mutatorName: mutation.mutationName,
-                    status: classification.status,
-                    ...(classification.statusReason && {
-                        statusReason: classification.statusReason,
-                    }),
-                    location,
-                    replacement: mutation.replacement,
-                    original: originalText,
-                },
-                progressMessage: classification.progressMessage,
-            };
-        }
-    }
-    formatRemainingTime(loopStartTime, completedCount, totalCount) {
-        if (completedCount === 0)
-            return '';
-        const elapsed = performance.now() - loopStartTime;
-        const avgPerMutant = elapsed / completedCount;
-        const remainingMs = avgPerMutant * (totalCount - completedCount);
-        return `Remaining: ${formatDuration(remainingMs)} | `;
     }
     async rollback(apexClass, apexClassRepository) {
+        this.spinner.start(`Rolling back "${this.apexClassName}" ApexClass to its original state`, undefined, { stdout: true });
         try {
-            this.spinner.start(`Rolling back "${this.apexClassName}" ApexClass to its original state`, undefined, { stdout: true });
             await apexClassRepository.update(apexClass);
             this.spinner.stop('Done');
         }
-        catch {
-            this.spinner.stop('Class not rolled back, please do it manually');
-        }
-    }
-    extractMutationOriginalText(mutation) {
-        const start = mutation.target.startToken;
-        const end = mutation.target.endToken;
-        if (start.startIndex !== undefined &&
-            end.stopIndex !== undefined &&
-            this.apexClassContent) {
-            return this.apexClassContent.substring(start.startIndex, end.stopIndex + 1);
+        catch (error) {
+            this.spinner.stop(`Rollback FAILED — '${this.apexClassName}' remains in a mutated state on the target org. Redeploy the original class manually.`);
+            const cause = error instanceof Error ? error.message : String(error);
+            throw new Error(`Rollback of '${this.apexClassName}' failed. The class on the target org is still in a mutated state. Redeploy manually. Underlying cause: ${cause}`);
         }
-        throw new Error(`Failed to extract original text for mutation: ${mutation.mutationName}`);
     }
 }
 //# sourceMappingURL=mutationTestingService.js.map