@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/mutation/semantic-move-policy.js

@@ -0,0 +1,360 @@
+"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.SEMANTIC_MOVE_POLICY_TESTING = void 0;
+exports.semanticMovePreferences = semanticMovePreferences;
+exports.findDetachedTopFileHeader = findDetachedTopFileHeader;
+exports.applySemanticMoveImportPolicies = applySemanticMoveImportPolicies;
+const node_module_1 = require("node:module");
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const import_rules_1 = require("../config/import-rules");
+const typescript_preferences_1 = require("../config/typescript-preferences");
+const import_specifier_policy_1 = require("../commands/import-specifier-policy");
+const targeted_import_canonicalizer_1 = require("./targeted-import-canonicalizer");
+const BUILTIN_MODULES = new Set([
+    ...node_module_1.builtinModules,
+    ...node_module_1.builtinModules.map((item) => item.startsWith("node:") ? item.slice("node:".length) : `node:${item}`)
+]);
+function semanticMovePreferences(targetFile, importRules, overrides, workspacePreferences) {
+    const rule = resolveEffectiveImportRule(targetFile, path.dirname(targetFile), importRules, workspacePreferences);
+    return {
+        quotePreference: "auto",
+        ...(overrides ?? {}),
+        ...(rule?.specifier ? { importModuleSpecifierPreference: rule.specifier } : {}),
+        ...(rule?.ending ? { importModuleSpecifierEnding: rule.ending } : {})
+    };
+}
+function findDetachedTopFileHeader(file, text, firstMovedName) {
+    const source = createSourceFile(file, text);
+    const firstStatement = source.statements[0];
+    if (!firstStatement || firstStatementName(firstStatement) !== firstMovedName)
+        return null;
+    const end = firstStatement.getStart(source);
+    if (end <= 0)
+        return null;
+    const headerText = text.slice(0, end);
+    if (!/\/\//.test(headerText) && !/\/\*/.test(headerText))
+        return null;
+    if (!/\r?\n[ \t]*\r?\n[ \t]*$/.test(headerText))
+        return null;
+    return { start: 0, end, text: headerText };
+}
+function applySemanticMoveImportPolicies(input) {
+    const tsConfigCache = new Map();
+    return input.edits.map((edit) => {
+        const rendered = applyTextChanges(edit.expectedText, edit.textChanges);
+        const rule = resolveEffectiveImportRule(edit.fileName, input.workspaceRoot, input.importRules, input.workspacePreferences);
+        let nextText = normalizeDeltaImportSpecifiers({
+            workspaceRoot: input.workspaceRoot,
+            file: edit.fileName,
+            beforeText: edit.expectedText,
+            text: rendered,
+            rule,
+            tsConfigCache,
+            ...(input.acceptsModuleSpecifier ? { acceptsModuleSpecifier: input.acceptsModuleSpecifier } : {}),
+            ...(input.resolveVirtualModuleTarget ? { resolveVirtualModuleTarget: input.resolveVirtualModuleTarget } : {})
+        });
+        nextText = removeSemanticMoveSelfImports({
+            workspaceRoot: input.workspaceRoot,
+            file: edit.fileName,
+            text: nextText,
+            tsConfigCache
+        });
+        nextText = (0, targeted_import_canonicalizer_1.formatChangedNamedImports)(edit.expectedText, nextText, edit.fileName).text;
+        nextText = normalizeDeltaNamedImportTypes(edit.expectedText, nextText, edit.fileName);
+        if (nextText === rendered)
+            return edit;
+        return {
+            ...edit,
+            textChanges: [{ span: { start: 0, length: edit.expectedText.length }, newText: nextText }]
+        };
+    });
+}
+function normalizeDeltaNamedImportTypes(beforeText, text, file) {
+    const before = createSourceFile(file, beforeText);
+    const source = createSourceFile(file, text);
+    const beforeNames = new Map();
+    for (const statement of before.statements) {
+        if (!typescript_1.default.isImportDeclaration(statement) || !typescript_1.default.isStringLiteralLike(statement.moduleSpecifier))
+            continue;
+        const names = beforeNames.get(statement.moduleSpecifier.text) ?? new Set();
+        for (const name of importLocalNames(statement))
+            names.add(name);
+        beforeNames.set(statement.moduleSpecifier.text, names);
+    }
+    const replacements = [];
+    for (const statement of source.statements) {
+        if (!typescript_1.default.isImportDeclaration(statement) || !typescript_1.default.isStringLiteralLike(statement.moduleSpecifier))
+            continue;
+        const clause = statement.importClause;
+        const bindings = clause?.namedBindings;
+        if (!clause || !bindings || !typescript_1.default.isNamedImports(bindings))
+            continue;
+        const previousNames = beforeNames.get(statement.moduleSpecifier.text) ?? new Set();
+        if (!bindings.elements.some((element) => !previousNames.has(element.name.text)))
+            continue;
+        const elements = bindings.elements.map((element) => ({
+            text: element.getText(source).replace(/^type\s+/, ""),
+            isTypeOnly: clause.isTypeOnly || element.isTypeOnly || (!previousNames.has(element.name.text) && isUsedOnlyInTypePositions(source, element.name.text))
+        })).sort((left, right) => Number(left.isTypeOnly) - Number(right.isTypeOnly));
+        const replacement = (0, targeted_import_canonicalizer_1.renderTargetedNamedImportLike)({
+            sourceText: text,
+            sourceFile: source,
+            statement,
+            elements,
+            specifier: statement.moduleSpecifier.text,
+            clauseTypeOnly: elements.every((element) => element.isTypeOnly)
+        });
+        if (replacement !== text.slice(statement.getStart(source), statement.getEnd())) {
+            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 isUsedOnlyInTypePositions(source, name) {
+    const uses = [];
+    const visit = (node) => {
+        if (typescript_1.default.isImportDeclaration(node))
+            return;
+        if (typescript_1.default.isIdentifier(node) && node.text === name)
+            uses.push(node);
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    return uses.length > 0 && uses.every((identifier) => typescript_1.default.isPartOfTypeNode(identifier));
+}
+function removeSemanticMoveSelfImports(input) {
+    const source = createSourceFile(input.file, input.text);
+    const config = (0, import_specifier_policy_1.readNearestTsConfig)(input.file, input.workspaceRoot, input.tsConfigCache);
+    const changes = [];
+    for (const statement of source.statements) {
+        if (!typescript_1.default.isImportDeclaration(statement) || !typescript_1.default.isStringLiteralLike(statement.moduleSpecifier))
+            continue;
+        const resolved = (0, import_specifier_policy_1.resolveImportSpecifier)(input.file, statement.moduleSpecifier.text, config);
+        if (!resolved || !samePath(resolved, input.file))
+            continue;
+        const line = source.getLineAndCharacterOfPosition(statement.getStart(source)).line;
+        const start = source.getPositionOfLineAndCharacter(line, 0);
+        let end = statement.getEnd();
+        if (input.text.startsWith("\r\n", end))
+            end += 2;
+        else if (input.text[end] === "\n" || input.text[end] === "\r")
+            end += 1;
+        changes.push({ span: { start, length: end - start }, newText: "" });
+    }
+    return changes.length > 0 ? applyTextChanges(input.text, changes) : input.text;
+}
+function normalizeDeltaImportSpecifiers(input) {
+    const rule = input.rule;
+    if (!rule || !rule.specifier && !rule.ending && !rule.builtin)
+        return input.text;
+    const before = createSourceFile(input.file, input.beforeText);
+    const current = createSourceFile(input.file, input.text);
+    const beforeImports = collectImportEvidence(before);
+    const replacements = [];
+    const config = (0, import_specifier_policy_1.readNearestTsConfig)(input.file, input.workspaceRoot, input.tsConfigCache);
+    for (const statement of current.statements) {
+        const moduleSpecifier = moduleSpecifierOf(statement);
+        if (!moduleSpecifier || !isImportRuleDelta(statement, current, beforeImports))
+            continue;
+        const original = moduleSpecifier.text;
+        let next = normalizeBuiltinSpecifier(original, rule.builtin) ?? original;
+        if (!isBuiltinSpecifier(next) && (rule.specifier || rule.ending)) {
+            const resolved = (0, import_specifier_policy_1.resolveImportSpecifier)(input.file, next, config) ??
+                input.resolveVirtualModuleTarget?.({ fileName: input.file, specifier: next }) ?? null;
+            if (resolved) {
+                const effectiveRule = (0, import_specifier_policy_1.materializeAutoImportEnding)(rule, original);
+                const preferred = (0, import_specifier_policy_1.chooseImportSpecifier)({
+                    fromFile: input.file,
+                    targetFile: resolved,
+                    config,
+                    rule: effectiveRule,
+                    allowIndexCollapse: true
+                });
+                if (!input.acceptsModuleSpecifier || input.acceptsModuleSpecifier({
+                    fileName: input.file,
+                    specifier: preferred,
+                    targetFile: resolved
+                })) {
+                    next = preferred;
+                }
+                else {
+                    const relative = (0, import_specifier_policy_1.chooseImportSpecifier)({
+                        fromFile: input.file,
+                        targetFile: resolved,
+                        config,
+                        rule: { ...effectiveRule, specifier: "relative" },
+                        allowIndexCollapse: true
+                    });
+                    next = input.acceptsModuleSpecifier({
+                        fileName: input.file,
+                        specifier: relative,
+                        targetFile: resolved
+                    })
+                        ? relative
+                        : input.acceptsModuleSpecifier({
+                            fileName: input.file,
+                            specifier: original,
+                            targetFile: resolved
+                        })
+                            ? original
+                            : preferred;
+                }
+            }
+        }
+        if (next !== original) {
+            replacements.push({ start: moduleSpecifier.getStart(current) + 1, length: original.length, text: next });
+        }
+    }
+    let output = input.text;
+    for (const replacement of replacements.sort((left, right) => right.start - left.start)) {
+        output = `${output.slice(0, replacement.start)}${replacement.text}${output.slice(replacement.start + replacement.length)}`;
+    }
+    return output;
+}
+function resolveEffectiveImportRule(file, workspaceRoot, importRules, workspacePreferences) {
+    if (importRules.length > 0) {
+        return (0, import_rules_1.resolveImportRuleForFile)(file, importRules);
+    }
+    const editor = workspacePreferences
+        ? (0, typescript_preferences_1.resolveWorkspaceImportPreferences)(workspacePreferences, file)
+        : {};
+    if (!editor.specifier && !editor.ending)
+        return null;
+    return {
+        scope: ".",
+        scopePath: workspaceRoot,
+        ...editor
+    };
+}
+function collectImportEvidence(source) {
+    return source.statements.flatMap((statement) => {
+        const specifier = moduleSpecifierOf(statement);
+        if (!specifier)
+            return [];
+        return [{
+                kind: typescript_1.default.isImportDeclaration(statement) ? "import" : "export",
+                specifier: specifier.text,
+                localNames: importLocalNames(statement)
+            }];
+    });
+}
+function isImportRuleDelta(statement, source, before) {
+    const specifier = moduleSpecifierOf(statement);
+    if (!specifier)
+        return false;
+    const kind = typescript_1.default.isImportDeclaration(statement) ? "import" : "export";
+    const sameSpecifier = before.filter((item) => item.kind === kind && item.specifier === specifier.text);
+    if (sameSpecifier.length === 0)
+        return true;
+    const beforeNames = new Set(before.filter((item) => item.kind === kind).flatMap((item) => [...item.localNames]));
+    return [...importLocalNames(statement)].some((name) => !beforeNames.has(name));
+}
+function importLocalNames(statement) {
+    const names = new Set();
+    if (typescript_1.default.isImportDeclaration(statement)) {
+        const clause = statement.importClause;
+        if (clause?.name)
+            names.add(clause.name.text);
+        const bindings = clause?.namedBindings;
+        if (bindings && typescript_1.default.isNamespaceImport(bindings))
+            names.add(bindings.name.text);
+        if (bindings && typescript_1.default.isNamedImports(bindings)) {
+            for (const element of bindings.elements)
+                names.add(element.name.text);
+        }
+    }
+    else if (typescript_1.default.isExportDeclaration(statement) && statement.exportClause && typescript_1.default.isNamedExports(statement.exportClause)) {
+        for (const element of statement.exportClause.elements)
+            names.add(element.name.text);
+    }
+    return names;
+}
+function moduleSpecifierOf(statement) {
+    return (typescript_1.default.isImportDeclaration(statement) || typescript_1.default.isExportDeclaration(statement)) && statement.moduleSpecifier && typescript_1.default.isStringLiteralLike(statement.moduleSpecifier)
+        ? statement.moduleSpecifier
+        : null;
+}
+function normalizeBuiltinSpecifier(specifier, preference) {
+    if ((preference !== "node" && preference !== "bare") || !isBuiltinSpecifier(specifier))
+        return null;
+    const bare = specifier.startsWith("node:") ? specifier.slice("node:".length) : specifier;
+    return preference === "node" ? `node:${bare}` : bare;
+}
+function isBuiltinSpecifier(specifier) {
+    return BUILTIN_MODULES.has(specifier);
+}
+function samePath(left, right, platform = process.platform) {
+    const normalize = (value) => {
+        const normalized = path.resolve(value).replace(/\\/g, "/");
+        return platform === "win32" ? normalized.toLowerCase() : normalized;
+    };
+    return normalize(left) === normalize(right);
+}
+exports.SEMANTIC_MOVE_POLICY_TESTING = { samePath };
+function firstStatementName(statement) {
+    if ((typescript_1.default.isTypeAliasDeclaration(statement) || typescript_1.default.isInterfaceDeclaration(statement) || typescript_1.default.isClassDeclaration(statement) ||
+        typescript_1.default.isFunctionDeclaration(statement) || typescript_1.default.isEnumDeclaration(statement) || typescript_1.default.isModuleDeclaration(statement)) &&
+        statement.name && typescript_1.default.isIdentifier(statement.name))
+        return statement.name.text;
+    if (typescript_1.default.isVariableStatement(statement)) {
+        const declaration = statement.declarationList.declarations[0];
+        return declaration && typescript_1.default.isIdentifier(declaration.name) ? declaration.name.text : null;
+    }
+    return null;
+}
+function applyTextChanges(text, changes) {
+    let output = text;
+    for (const change of [...changes].sort((left, right) => right.span.start - left.span.start || right.span.length - left.span.length)) {
+        output = `${output.slice(0, change.span.start)}${change.newText}${output.slice(change.span.start + change.span.length)}`;
+    }
+    return output;
+}
+function createSourceFile(file, text) {
+    const extension = path.extname(file).toLowerCase();
+    const scriptKind = extension === ".tsx" ? typescript_1.default.ScriptKind.TSX
+        : extension === ".jsx" ? typescript_1.default.ScriptKind.JSX
+            : [".js", ".mjs", ".cjs"].includes(extension) ? typescript_1.default.ScriptKind.JS
+                : typescript_1.default.ScriptKind.TS;
+    return typescript_1.default.createSourceFile(file, text, typescript_1.default.ScriptTarget.Latest, true, scriptKind);
+}

package/dist/mutation/semantic-move-process.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSemanticMoveConfigWorker = runSemanticMoveConfigWorker;
+const node_child_process_1 = require("node:child_process");
+const semantic_worker_retry_1 = require("./semantic-worker-retry");
+const EXIT_GRACE_MS = 1_000;
+const EXIT_FORCE_MS = 2_000;
+async function runSemanticMoveConfigWorker(input) {
+    return (0, semantic_worker_retry_1.runSemanticWorkerWithRetry)(() => runSemanticMoveConfigWorkerAttempt(input));
+}
+async function runSemanticMoveConfigWorkerAttempt(input) {
+    const startedAt = Date.now();
+    const metricsEnabled = input.request.metricsEnabled === true;
+    const spawnStartedAt = metricsEnabled ? Date.now() : 0;
+    const child = (0, node_child_process_1.fork)(input.modulePath, [], {
+        windowsHide: true,
+        detached: false,
+        stdio: ["ignore", "ignore", "ignore", "ipc"],
+        env: { ...process.env, ELECTRON_RUN_AS_NODE: "1" }
+    });
+    const spawnMs = metricsEnabled ? Date.now() - spawnStartedAt : 0;
+    const pid = child.pid ?? null;
+    if (!pid) {
+        const terminationConfirmed = await terminateChild(child, null);
+        throw workerError(terminationConfirmed ? "SEMANTIC_MOVE_WORKER_START_FAILED" : "SEMANTIC_MOVE_WORKER_TERMINATION_FAILED", terminationConfirmed ? "Semantic move config worker did not publish a PID." : "PID-less worker exit was not confirmed.");
+    }
+    let timer = null;
+    try {
+        const result = await new Promise((resolve, reject) => {
+            let settled = false;
+            const settle = (error, value) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                child.removeAllListeners("message");
+                child.removeAllListeners("error");
+                child.removeAllListeners("exit");
+                if (error)
+                    reject(error);
+                else
+                    resolve(value);
+            };
+            timer = setTimeout(() => settle(workerError("SEMANTIC_MOVE_WORKER_DEADLINE", `Semantic move config worker exceeded ${input.deadlineMs}ms.`)), input.deadlineMs);
+            timer.unref();
+            child.once("error", (error) => settle(workerError("SEMANTIC_MOVE_WORKER_START_FAILED", error.message)));
+            child.once("exit", (code, signal) => settle(workerError("SEMANTIC_MOVE_WORKER_CRASHED", `Semantic move config worker exited before a result (code=${String(code)}, signal=${String(signal)}).`)));
+            child.once("message", (raw) => {
+                if (!isCompatibleResult(raw, input.request, pid)) {
+                    settle(workerError("SEMANTIC_MOVE_WORKER_PROTOCOL", "Semantic move config worker returned malformed or mismatched evidence."));
+                    return;
+                }
+                settle(null, raw);
+            });
+            child.send(input.request, (error) => {
+                if (error)
+                    settle(workerError("SEMANTIC_MOVE_WORKER_START_FAILED", error.message));
+            });
+        });
+        const terminateStartedAt = metricsEnabled ? Date.now() : 0;
+        const terminationConfirmed = await terminateChild(child, pid);
+        const terminateMs = metricsEnabled ? Date.now() - terminateStartedAt : 0;
+        if (!terminationConfirmed) {
+            throw workerError("SEMANTIC_MOVE_WORKER_TERMINATION_FAILED", `Worker process-tree exit was not confirmed for PID ${pid}.`);
+        }
+        return {
+            result,
+            durationMs: Date.now() - startedAt,
+            terminationConfirmed: true,
+            ...(metricsEnabled ? { metrics: { spawnMs, terminateMs } } : {})
+        };
+    }
+    catch (error) {
+        const terminationConfirmed = await terminateChild(child, pid);
+        if (!terminationConfirmed) {
+            throw workerError("SEMANTIC_MOVE_WORKER_TERMINATION_FAILED", `Worker failure was followed by unconfirmed process-tree exit for PID ${pid}.`);
+        }
+        throw error;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function isCompatibleResult(raw, request, pid) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return false;
+    const value = raw;
+    return value.type === "semanticMoveConfigResult" && value.id === request.id &&
+        value.configFilePath === request.configFilePath && value.pid === pid &&
+        typeof value.ok === "boolean" && typeof value.containsSource === "boolean" &&
+        Array.isArray(value.rootFiles) && value.rootFiles.every((item) => typeof item === "string") &&
+        Array.isArray(value.edits) && value.edits.every(isCompatibleFileEdit) &&
+        isStringRecord(value.beforeHashes) && typeof value.configHash === "string" &&
+        (value.exportStarProofs === undefined || Array.isArray(value.exportStarProofs) && value.exportStarProofs.every(isCompatibleExportStarProof)) &&
+        typeof value.rssMiB === "number" && Number.isFinite(value.rssMiB) &&
+        (value.failureKind === undefined || ["provider-unsupported", "changes-overlap", "provider-failed", "owner-incomplete", "worker-error"].includes(value.failureKind)) &&
+        (value.providerCode === undefined || ["TS_MOVE_TO_FILE_UNSUPPORTED_BY_ENGINE", "TS_MOVE_TO_FILE_REFACTOR_FAILED", "SEMANTIC_MOVE_PROVIDER_FAILED"].includes(value.providerCode)) &&
+        (value.error === undefined || typeof value.error === "string") &&
+        (value.metrics === undefined || isCompatibleMetrics(value.metrics));
+}
+function isCompatibleExportStarProof(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const proof = value;
+    return typeof proof.barrelFile === "string" && typeof proof.moduleSpecifier === "string" &&
+        Number.isSafeInteger(proof.specifierStart) && proof.specifierStart >= 0 &&
+        typeof proof.entity === "string" && proof.entity.length > 0 &&
+        typeof proof.checked === "boolean" &&
+        typeof proof.matchesSourceSymbol === "boolean" && typeof proof.typeOnly === "boolean";
+}
+function isCompatibleMetrics(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const metrics = value;
+    return Boolean(metrics.phasesMs) && typeof metrics.phasesMs === "object" && !Array.isArray(metrics.phasesMs) &&
+        Object.entries(metrics.phasesMs).every(([key, duration]) => ["config", "program", "refactor", "cleanupScan", "cleanupRefresh", "cleanupOracle", "cleanupRender", "serialize"].includes(key) &&
+            typeof duration === "number" && Number.isFinite(duration) && duration >= 0) &&
+        (metrics.unusedImportCleanup === undefined || isCompatibleCleanupMetrics(metrics.unusedImportCleanup)) &&
+        typeof metrics.peakRssMiB === "number" && Number.isFinite(metrics.peakRssMiB) && metrics.peakRssMiB >= 0 &&
+        typeof metrics.endingRssMiB === "number" && Number.isFinite(metrics.endingRssMiB) && metrics.endingRssMiB >= 0;
+}
+function isCompatibleCleanupMetrics(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const metrics = value;
+    return [metrics.candidateFiles, metrics.candidateBindings, metrics.oracleFiles, metrics.removedBindings]
+        .every((item) => Number.isSafeInteger(item) && item >= 0);
+}
+function isCompatibleFileEdit(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const edit = value;
+    return typeof edit.fileName === "string" && typeof edit.isNewFile === "boolean" &&
+        Array.isArray(edit.textChanges) && edit.textChanges.every(isCompatibleTextChange);
+}
+function isCompatibleTextChange(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const change = value;
+    return Boolean(change.span) && typeof change.span === "object" && !Array.isArray(change.span) &&
+        Number.isSafeInteger(change.span.start) && change.span.start >= 0 &&
+        Number.isSafeInteger(change.span.length) && change.span.length >= 0 &&
+        typeof change.newText === "string";
+}
+function isStringRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value) &&
+        Object.entries(value).every(([key, item]) => key !== "" && typeof item === "string");
+}
+async function terminateChild(child, pid) {
+    if (child.connected)
+        child.disconnect();
+    if (pid === null) {
+        try {
+            child.kill("SIGKILL");
+        }
+        catch { /* already gone */ }
+        return waitForExit(child, EXIT_FORCE_MS);
+    }
+    if (!isAlive(pid) && hasExited(child))
+        return true;
+    if (process.platform === "win32") {
+        (0, node_child_process_1.spawnSync)("taskkill.exe", ["/PID", String(pid), "/T", "/F"], {
+            windowsHide: true,
+            stdio: "ignore",
+            timeout: EXIT_FORCE_MS
+        });
+        return waitForDead(child, pid, EXIT_FORCE_MS);
+    }
+    try {
+        child.kill("SIGTERM");
+    }
+    catch { /* already gone */ }
+    if (await waitForDead(child, pid, EXIT_GRACE_MS))
+        return true;
+    try {
+        child.kill("SIGKILL");
+    }
+    catch { /* already gone */ }
+    return waitForDead(child, pid, EXIT_FORCE_MS);
+}
+async function waitForDead(child, pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+        if (!isAlive(pid) && hasExited(child))
+            return true;
+        await delay(20);
+    }
+    return !isAlive(pid) && hasExited(child);
+}
+async function waitForExit(child, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+        if (hasExited(child))
+            return true;
+        await delay(20);
+    }
+    return hasExited(child);
+}
+function hasExited(child) {
+    return child.exitCode !== null || child.signalCode !== null;
+}
+function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function workerError(code, message) {
+    return Object.assign(new Error(message), { code });
+}

package/dist/mutation/semantic-move-provider-diagnostics.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifySemanticMoveProviderException = classifySemanticMoveProviderException;
+function classifySemanticMoveProviderException(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/Expected symbol to be a module/i.test(message)) {
+        return {
+            failureKind: "provider-unsupported",
+            code: "TS_MOVE_TO_FILE_UNSUPPORTED_BY_ENGINE",
+            error: "TypeScript move-to-file cannot move this selection; manual extraction is required."
+        };
+    }
+    if (/Changes overlap/i.test(message)) {
+        return {
+            failureKind: "changes-overlap",
+            code: "TS_MOVE_TO_FILE_REFACTOR_FAILED",
+            error: "Changes overlap"
+        };
+    }
+    const rawName = error instanceof Error ? error.name : "Error";
+    const safeName = /^[A-Za-z][A-Za-z0-9]*$/.test(rawName) ? rawName : "Error";
+    return {
+        failureKind: "provider-failed",
+        code: "SEMANTIC_MOVE_PROVIDER_FAILED",
+        error: `TypeScript refactor provider threw an exception (${safeName}).`
+    };
+}