@automaton-labs/aib 0.0.7 → 0.0.8

package/dist/mutation/mutation-plan.js

@@ -0,0 +1,467 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMutationPlanFromSegments = buildMutationPlanFromSegments;
+const path = __importStar(require("node:path"));
+const file_impact_scan_1 = require("./file-impact-scan");
+const file_mutation_eta_1 = require("./file-mutation-eta");
+const semantic_impact_scan_1 = require("./semantic-impact-scan");
+function buildMutationPlanFromSegments(input) {
+    const groups = input.segments.map((segment, index) => buildGroup(input.cwd, segment, index));
+    for (const group of groups) {
+        group.estimate = buildEstimate([group]);
+    }
+    return {
+        version: 1,
+        operation: input.operation,
+        cwd: path.resolve(input.cwd),
+        groups,
+        estimate: buildEstimate(groups)
+    };
+}
+function buildGroup(cwd, segment, index) {
+    const id = `group_${index + 1}`;
+    if (segment.kind === "semantic") {
+        const requests = readObjects(segment.requests);
+        const rows = requests.flatMap((request, requestIndex) => buildSemanticRows(cwd, id, request, requestIndex));
+        const semanticImpact = (0, semantic_impact_scan_1.estimateSemanticMutationImpact)({
+            cwd,
+            sourceFiles: rows.map((row) => row.sourceFile).filter((file) => Boolean(file)),
+            entities: rows.map((row) => row.entity).filter((entity) => Boolean(entity))
+        });
+        return {
+            id,
+            domain: "semantic",
+            mixable: true,
+            inputRowCount: Math.max(1, requests.length),
+            declarationCount: Math.max(1, rows.length),
+            rows,
+            phases: ["preflight", "collectProviderEdits", "applyTextEdits", "postProcessImports"],
+            semanticImpact
+        };
+    }
+    if (segment.kind === "file") {
+        const operations = readObjects(segment.operations);
+        const rows = operations.map((operation, operationIndex) => buildFileRow(cwd, id, operation, operationIndex));
+        const targetDirs = new Set(rows.map((row) => row.targetDir).filter((value) => Boolean(value)));
+        const impact = (0, file_impact_scan_1.estimateFileMutationImpact)(cwd, rows.map((row) => row.sourceFile).filter((file) => Boolean(file)));
+        const eta = (0, file_mutation_eta_1.estimateFileMutationEta)({
+            rowCount: rows.length,
+            targetDirCount: targetDirs.size,
+            dirsToCreate: targetDirs.size,
+            importingFileCount: impact.importingFileCount,
+            importStatementCount: impact.importStatementCount,
+            barrelExportCount: impact.barrelExportCount,
+            sourceFileCount: impact.sourceFileCount,
+            existingSourceFileCount: impact.existingSourceFileCount,
+            scanTruncated: impact.truncated
+        });
+        return {
+            id,
+            domain: "file",
+            mixable: true,
+            rows,
+            phases: ["preflight", "collectProviderEdits", "applyFileOps", "applyTextEdits", "applyAssetEdits", "postProcessImports", "postMutationChecks"],
+            impact,
+            eta
+        };
+    }
+    if (segment.kind === "modulePlan") {
+        const sourceFile = resolvePlanPath(cwd, readString(segment.sourceFile));
+        const rows = readObjects(segment.modules).flatMap((moduleRow, moduleIndex) => readModuleEntities(moduleRow).map((entity, entityIndex) => ({
+            id: `${id}_module_${moduleIndex + 1}_${entityIndex + 1}`,
+            domain: "modulePlan",
+            op: "modulePlan.move",
+            sourceFile,
+            targetFile: resolvePlanPath(cwd, readString(moduleRow.targetFile)),
+            entity,
+            providerRequests: [{
+                    kind: "moveRefactorEdits",
+                    sourceFile,
+                    targetFile: resolvePlanPath(cwd, readString(moduleRow.targetFile)),
+                    entity
+                }],
+            applySteps: [
+                { kind: "textEdits" },
+                { kind: "importCleanup" }
+            ],
+            recoveryCheckpoints: ["provider-collected", "text-edits-applied", "cleanup-applied"]
+        })));
+        const semanticImpact = (0, semantic_impact_scan_1.estimateSemanticMutationImpact)({
+            cwd,
+            sourceFiles: rows.map((row) => row.sourceFile).filter((file) => Boolean(file)),
+            entities: rows.map((row) => row.entity).filter((entity) => Boolean(entity))
+        });
+        return {
+            id,
+            domain: "modulePlan",
+            mixable: false,
+            rows,
+            phases: ["preflight", "collectProviderEdits", "applyTextEdits", "postProcessImports", "postMutationChecks"],
+            semanticImpact
+        };
+    }
+    if (segment.kind === "imports.normalize") {
+        return {
+            id,
+            domain: "imports.normalize",
+            mixable: false,
+            rows: [{
+                    id: `${id}_imports_normalize_1`,
+                    domain: "imports.normalize",
+                    op: "imports.normalize",
+                    sourceFile: resolvePlanPath(cwd, readString(isObject(segment.request) ? segment.request.scope : "")),
+                    providerRequests: [],
+                    applySteps: [{ kind: "textEdits" }],
+                    recoveryCheckpoints: ["imports-normalized"]
+                }],
+            phases: ["preflight", "applyTextEdits"]
+        };
+    }
+    if (segment.kind === "imports.rebase") {
+        const request = isObject(segment.request) ? segment.request : {};
+        return {
+            id,
+            domain: "imports.rebase",
+            mixable: false,
+            rows: [{
+                    id: `${id}_imports_rebase_1`,
+                    domain: "imports.rebase",
+                    op: readString(request.operation) || "imports.rebase",
+                    sourceFile: resolvePlanPath(cwd, readString(request.barrel)),
+                    providerRequests: [],
+                    applySteps: [{ kind: "textEdits" }],
+                    recoveryCheckpoints: ["imports-rebased"]
+                }],
+            phases: ["preflight", "applyTextEdits"]
+        };
+    }
+    if (segment.kind === "declaration") {
+        const request = isObject(segment.request) ? segment.request : {};
+        const files = readStringArray(request.files);
+        const selectors = readStringArray(request.selectors);
+        const rowCount = Math.max(1, files.length || selectors.length || 1);
+        return {
+            id,
+            domain: "declaration",
+            mixable: false,
+            rows: Array.from({ length: rowCount }, (_unused, rowIndex) => {
+                const entity = selectors[rowIndex] ?? selectors[0];
+                return {
+                    id: `${id}_declaration_${rowIndex + 1}`,
+                    domain: "declaration",
+                    op: `declaration.${readString(request.operation) || "unknown"}`,
+                    sourceFile: files[rowIndex] ? resolvePlanPath(cwd, files[rowIndex]) : resolvePlanPath(cwd, readString(request.scope)),
+                    ...(entity ? { entity } : {}),
+                    providerRequests: [],
+                    applySteps: [{ kind: "textEdits" }, { kind: "importCleanup" }],
+                    recoveryCheckpoints: ["declaration-planned", "text-edits-applied"]
+                };
+            }),
+            phases: ["preflight", "applyTextEdits", "postProcessImports"]
+        };
+    }
+    if (segment.kind === "exports.object") {
+        const sourceFile = resolvePlanPath(cwd, readString(segment.sourceFile));
+        const packs = readObjects(segment.packs);
+        const rows = packs.flatMap((pack, packIndex) => readStringArray(pack.selectors).map((selector, selectorIndex) => ({
+            id: `${id}_object_pack_${packIndex + 1}_${selectorIndex + 1}`,
+            domain: "exports.object",
+            op: readString(pack.operation) === "unpack" ? "object.unpack" : "object.pack",
+            sourceFile,
+            entity: selector,
+            providerRequests: [],
+            applySteps: [{ kind: "textEdits" }, { kind: "importCleanup" }],
+            recoveryCheckpoints: ["object-pack-planned", "text-edits-applied"]
+        })));
+        return {
+            id,
+            domain: "exports.object",
+            mixable: false,
+            rows,
+            phases: ["preflight", "applyTextEdits", "postProcessImports"]
+        };
+    }
+    if (segment.kind === "exports.star") {
+        const sourceFile = resolvePlanPath(cwd, readString(segment.sourceFile));
+        const selectors = readStringArray(segment.selectors);
+        return {
+            id,
+            domain: "exports.star",
+            mixable: false,
+            rows: (selectors.length > 0 ? selectors : ["*"]).map((selector, selectorIndex) => ({
+                id: `${id}_exports_star_${selectorIndex + 1}`,
+                domain: "exports.star",
+                op: readString(segment.operation) === "collapse" ? "exports.star.collapse" : "exports.star.expand",
+                sourceFile,
+                entity: selector,
+                providerRequests: [],
+                applySteps: [],
+                recoveryCheckpoints: ["exports-star-previewed"]
+            })),
+            phases: ["preflight"]
+        };
+    }
+    return {
+        id,
+        domain: "semantic",
+        mixable: true,
+        rows: [],
+        phases: ["preflight"]
+    };
+}
+function buildSemanticRows(cwd, groupId, request, requestIndex) {
+    const sourceFile = resolvePlanPath(cwd, readString(request.sourceFile));
+    if (request.op === "rename") {
+        const renames = readRenamePairs(request.renames);
+        return renames.map((rename, renameIndex) => ({
+            id: `${groupId}_rename_${requestIndex + 1}_${renameIndex + 1}`,
+            domain: "semantic",
+            op: "rename",
+            sourceFile,
+            entity: rename.entity,
+            newName: rename.newName,
+            providerRequests: [{
+                    kind: "renameLocations",
+                    sourceFile,
+                    entity: rename.entity,
+                    newName: rename.newName
+                }],
+            applySteps: [{ kind: "textEdits" }],
+            recoveryCheckpoints: ["provider-collected", "text-edits-applied"]
+        }));
+    }
+    if (request.op === "move") {
+        const targetFile = resolvePlanPath(cwd, readString(request.targetFile));
+        return readStringArray(request.entities).map((entity, entityIndex) => ({
+            id: `${groupId}_move_${requestIndex + 1}_${entityIndex + 1}`,
+            domain: "semantic",
+            op: "move",
+            sourceFile,
+            targetFile,
+            entity,
+            providerRequests: [{
+                    kind: "moveRefactorEdits",
+                    sourceFile,
+                    targetFile,
+                    entity
+                }],
+            applySteps: [
+                { kind: "textEdits" },
+                { kind: "importCleanup" }
+            ],
+            recoveryCheckpoints: ["provider-collected", "text-edits-applied", "cleanup-applied"]
+        }));
+    }
+    return [];
+}
+function buildFileRow(cwd, groupId, operation, operationIndex) {
+    const sourceFile = resolvePlanPath(cwd, readString(operation.sourceFile));
+    const targetFile = resolvePlanPath(cwd, readString(operation.targetFile));
+    const targetDir = resolvePlanPath(cwd, readString(operation.targetDir));
+    const op = operation.kind === "fileRename" ? "file.rename" : "file.moveToDir";
+    const fileStepKind = operation.kind === "fileRename" ? "fileRename" : "fileMove";
+    return {
+        id: `${groupId}_file_${operationIndex + 1}`,
+        domain: "file",
+        op,
+        sourceFile,
+        targetFile,
+        targetDir,
+        providerRequests: [{
+                kind: "fileRenameEdits",
+                sourceFile,
+                targetFile
+            }],
+        applySteps: [
+            { kind: fileStepKind, sourceFile, targetFile },
+            { kind: "textEdits" },
+            { kind: "assetImportEdits", sourceFile, targetFile },
+            { kind: "importCleanup" },
+            { kind: "postMutationCycles" }
+        ],
+        recoveryCheckpoints: ["provider-collected", "file-op-applied", "text-edits-applied", "asset-edits-applied", "cleanup-applied"]
+    };
+}
+function buildEstimate(groups) {
+    const rows = groups.flatMap((group) => group.rows);
+    const targetDirs = new Set(rows.map((row) => row.targetDir).filter((value) => Boolean(value)));
+    const fileRows = rows.filter((row) => row.domain === "file");
+    const fileGroups = groups.filter((group) => group.domain === "file");
+    const semanticGroups = groups.filter((group) => group.domain === "semantic" || group.domain === "modulePlan");
+    const semanticRenameRows = rows.filter((row) => row.domain === "semantic" && row.op === "rename");
+    const semanticMoveRows = rows.filter((row) => row.domain === "semantic" && row.op === "move");
+    const modulePlanRows = rows.filter((row) => row.domain === "modulePlan");
+    const semanticSelectedDurationMs = estimateSemanticScanDurationMs(semanticGroups);
+    return {
+        groupCount: groups.length,
+        rowCount: rows.length,
+        semanticRowCount: rows.filter((row) => row.domain === "semantic").length,
+        fileRowCount: fileRows.length,
+        modulePlanRowCount: rows.filter((row) => row.domain === "modulePlan").length,
+        fileOperationCount: fileRows.length,
+        semanticOperationCount: rows.filter((row) => row.domain === "semantic" || row.domain === "modulePlan" || row.domain === "declaration").length,
+        providerRequestCount: rows.reduce((count, row) => count + row.providerRequests.length, 0),
+        targetDirCount: targetDirs.size,
+        fileImportingFileCount: fileGroups.reduce((count, group) => count + (group.impact?.importingFileCount ?? 0), 0),
+        fileImportStatementCount: fileGroups.reduce((count, group) => count + (group.impact?.importStatementCount ?? 0), 0),
+        fileBarrelExportCount: fileGroups.reduce((count, group) => count + (group.impact?.barrelExportCount ?? 0), 0),
+        semanticImportingFileCount: semanticGroups.reduce((count, group) => count + (group.semanticImpact?.matchedFileCount ?? 0), 0),
+        semanticRgMatchedFileCount: semanticGroups.reduce((count, group) => count + (group.semanticImpact?.rgMatchedFileCount ?? 0), 0),
+        semanticImportStatementCount: semanticGroups.reduce((count, group) => count + (group.semanticImpact?.importStatementCount ?? 0), 0),
+        semanticMatchedNamedSpecifierCount: semanticGroups.reduce((count, group) => count + (group.semanticImpact?.matchedNamedSpecifierCount ?? 0), 0),
+        semanticScanDurationMs: semanticGroups.reduce((count, group) => count + (group.semanticImpact?.timings.totalMs ?? 0), 0),
+        semanticRenameRowCount: semanticRenameRows.length,
+        semanticMoveRowCount: semanticMoveRows.length,
+        modulePlanSymbolCount: modulePlanRows.length,
+        semanticSelectedDurationMs,
+        semanticEstimateSource: semanticSelectedDurationMs > 0 ? "scan" : "default",
+        fileDefaultDurationMs: fileGroups.reduce((count, group) => count + (group.eta?.defaultMs ?? 0), 0),
+        fileScanDurationMs: fileGroups.reduce((count, group) => count + (group.eta?.scanMs ?? 0), 0),
+        fileSelectedDurationMs: fileGroups.reduce((count, group) => count + (group.eta?.selectedMs ?? 0), 0),
+        postProcessPhaseCount: groups.filter((group) => group.phases.includes("postProcessImports")).length
+    };
+}
+function estimateSemanticScanDurationMs(groups) {
+    let total = 0;
+    for (const group of groups) {
+        const impact = group.semanticImpact;
+        if (!impact || impact.existingSourceFileCount <= 0 || impact.truncated) {
+            continue;
+        }
+        const rows = group.rows;
+        if (group.domain === "modulePlan") {
+            total += estimateSemanticMoveLikeMs({
+                rowCount: rows.length,
+                entityCount: rows.length,
+                matchedFileCount: impact.matchedFileCount,
+                importStatementCount: impact.importStatementCount,
+                matchedNamedSpecifierCount: impact.matchedNamedSpecifierCount,
+                noisyFileCount: Math.max(0, impact.rgMatchedFileCount - impact.matchedFileCount),
+                modulePlan: true
+            });
+            continue;
+        }
+        const renameRows = rows.filter((row) => row.op === "rename");
+        if (renameRows.length > 0) {
+            total += estimateSemanticRenameMs({
+                rowCount: renameRows.length,
+                entityCount: renameRows.length,
+                matchedFileCount: impact.matchedFileCount,
+                importStatementCount: impact.importStatementCount,
+                matchedNamedSpecifierCount: impact.matchedNamedSpecifierCount,
+                noisyFileCount: Math.max(0, impact.rgMatchedFileCount - impact.matchedFileCount)
+            });
+        }
+        const moveRows = rows.filter((row) => row.op === "move");
+        if (moveRows.length > 0) {
+            total += estimateSemanticMoveLikeMs({
+                rowCount: moveRows.length,
+                entityCount: moveRows.length,
+                matchedFileCount: impact.matchedFileCount,
+                importStatementCount: impact.importStatementCount,
+                matchedNamedSpecifierCount: impact.matchedNamedSpecifierCount,
+                noisyFileCount: Math.max(0, impact.rgMatchedFileCount - impact.matchedFileCount),
+                modulePlan: false
+            });
+        }
+    }
+    return total > 0 ? Math.round(total) : 0;
+}
+function estimateSemanticRenameMs(input) {
+    return clampMs(2_150 +
+        input.rowCount * 700 +
+        input.entityCount * 700 +
+        input.matchedFileCount * 3 +
+        input.importStatementCount * 1 +
+        input.matchedNamedSpecifierCount * 2 +
+        input.noisyFileCount * 0.5, 3_000, 60_000);
+}
+function estimateSemanticMoveLikeMs(input) {
+    if (input.modulePlan) {
+        return clampMs((5_000 +
+            Math.pow(Math.max(1, input.rowCount), 1.3) * 5_000 +
+            input.matchedFileCount * 220 +
+            input.importStatementCount * 50 +
+            input.matchedNamedSpecifierCount * 10 +
+            input.noisyFileCount * 24) * 1.07, 12_000, 300_000);
+    }
+    return clampMs((3_500 +
+        input.rowCount * 1_000 +
+        input.entityCount * 1_000 +
+        input.matchedFileCount * 280 +
+        input.importStatementCount * 15 +
+        input.matchedNamedSpecifierCount * 3 +
+        input.noisyFileCount * 30) * 1.03, 8_000, 180_000);
+}
+function clampMs(value, minMs, maxMs) {
+    return Math.min(maxMs, Math.max(minMs, Math.round(value)));
+}
+function readRenamePairs(value) {
+    if (Array.isArray(value)) {
+        return value
+            .filter(isObject)
+            .map((row) => ({ entity: readString(row.entity), newName: readString(row.newName) }))
+            .filter((row) => row.entity !== "" && row.newName !== "");
+    }
+    if (isObject(value)) {
+        return Object.entries(value)
+            .filter(([, newName]) => typeof newName === "string")
+            .map(([entity, newName]) => ({ entity, newName: String(newName) }));
+    }
+    return [];
+}
+function readModuleEntities(row) {
+    const entities = readStringArray(row.entities);
+    return entities.length > 0 ? entities : readStringArray(row.symbols);
+}
+function resolvePlanPath(cwd, filePath) {
+    if (!filePath) {
+        return "";
+    }
+    return path.normalize(path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath));
+}
+function readObjects(value) {
+    return Array.isArray(value) ? value.filter(isObject) : [];
+}
+function readStringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function readString(value) {
+    return typeof value === "string" ? value : "";
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/mutation/object-mutation-foundation.js

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

package/dist/mutation/object-mutation-partition.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planBestEffortObjectMutation = planBestEffortObjectMutation;
+function planBestEffortObjectMutation(rows, planStrict, options) {
+    const requested = normalizeRows(rows);
+    if (requested.reduce((sum, row) => sum + row.selectors.length, 0) <= 1) {
+        return planStrict(requested);
+    }
+    const fullPlan = planStrict(requested);
+    if (fullPlan.ok) {
+        return fullPlan;
+    }
+    const retained = [];
+    const notRun = [];
+    const memberSafeRows = [];
+    const memberSafePlans = [];
+    for (const row of requested) {
+        let remaining = [...row.selectors];
+        const rowIssues = [];
+        let safePlan = null;
+        let blocked = false;
+        while (remaining.length > 0) {
+            const probe = requested.length === 1 && remaining.length === row.selectors.length
+                ? fullPlan
+                : planStrict([{ objectName: row.objectName, selectors: remaining }]);
+            if (probe.ok) {
+                safePlan = probe;
+                break;
+            }
+            const wholeGroupIssues = probe.unsupported.filter(options.blocksWholeGroup);
+            const failedSelectors = [...new Set(probe.unsupported
+                    .map((issue) => issue.selector)
+                    .filter((selector) => typeof selector === "string" && remaining.includes(selector)))];
+            if (wholeGroupIssues.length > 0 || failedSelectors.length === 0) {
+                const issues = normalizeIssues(wholeGroupIssues.length > 0 ? wholeGroupIssues : probe.unsupported, row.objectName);
+                for (const selector of row.selectors) {
+                    retained.push({ status: "retained", objectName: row.objectName, selector, issues });
+                }
+                notRun.push({ status: "notRun", objectName: row.objectName, selectors: row.selectors, issues });
+                blocked = true;
+                break;
+            }
+            for (const selector of failedSelectors) {
+                const issues = normalizeIssues(probe.unsupported.filter((issue) => issue.selector === selector), row.objectName, selector);
+                rowIssues.push(...issues);
+                retained.push({ status: "retained", objectName: row.objectName, selector, issues });
+            }
+            remaining = remaining.filter((selector) => !failedSelectors.includes(selector));
+        }
+        if (blocked) {
+            continue;
+        }
+        if (!safePlan || remaining.length === 0) {
+            notRun.push({
+                status: "notRun",
+                objectName: row.objectName,
+                selectors: row.selectors,
+                issues: dedupeIssues(rowIssues)
+            });
+            continue;
+        }
+        memberSafeRows.push({ objectName: row.objectName, selectors: remaining });
+        memberSafePlans.push(safePlan);
+    }
+    if (memberSafeRows.length === 0) {
+        return planStrict(requested);
+    }
+    const acceptedRows = [];
+    let acceptedPlan = null;
+    for (const [index, row] of memberSafeRows.entries()) {
+        const candidateRows = [...acceptedRows, row];
+        const candidate = acceptedRows.length === 0 ? memberSafePlans[index] : planStrict(candidateRows);
+        if (candidate.ok) {
+            acceptedRows.push(row);
+            acceptedPlan = candidate;
+            continue;
+        }
+        const issues = normalizeIssues(candidate.unsupported, row.objectName);
+        for (const selector of row.selectors) {
+            retained.push({ status: "retained", objectName: row.objectName, selector, issues });
+        }
+        notRun.push({ status: "notRun", objectName: row.objectName, selectors: row.selectors, issues });
+    }
+    if (!acceptedPlan || acceptedRows.length === 0) {
+        return planStrict(requested);
+    }
+    const retainedMembers = dedupeRetained(retained).filter((item) => !acceptedRows.some((row) => row.objectName === item.objectName && row.selectors.includes(item.selector)));
+    if (retainedMembers.length === 0) {
+        return acceptedPlan;
+    }
+    const requestedMemberCount = requested.reduce((sum, row) => sum + row.selectors.length, 0);
+    return Object.assign(acceptedPlan, {
+        partial: true,
+        requestedObjectCount: requested.length,
+        requestedMemberCount,
+        retainedCount: retainedMembers.length,
+        retained: retainedMembers,
+        notRun: dedupeNotRun(notRun)
+    });
+}
+function normalizeRows(rows) {
+    return rows.map((row) => ({
+        objectName: row.objectName,
+        selectors: [...new Set(row.selectors)].sort()
+    })).sort((left, right) => left.objectName.localeCompare(right.objectName));
+}
+function normalizeIssues(issues, objectName, selector) {
+    return dedupeIssues(issues.map((issue) => ({
+        ...issue,
+        objectName: issue.objectName ?? objectName,
+        ...(selector && !issue.selector ? { selector } : {})
+    })));
+}
+function dedupeIssues(issues) {
+    const byKey = new Map();
+    for (const issue of issues) {
+        const key = stableStringify(issue);
+        byKey.set(key, issue);
+    }
+    return [...byKey.values()].sort((left, right) => left.code.localeCompare(right.code) || (left.file ?? "").localeCompare(right.file ?? "") ||
+        (left.selector ?? "").localeCompare(right.selector ?? ""));
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(",")}]`;
+    }
+    return `{${Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
+        .join(",")}}`;
+}
+function dedupeRetained(items) {
+    const byKey = new Map();
+    for (const item of items) {
+        byKey.set(`${item.objectName}\0${item.selector}`, item);
+    }
+    return [...byKey.values()].sort((left, right) => left.objectName.localeCompare(right.objectName) || left.selector.localeCompare(right.selector));
+}
+function dedupeNotRun(items) {
+    const byKey = new Map();
+    for (const item of items) {
+        byKey.set(`${item.objectName}\0${item.selectors.join("\0")}`, item);
+    }
+    return [...byKey.values()].sort((left, right) => left.objectName.localeCompare(right.objectName));
+}