@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/mutation/semantic-rename-transaction.js

@@ -0,0 +1,333 @@
+"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.applyStandaloneSemanticRenameTransaction = applyStandaloneSemanticRenameTransaction;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const file_text_edit_executor_1 = require("../commands/file-text-edit-executor");
+const file_mutation_discovery_1 = require("./file-mutation-discovery");
+const semantic_rename_locations_1 = require("./semantic-rename-locations");
+const targeted_import_canonicalizer_1 = require("./targeted-import-canonicalizer");
+const defaultDependencies = {
+    fs,
+    computeWorkspaceFingerprint: file_mutation_discovery_1.computeFileMutationWorkspaceFingerprint
+};
+function applyStandaloneSemanticRenameTransaction(input, dependencies = defaultDependencies) {
+    const root = path.resolve(input.workspaceRoot);
+    const validation = validatePlan(root, input.plan);
+    if (!validation.ok)
+        return failure(validation.code, validation.error);
+    let prepared;
+    try {
+        const realRoot = dependencies.fs.realpathSync(root);
+        assertWorkspaceFingerprint(root, input.plan, input.computeWorkspaceFingerprint ?? dependencies.computeWorkspaceFingerprint, "SEMANTIC_RENAME_COMMIT_PREFLIGHT_STALE");
+        prepared = input.plan.edits.map((edit) => prepareFile(root, realRoot, edit, dependencies.fs));
+    }
+    catch (error) {
+        return failure(errorCode(error, "SEMANTIC_RENAME_COMMIT_PREFLIGHT_FAILED"), errorMessage(error));
+    }
+    const attempted = [];
+    try {
+        for (const item of prepared) {
+            item.descriptor = dependencies.fs.openSync(item.file, "r+");
+            assertDescriptorSnapshot(item, dependencies.fs, item.originalBytes, "File changed while acquiring transaction ownership.");
+            assertOwnedPath(item, dependencies.fs, item.originalBytes, "File path changed while acquiring transaction ownership.");
+        }
+        dependencies.onPhase?.("beforeFinalPreflight", null, -1);
+        dependencies.checkInterrupted?.();
+        assertWorkspaceFingerprint(root, input.plan, input.computeWorkspaceFingerprint ?? dependencies.computeWorkspaceFingerprint, "SEMANTIC_RENAME_COMMIT_PREFLIGHT_STALE");
+        for (const item of prepared) {
+            assertDescriptorSnapshot(item, dependencies.fs, item.originalBytes, "File changed at the final transaction boundary.");
+            assertOwnedPath(item, dependencies.fs, item.originalBytes, "File path changed at the final transaction boundary.");
+        }
+        input.beforeApply?.(prepared.map((item) => item.file));
+        for (const [index, item] of prepared.entries()) {
+            dependencies.onPhase?.("beforeWrite", item.file, index);
+            dependencies.checkInterrupted?.();
+            assertDescriptorSnapshot(item, dependencies.fs, item.originalBytes, "File changed before its transaction write.");
+            assertOwnedPath(item, dependencies.fs, item.originalBytes, "File path changed before its transaction write.");
+            attempted.push(item);
+            writeExact(item, item.finalBytes, dependencies.fs);
+            dependencies.onPhase?.("afterWrite", item.file, index);
+        }
+        dependencies.onPhase?.("beforeFinalVerify", null, prepared.length);
+        dependencies.checkInterrupted?.();
+        for (const item of prepared) {
+            assertDescriptorSnapshot(item, dependencies.fs, item.finalBytes, "Written file changed before transaction commit.");
+            assertOwnedPath(item, dependencies.fs, item.finalBytes, "Written path was replaced before transaction commit.");
+        }
+    }
+    catch (error) {
+        const result = rollback(error, attempted, prepared, dependencies);
+        closeAll(prepared, dependencies.fs);
+        return result;
+    }
+    closeAll(prepared, dependencies.fs);
+    return {
+        ok: true,
+        savedFiles: prepared.map((item) => item.file),
+        touchedFiles: prepared.map((item) => item.file),
+        editCount: input.plan.edits.reduce((sum, edit) => sum + edit.textChanges.length, 0)
+    };
+}
+function validatePlan(root, plan) {
+    if (!plan.complete) {
+        return { ok: false, code: plan.code, error: plan.error ?? "Standalone semantic rename plan is incomplete." };
+    }
+    if (!samePath(root, plan.workspaceRoot) || !plan.discovery.workspaceFingerprint) {
+        return { ok: false, code: "SEMANTIC_RENAME_PLAN_IDENTITY_INVALID", error: "Planner workspace identity is missing or mismatched." };
+    }
+    if (plan.intents.length === 0 || plan.edits.length === 0 || plan.intents.some((intent) => intent.locations.length === 0)) {
+        return { ok: false, code: "SEMANTIC_RENAME_PLAN_EMPTY", error: "Every rename intent must publish at least one edit location." };
+    }
+    const authorizedLocations = new Map();
+    for (const intent of plan.intents) {
+        for (const location of intent.locations) {
+            const file = path.resolve(location.fileName);
+            if (!isInside(root, file) || location.start < 0 || location.length <= 0) {
+                return { ok: false, code: "SEMANTIC_RENAME_EDIT_OUTSIDE_WORKSPACE", error: `Invalid planned location: ${location.fileName}.` };
+            }
+            const key = spanKey(file, location.start, location.length);
+            if (authorizedLocations.has(key)) {
+                return { ok: false, code: "SEMANTIC_RENAME_EDIT_DUPLICATE", error: `Duplicate planned location: ${key}.` };
+            }
+            authorizedLocations.set(key, {
+                oldName: intent.oldName,
+                replacement: (0, semantic_rename_locations_1.semanticRenameReplacement)(location, intent.newName)
+            });
+        }
+    }
+    const files = new Set();
+    const editSpans = new Set();
+    for (const edit of plan.edits) {
+        const file = path.resolve(edit.fileName);
+        const fileKey = pathKey(file);
+        if (!isInside(root, file)) {
+            return { ok: false, code: "SEMANTIC_RENAME_EDIT_OUTSIDE_WORKSPACE", error: `Edit is outside the workspace: ${edit.fileName}.` };
+        }
+        if (files.has(fileKey)) {
+            return { ok: false, code: "SEMANTIC_RENAME_EDIT_DUPLICATE", error: `Duplicate file edit: ${edit.fileName}.` };
+        }
+        files.add(fileKey);
+        const ordered = [...edit.textChanges].sort((left, right) => left.span.start - right.span.start);
+        if (ordered.length === 0) {
+            return { ok: false, code: "SEMANTIC_RENAME_EDIT_EMPTY", error: `Edit has no text changes: ${edit.fileName}.` };
+        }
+        for (const [index, change] of ordered.entries()) {
+            if (change.span.start < 0 || change.span.length <= 0 || change.span.start + change.span.length > edit.expectedText.length ||
+                (index > 0 && ordered[index - 1].span.start + ordered[index - 1].span.length > change.span.start)) {
+                return { ok: false, code: "SEMANTIC_RENAME_EDIT_OVERLAP", error: `Invalid or overlapping edit in ${edit.fileName}.` };
+            }
+            const key = spanKey(file, change.span.start, change.span.length);
+            const authorized = authorizedLocations.get(key);
+            if (!authorized || editSpans.has(key)) {
+                return { ok: false, code: "SEMANTIC_RENAME_EDIT_UNEXPECTED", error: `Edit span is not authorized by the planner: ${key}.` };
+            }
+            if (edit.expectedText.slice(change.span.start, change.span.start + change.span.length) !== authorized.oldName ||
+                change.newText !== authorized.replacement) {
+                return {
+                    ok: false,
+                    code: "SEMANTIC_RENAME_EDIT_PAYLOAD_MISMATCH",
+                    error: `Edit payload does not match the exact rename intent at ${key}.`
+                };
+            }
+            editSpans.add(key);
+        }
+    }
+    if (editSpans.size !== authorizedLocations.size) {
+        return { ok: false, code: "SEMANTIC_RENAME_EDIT_MISSING", error: "Not every planned rename location has one exact text edit." };
+    }
+    return { ok: true };
+}
+function prepareFile(root, realRoot, edit, fsAdapter) {
+    const file = path.resolve(edit.fileName);
+    if (!isInside(root, file))
+        throw typed("SEMANTIC_RENAME_EDIT_OUTSIDE_WORKSPACE", `Edit is outside the workspace: ${file}.`);
+    const realFile = fsAdapter.realpathSync(file);
+    if (!isInside(realRoot, realFile)) {
+        throw typed("SEMANTIC_RENAME_EDIT_OUTSIDE_WORKSPACE", `Edit resolves outside the real workspace root: ${file}.`);
+    }
+    const stat = fsAdapter.statSync(file);
+    const identity = readIdentity(file, stat);
+    const mode = stat.mode & 0o7777;
+    const originalBytes = fsAdapter.readFileSync(file);
+    if (sha256(originalBytes) !== edit.expectedHash || originalBytes.toString("utf8") !== edit.expectedText ||
+        !Buffer.from(edit.expectedText, "utf8").equals(originalBytes)) {
+        throw typed("SEMANTIC_RENAME_EDIT_SNAPSHOT_CHANGED", `Exact planned bytes changed or are not canonical UTF-8: ${file}.`);
+    }
+    const renamedText = (0, file_text_edit_executor_1.applyTextChanges)(edit.expectedText, edit.textChanges);
+    const finalText = (0, targeted_import_canonicalizer_1.formatChangedNamedImports)(edit.expectedText, renamedText, file).text;
+    const finalBytes = Buffer.from(finalText, "utf8");
+    if (finalBytes.equals(originalBytes))
+        throw typed("SEMANTIC_RENAME_EDIT_NOOP", `Rename edit does not change ${file}.`);
+    return { file, originalBytes, finalBytes, identity, mode, realFile, realRoot, workspaceRoot: root, descriptor: null };
+}
+function rollback(cause, attempted, all, dependencies) {
+    if (attempted.length === 0) {
+        return failure(errorCode(cause, "SEMANTIC_RENAME_TRANSACTION_FAILED"), errorMessage(cause));
+    }
+    const potentiallyModified = new Map(attempted.map((item) => [pathKey(item.file), item.file]));
+    const rollbackErrors = [];
+    for (const [reverseIndex, item] of [...attempted].reverse().entries()) {
+        try {
+            dependencies.onPhase?.("beforeRollback", item.file, reverseIndex);
+            writeExact(item, item.originalBytes, dependencies.fs);
+            assertDescriptorSnapshot(item, dependencies.fs, item.originalBytes, "Rollback bytes or mode do not match the original snapshot.");
+            assertOwnedPath(item, dependencies.fs, item.originalBytes, "Rollback refused a foreign or replaced path.");
+            potentiallyModified.delete(pathKey(item.file));
+        }
+        catch (error) {
+            rollbackErrors.push(`${item.file}: ${errorMessage(error)}`);
+        }
+    }
+    const residual = [...potentiallyModified.values()].sort();
+    return {
+        ok: false,
+        code: rollbackErrors.length === 0 ? "SEMANTIC_RENAME_TRANSACTION_FAILED" : "SEMANTIC_RENAME_ROLLBACK_FAILED",
+        error: rollbackErrors.length === 0
+            ? errorMessage(cause)
+            : `${errorMessage(cause)} Rollback failed: ${rollbackErrors.join("; ")}`,
+        rollback: rollbackErrors.length === 0 ? "ok" : "failed",
+        potentiallyModifiedFiles: residual,
+        ...(rollbackErrors.length > 0 ? { rollbackErrors } : {})
+    };
+}
+function writeExact(item, bytes, fsAdapter) {
+    const descriptor = requireDescriptor(item);
+    fsAdapter.ftruncateSync(descriptor, 0);
+    let offset = 0;
+    while (offset < bytes.length) {
+        const written = fsAdapter.writeSync(descriptor, bytes, offset, bytes.length - offset, offset);
+        if (written <= 0)
+            throw new Error(`Descriptor write made no progress for ${item.file}.`);
+        offset += written;
+    }
+    fsAdapter.fchmodSync(descriptor, item.mode);
+    fsAdapter.fsyncSync(descriptor);
+    assertDescriptorSnapshot(item, fsAdapter, bytes, "Descriptor bytes or mode do not match the requested transaction state.");
+}
+function assertDescriptorSnapshot(item, fsAdapter, expectedBytes, error) {
+    const descriptor = requireDescriptor(item);
+    const stat = fsAdapter.fstatSync(descriptor);
+    if (!sameIdentity(item.identity, readIdentity(item.file, stat)) || (stat.mode & 0o7777) !== item.mode ||
+        !readDescriptor(descriptor, stat.size, fsAdapter).equals(expectedBytes))
+        throw new Error(error);
+}
+function assertOwnedPath(item, fsAdapter, expectedBytes, error) {
+    const currentRoot = fsAdapter.realpathSync(item.workspaceRoot);
+    const currentFile = fsAdapter.realpathSync(item.file);
+    if (!samePath(currentRoot, item.realRoot) || !samePath(currentFile, item.realFile) || !isInside(currentRoot, currentFile)) {
+        throw new Error(error);
+    }
+    const before = fsAdapter.statSync(item.file);
+    if (!sameIdentity(item.identity, readIdentity(item.file, before)) || (before.mode & 0o7777) !== item.mode)
+        throw new Error(error);
+    const bytes = fsAdapter.readFileSync(item.file);
+    const after = fsAdapter.statSync(item.file);
+    if (!sameIdentity(item.identity, readIdentity(item.file, after)) || (after.mode & 0o7777) !== item.mode || !bytes.equals(expectedBytes)) {
+        throw new Error(error);
+    }
+}
+function assertWorkspaceFingerprint(root, plan, computeWorkspaceFingerprint, code) {
+    if (computeWorkspaceFingerprint(root) !== plan.discovery.workspaceFingerprint) {
+        throw typed(code, "Workspace files, configs, or package metadata changed before semantic rename apply.");
+    }
+}
+function readDescriptor(descriptor, size, fsAdapter) {
+    const result = Buffer.alloc(size);
+    let offset = 0;
+    while (offset < size) {
+        const read = fsAdapter.readSync(descriptor, result, offset, size - offset, offset);
+        if (read <= 0)
+            throw new Error("Descriptor read ended before the expected file size.");
+        offset += read;
+    }
+    return result;
+}
+function closeAll(files, fsAdapter) {
+    for (const item of files) {
+        if (item.descriptor === null)
+            continue;
+        try {
+            fsAdapter.closeSync(item.descriptor);
+        }
+        catch { /* content ownership was verified before close */ }
+        item.descriptor = null;
+    }
+}
+function readIdentity(file, stat) {
+    if (!stat.isFile() || !Number.isFinite(stat.dev) || !Number.isFinite(stat.ino) || stat.ino === 0) {
+        throw new Error(`Stable regular-file identity is unavailable for ${file}.`);
+    }
+    return { dev: stat.dev, ino: stat.ino };
+}
+function requireDescriptor(item) {
+    if (item.descriptor === null)
+        throw new Error(`Transaction descriptor is unavailable for ${item.file}.`);
+    return item.descriptor;
+}
+function isInside(root, file) {
+    const relative = path.relative(root, file);
+    return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function samePath(left, right) {
+    return pathKey(left) === pathKey(right);
+}
+function pathKey(file) {
+    const normalized = path.resolve(file);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function spanKey(file, start, length) {
+    return `${pathKey(file)}:${start}:${length}`;
+}
+function sameIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+function sha256(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}
+function typed(code, message) {
+    return Object.assign(new Error(message), { code });
+}
+function errorCode(error, fallback) {
+    return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : fallback;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function failure(code, error) {
+    return { ok: false, code, error, rollback: "not-needed", potentiallyModifiedFiles: [] };
+}

package/dist/mutation/semantic-unused-import-cleanup.js

@@ -0,0 +1,248 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSemanticUnusedImportCleanup = runSemanticUnusedImportCleanup;
+const path = __importStar(require("node:path"));
+const node_perf_hooks_1 = require("node:perf_hooks");
+const typescript_1 = __importDefault(require("typescript"));
+const targeted_import_canonicalizer_1 = require("./targeted-import-canonicalizer");
+function runSemanticUnusedImportCleanup(input) {
+    const metrics = {
+        scanMs: 0,
+        refreshMs: 0,
+        oracleMs: 0,
+        renderMs: 0,
+        candidateFiles: 0,
+        candidateBindings: 0,
+        oracleFiles: 0,
+        removedBindings: 0
+    };
+    const scanStartedAt = node_perf_hooks_1.performance.now();
+    const candidates = new Map();
+    for (const snapshot of input.snapshots) {
+        if (!snapshot.cleanup)
+            continue;
+        const fileCandidates = collectCandidateKeys(snapshot.fileName, snapshot.text);
+        if (fileCandidates.size === 0)
+            continue;
+        candidates.set(pathKey(snapshot.fileName), fileCandidates);
+        metrics.candidateFiles += 1;
+        metrics.candidateBindings += fileCandidates.size;
+    }
+    metrics.scanMs = node_perf_hooks_1.performance.now() - scanStartedAt;
+    if (candidates.size === 0) {
+        return { texts: new Map(), metrics };
+    }
+    const refreshStartedAt = node_perf_hooks_1.performance.now();
+    input.updateSnapshots(input.snapshots);
+    if (!input.languageService.getProgram()) {
+        throw new Error("TypeScript LanguageService did not refresh the semantic cleanup Program.");
+    }
+    metrics.refreshMs = node_perf_hooks_1.performance.now() - refreshStartedAt;
+    const texts = new Map();
+    for (const snapshot of input.snapshots) {
+        const fileCandidates = candidates.get(pathKey(snapshot.fileName));
+        if (!fileCandidates)
+            continue;
+        const oracleStartedAt = node_perf_hooks_1.performance.now();
+        const organizedEdits = input.languageService.organizeImports({ type: "file", fileName: snapshot.fileName, skipDestructiveCodeActions: false }, input.formatOptions, input.preferences);
+        metrics.oracleMs += node_perf_hooks_1.performance.now() - oracleStartedAt;
+        metrics.oracleFiles += 1;
+        const organized = organizedEdits.find((edit) => pathKey(edit.fileName) === pathKey(snapshot.fileName));
+        const organizedText = organized ? applyTextChanges(snapshot.text, organized.textChanges) : snapshot.text;
+        const remaining = new Set(readImportBindings(snapshot.fileName, organizedText).map((binding) => binding.key));
+        const confirmed = new Set([...fileCandidates].filter((key) => !remaining.has(key)));
+        if (confirmed.size === 0)
+            continue;
+        const renderStartedAt = node_perf_hooks_1.performance.now();
+        const cleaned = removeConfirmedBindings(snapshot.fileName, snapshot.text, confirmed);
+        metrics.renderMs += node_perf_hooks_1.performance.now() - renderStartedAt;
+        if (cleaned !== snapshot.text) {
+            texts.set(pathKey(snapshot.fileName), cleaned);
+            metrics.removedBindings += confirmed.size;
+        }
+    }
+    return { texts, metrics };
+}
+function collectCandidateKeys(fileName, text) {
+    const source = createSourceFile(fileName, text);
+    const referenced = new Set();
+    const visit = (node) => {
+        if (typescript_1.default.isImportDeclaration(node))
+            return;
+        if (typescript_1.default.isIdentifier(node))
+            referenced.add(node.text);
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    return new Set(readImportBindingsFromSource(source, text)
+        .filter((binding) => !referenced.has(binding.localName))
+        .map((binding) => binding.key));
+}
+function readImportBindings(fileName, text) {
+    return readImportBindingsFromSource(createSourceFile(fileName, text), text);
+}
+function readImportBindingsFromSource(source, text) {
+    const bindings = [];
+    for (const statement of source.statements) {
+        if (!typescript_1.default.isImportDeclaration(statement) || !statement.importClause ||
+            !typescript_1.default.isStringLiteralLike(statement.moduleSpecifier) || hasSensitiveComment(statement, source, text)) {
+            continue;
+        }
+        const clause = statement.importClause;
+        const specifier = statement.moduleSpecifier.text;
+        if (clause.name) {
+            bindings.push({ key: bindingKey(specifier, "default", "default", clause.name.text), localName: clause.name.text });
+        }
+        const named = clause.namedBindings;
+        if (named && typescript_1.default.isNamespaceImport(named)) {
+            bindings.push({ key: bindingKey(specifier, "namespace", "*", named.name.text), localName: named.name.text });
+        }
+        else if (named) {
+            for (const element of named.elements) {
+                const importedName = element.propertyName?.text ?? element.name.text;
+                bindings.push({
+                    key: bindingKey(specifier, "named", importedName, element.name.text),
+                    localName: element.name.text
+                });
+            }
+        }
+    }
+    return bindings;
+}
+function removeConfirmedBindings(fileName, text, confirmed) {
+    const source = createSourceFile(fileName, text);
+    const replacements = [];
+    for (const statement of source.statements) {
+        if (!typescript_1.default.isImportDeclaration(statement) || !statement.importClause ||
+            !typescript_1.default.isStringLiteralLike(statement.moduleSpecifier) || hasSensitiveComment(statement, source, text)) {
+            continue;
+        }
+        const clause = statement.importClause;
+        const specifier = statement.moduleSpecifier.text;
+        const keepDefault = clause.name && !confirmed.has(bindingKey(specifier, "default", "default", clause.name.text))
+            ? clause.name.text
+            : null;
+        const named = clause.namedBindings;
+        const keepNamespace = named && typescript_1.default.isNamespaceImport(named) &&
+            !confirmed.has(bindingKey(specifier, "namespace", "*", named.name.text))
+            ? named.name.text
+            : null;
+        const keepNamed = named && typescript_1.default.isNamedImports(named)
+            ? named.elements.filter((element) => !confirmed.has(bindingKey(specifier, "named", element.propertyName?.text ?? element.name.text, element.name.text)))
+            : [];
+        const originalBindingCount = Number(Boolean(clause.name)) +
+            Number(Boolean(named && typescript_1.default.isNamespaceImport(named))) +
+            (named && typescript_1.default.isNamedImports(named) ? named.elements.length : 0);
+        const keptBindingCount = Number(Boolean(keepDefault)) + Number(Boolean(keepNamespace)) + keepNamed.length;
+        if (keptBindingCount === originalBindingCount)
+            continue;
+        if (keptBindingCount === 0) {
+            replacements.push({
+                start: statement.getStart(source),
+                end: includeTrailingBreak(text, statement.getEnd()),
+                text: ""
+            });
+            continue;
+        }
+        let replacement;
+        if (named && typescript_1.default.isNamedImports(named) && keepNamed.length > 0) {
+            const elements = keepNamed.map((element) => ({
+                text: element.getText(source).replace(/^type\s+/, ""),
+                isTypeOnly: clause.isTypeOnly || element.isTypeOnly
+            }));
+            replacement = (0, targeted_import_canonicalizer_1.renderTargetedNamedImportLike)({
+                sourceText: text,
+                sourceFile: source,
+                statement,
+                elements,
+                specifier,
+                clauseTypeOnly: clause.isTypeOnly,
+                defaultBinding: keepDefault
+            });
+        }
+        else {
+            const keyword = clause.isTypeOnly ? "import type" : "import";
+            const parts = [keepDefault, keepNamespace ? `* as ${keepNamespace}` : null]
+                .filter((item) => Boolean(item));
+            const moduleText = text.slice(statement.moduleSpecifier.getStart(source), statement.moduleSpecifier.getEnd());
+            const suffix = text.slice(statement.moduleSpecifier.getEnd(), statement.getEnd());
+            replacement = `${keyword} ${parts.join(", ")} from ${moduleText}${suffix}`;
+        }
+        replacements.push({ start: statement.getStart(source), end: statement.getEnd(), text: replacement });
+    }
+    let output = text;
+    for (const replacement of replacements.sort((left, right) => right.start - left.start)) {
+        output = `${output.slice(0, replacement.start)}${replacement.text}${output.slice(replacement.end)}`;
+    }
+    return output;
+}
+function applyTextChanges(text, changes) {
+    let output = text;
+    for (const change of [...changes].sort((left, right) => right.span.start - left.span.start)) {
+        output = `${output.slice(0, change.span.start)}${change.newText}${output.slice(change.span.start + change.span.length)}`;
+    }
+    return output;
+}
+function bindingKey(specifier, kind, importedName, localName) {
+    return `${specifier}\0${kind}\0${importedName}\0${localName}`;
+}
+function hasSensitiveComment(statement, source, text) {
+    const newline = text.indexOf("\n", statement.getEnd());
+    const statementText = text.slice(statement.getStart(source), newline < 0 ? text.length : newline);
+    return /\/\*|\/\//.test(statementText);
+}
+function includeTrailingBreak(text, offset) {
+    if (text.startsWith("\r\n", offset))
+        return offset + 2;
+    if (text[offset] === "\n" || text[offset] === "\r")
+        return offset + 1;
+    return offset;
+}
+function createSourceFile(fileName, text) {
+    const extension = fileName.toLowerCase();
+    const kind = extension.endsWith(".tsx") ? typescript_1.default.ScriptKind.TSX
+        : extension.endsWith(".jsx") || extension.endsWith(".js") || extension.endsWith(".mjs") || extension.endsWith(".cjs")
+            ? typescript_1.default.ScriptKind.JS
+            : typescript_1.default.ScriptKind.TS;
+    return typescript_1.default.createSourceFile(fileName, text, typescript_1.default.ScriptTarget.Latest, true, kind);
+}
+function pathKey(fileName) {
+    const normalized = path.normalize(fileName);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}

package/dist/mutation/semantic-worker-retry.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEMANTIC_WORKER_RETRY_TESTING = void 0;
+exports.runSemanticWorkerWithRetry = runSemanticWorkerWithRetry;
+exports.isRetryableSemanticWorkerFailure = isRetryableSemanticWorkerFailure;
+const RETRYABLE_WORKER_FAILURE_SUFFIXES = [
+    "_WORKER_CRASHED",
+    "_WORKER_START_FAILED",
+    "_WORKER_DEADLINE"
+];
+const DEFAULT_MAX_ATTEMPTS = 2;
+async function runSemanticWorkerWithRetry(runAttempt, options = {}) {
+    const maxAttempts = Math.max(1, Math.floor(options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS));
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            return await runAttempt(attempt);
+        }
+        catch (error) {
+            lastError = error;
+            const code = readErrorCode(error);
+            options.onFailure?.({ attempt, code });
+            if (attempt >= maxAttempts || !isRetryableSemanticWorkerFailure(code))
+                throw error;
+        }
+    }
+    throw lastError;
+}
+function isRetryableSemanticWorkerFailure(code) {
+    return RETRYABLE_WORKER_FAILURE_SUFFIXES.some((suffix) => code.endsWith(suffix));
+}
+function readErrorCode(error) {
+    if (error instanceof Error && typeof error.code === "string") {
+        return error.code;
+    }
+    return "SEMANTIC_WORKER_FAILED";
+}
+exports.SEMANTIC_WORKER_RETRY_TESTING = {
+    defaultMaxAttempts: DEFAULT_MAX_ATTEMPTS
+};