@automaton-labs/aib 0.0.7 → 0.0.8

package/dist/mutation/semantic-rename-config-worker.js

@@ -0,0 +1,498 @@
+"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.runSemanticRenameConfigJob = runSemanticRenameConfigJob;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const semantic_rename_commonjs_1 = require("./semantic-rename-commonjs");
+const semantic_rename_locations_1 = require("./semantic-rename-locations");
+function runSemanticRenameConfigJob(request) {
+    let languageService = null;
+    let program = null;
+    try {
+        const parsed = parseConfig(request.configFilePath);
+        languageService = createLanguageService(request.configFilePath, parsed, new Map([[pathKey(request.sourceFile), request.sourceText]]), request.programRootFiles);
+        program = languageService.getProgram() ?? null;
+        if (!program)
+            throw new Error("TypeScript LanguageService did not provide a Program.");
+        const containsSource = program.getSourceFiles().some((file) => pathKey(file.fileName) === pathKey(request.sourceFile));
+        const checker = program.getTypeChecker();
+        const source = program.getSourceFiles().find((file) => pathKey(file.fileName) === pathKey(request.sourceFile));
+        const beforeHashes = {};
+        const workerIntents = request.intents.map((intent) => {
+            const info = languageService.getRenameInfo(request.sourceFile, intent.position, { allowRenameOfImportPath: false });
+            if (!info.canRename) {
+                return {
+                    id: intent.id,
+                    canRename: false,
+                    error: info.localizedErrorMessage ?? "TypeScript API returned canRename=false.",
+                    completeLocations: [],
+                    preserveLocations: [],
+                    baseLocations: [],
+                    effectiveLocations: [],
+                    commonJsBlockers: []
+                };
+            }
+            const base = languageService.findRenameLocations(request.sourceFile, intent.position, false, false, false) ?? [];
+            const sourceNode = source ? tokenAt(source, intent.position) : null;
+            const sourceSymbol = sourceNode ? canonicalSymbol(checker, symbolAtRenameSite(checker, sourceNode)) : undefined;
+            const commonJs = sourceSymbol
+                ? (0, semantic_rename_commonjs_1.collectCommonJsRenameEvidence)(languageService, program, checker, request, intent, sourceSymbol)
+                : { locations: [], blockers: [] };
+            const proofLocations = uniqueRenameLocations([...base, ...commonJs.locations]);
+            const complete = (0, semantic_rename_locations_1.expandSemanticRenameLocations)(languageService, proofLocations);
+            const preserve = languageService.findRenameLocations(request.sourceFile, intent.position, false, false, true) ?? [];
+            const preserveSpans = new Set(preserve.map(renameLocationSpanKey));
+            const effective = request.preserveIntentIds.includes(intent.id)
+                ? complete.filter((location) => preserveSpans.has(renameLocationSpanKey(location)))
+                : complete;
+            for (const location of effective) {
+                const file = path.normalize(location.fileName);
+                beforeHashes[file] ??= hashFile(file);
+            }
+            return {
+                id: intent.id,
+                canRename: true,
+                completeLocations: complete.map((location) => (0, semantic_rename_locations_1.serializeSemanticRenameLocation)(program, location)),
+                preserveLocations: preserve.map((location) => (0, semantic_rename_locations_1.serializeSemanticRenameLocation)(program, location)),
+                baseLocations: proofLocations,
+                effectiveLocations: effective,
+                commonJsBlockers: commonJs.blockers
+            };
+        });
+        const intents = workerIntents.map(({ baseLocations: _base, effectiveLocations: _effective, commonJsBlockers: _commonJsBlockers, ...intent }) => intent);
+        const commonJsBlockers = workerIntents.flatMap((intent) => intent.commonJsBlockers);
+        const rootFiles = [...program.getRootFileNames()].map(path.normalize);
+        const starProofs = request.starBoundaries.map((boundary) => proveStarBoundary(program, checker, request, boundary));
+        const collisionProofs = proveTargetBindings(request, program, workerIntents);
+        return {
+            type: "semanticRenameConfigResult",
+            id: request.id,
+            ok: containsSource && intents.every((intent) => intent.canRename) &&
+                collisionProofs.every((proof) => proof.status === "proven") && commonJsBlockers.length === 0,
+            configFilePath: path.normalize(request.configFilePath),
+            rootFiles,
+            containsSource,
+            intents,
+            starProofs,
+            collisionProofs,
+            commonJsBlockers,
+            beforeHashes,
+            configHash: hashFile(request.configFilePath),
+            pid: process.pid,
+            rssMiB: process.memoryUsage().rss / 1024 / 1024,
+            ...(!containsSource ? { error: "Selected project does not contain the rename source." } : {})
+        };
+    }
+    catch (error) {
+        return {
+            type: "semanticRenameConfigResult",
+            id: request.id,
+            ok: false,
+            configFilePath: path.normalize(request.configFilePath),
+            rootFiles: [],
+            containsSource: false,
+            intents: [],
+            starProofs: [],
+            collisionProofs: [],
+            commonJsBlockers: [],
+            beforeHashes: {},
+            configHash: "",
+            pid: process.pid,
+            rssMiB: process.memoryUsage().rss / 1024 / 1024,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+    finally {
+        languageService?.dispose();
+    }
+}
+function proveStarBoundary(program, checker, request, boundary) {
+    const barrel = program.getSourceFiles().find((file) => pathKey(file.fileName) === pathKey(boundary.file));
+    if (!barrel)
+        return { id: boundary.id, status: "notPresent" };
+    const source = program.getSourceFiles().find((file) => pathKey(file.fileName) === pathKey(request.sourceFile));
+    const intent = request.intents.find((item) => item.id === boundary.intentId);
+    if (!source || !intent)
+        return { id: boundary.id, status: "unresolved", error: "Rename source is absent from this Program." };
+    const declarationSymbol = canonicalSymbol(checker, checker.getSymbolAtLocation(tokenAt(source, intent.position)));
+    if (!declarationSymbol)
+        return { id: boundary.id, status: "unresolved", error: "Source declaration symbol is unresolved." };
+    let current = tokenAt(barrel, boundary.start);
+    while (current && !typescript_1.default.isExportDeclaration(current))
+        current = current.parent;
+    if (!current || current.exportClause || !current.moduleSpecifier || !typescript_1.default.isStringLiteral(current.moduleSpecifier) ||
+        current.isTypeOnly !== boundary.typeOnly) {
+        return { id: boundary.id, status: "divergent", error: "Structural export-star boundary no longer matches the Program AST." };
+    }
+    const targetModule = canonicalSymbol(checker, checker.getSymbolAtLocation(current.moduleSpecifier));
+    if (!targetModule || !symbolDeclaresFile(targetModule, boundary.targetFile)) {
+        return { id: boundary.id, status: "divergent", error: "Export-star resolves to a different module." };
+    }
+    const barrelModule = checker.getSymbolAtLocation(barrel);
+    if (!barrelModule)
+        return { id: boundary.id, status: "unresolved", error: "Barrel module symbol is unresolved." };
+    const exports = checker.getExportsOfModule(barrelModule);
+    const oldExport = exports.find((item) => item.name === boundary.oldName);
+    const localAliasMatches = pathKey(boundary.targetFile) === pathKey(request.sourceFile) &&
+        hasLocalExportAlias(source, intent.oldName, boundary.oldName);
+    if (!oldExport || (!symbolsEquivalent(canonicalSymbol(checker, oldExport), declarationSymbol) && !localAliasMatches)) {
+        return { id: boundary.id, status: "divergent", error: "Export-star old name does not resolve to the rename source symbol." };
+    }
+    if (exports.some((item) => item.name === boundary.newName)) {
+        return { id: boundary.id, status: "collision", error: "The requested new name is already exported by this barrel." };
+    }
+    return { id: boundary.id, status: "proven" };
+}
+function hasLocalExportAlias(source, localName, exposedName) {
+    return source.statements.some((statement) => typescript_1.default.isExportDeclaration(statement) && !statement.moduleSpecifier && statement.exportClause && typescript_1.default.isNamedExports(statement.exportClause) &&
+        statement.exportClause.elements.some((element) => (element.propertyName?.text ?? element.name.text) === localName && element.name.text === exposedName));
+}
+function uniqueRenameLocations(locations) {
+    const seen = new Set();
+    return locations.filter((location) => {
+        const key = `${renameLocationSpanKey(location)}:${location.prefixText ?? ""}\0${location.suffixText ?? ""}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function proveTargetBindings(request, program, intents) {
+    const failed = intents.find((intent) => !intent.canRename);
+    if (failed)
+        return request.intents.map((intent) => ({
+            id: intent.id,
+            status: "unresolved",
+            error: failed.error ?? "Original rename symbol is unavailable."
+        }));
+    const checker = program.getTypeChecker();
+    const sources = sourceMap(program);
+    const proofs = [];
+    for (const intent of request.intents) {
+        const source = sources.get(pathKey(request.sourceFile));
+        const sourceNode = source ? tokenAt(source, intent.position) : null;
+        const sourceSymbol = sourceNode ? canonicalSymbol(checker, symbolAtRenameSite(checker, sourceNode)) : undefined;
+        const evidence = intents.find((item) => item.id === intent.id);
+        if (!source || !sourceSymbol || !evidence) {
+            proofs.push({ id: intent.id, status: "unresolved", error: `Original symbol proof is unavailable for ${intent.oldName}.` });
+            continue;
+        }
+        const effectiveSpans = new Set(evidence.effectiveLocations.map(renameLocationSpanKey));
+        let failure = null;
+        for (const location of evidence.baseLocations.filter((item) => effectiveSpans.has(renameLocationSpanKey(item)))) {
+            const locationSource = sources.get(pathKey(location.fileName));
+            const node = locationSource ? tokenAt(locationSource, location.textSpan.start) : null;
+            const symbol = node ? canonicalSymbol(checker, symbolAtRenameSite(checker, node)) : undefined;
+            if (!symbol || !symbolsEquivalent(symbol, sourceSymbol)) {
+                failure = { status: "unresolved", error: `Original owner symbol proof diverged at ${location.fileName}:${location.textSpan.start}.` };
+                break;
+            }
+            failure = proveTargetAtSite(checker, node, intent.oldName, intent.newName, sourceSymbol, location);
+            if (failure)
+                break;
+        }
+        proofs.push(failure ? {
+            id: intent.id,
+            status: failure.status,
+            error: failure.error,
+            ...(failure.collision ? {
+                blocker: {
+                    ...failure.collision,
+                    intentId: intent.id,
+                    oldName: intent.oldName,
+                    newName: intent.newName
+                }
+            } : {})
+        } : { id: intent.id, status: "proven" });
+    }
+    return proofs;
+}
+function proveTargetAtSite(checker, node, oldName, newName, sourceSymbol, location) {
+    const binding = relatedShorthandBinding(checker, node);
+    if (binding) {
+        const receiver = objectBindingSource(binding);
+        if (!receiver) {
+            return { status: "unresolved", error: `Object binding source is unresolved at ${location.fileName}:${location.textSpan.start}.` };
+        }
+        const propertyCollision = proveMemberTarget(checker, checker.getTypeAtLocation(receiver), newName, sourceSymbol, location, "object binding property");
+        if (propertyCollision)
+            return propertyCollision;
+        return differentTarget(checker.resolveName(newName, node, typescript_1.default.SymbolFlags.Value, false), checker, sourceSymbol, location, newName, "object binding scope");
+    }
+    if (typescript_1.default.isIdentifier(node) && typescript_1.default.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
+        return proveMemberTarget(checker, checker.getTypeAtLocation(node.parent.expression), newName, sourceSymbol, location, "property");
+    }
+    if (typescript_1.default.isIdentifier(node) && typescript_1.default.isQualifiedName(node.parent) && node.parent.right === node) {
+        const module = canonicalSymbol(checker, checker.getSymbolAtLocation(node.parent.left));
+        const exported = module && module.flags & typescript_1.default.SymbolFlags.Module
+            ? checker.getExportsOfModule(module).find((item) => item.name === newName)
+            : undefined;
+        const existing = exported ?? checker.getPropertyOfType(checker.getTypeAtLocation(node.parent.left), newName);
+        return differentTarget(existing, checker, sourceSymbol, location, newName, "qualified member");
+    }
+    if (typescript_1.default.isIdentifier(node) && typescript_1.default.isExportSpecifier(node.parent)) {
+        const specifier = node.parent;
+        if (specifier.propertyName === node) {
+            const declaration = containingModuleDeclaration(specifier);
+            if (declaration?.moduleSpecifier) {
+                return proveModuleSpecifierTarget(checker, specifier, newName, sourceSymbol, location, "re-export source");
+            }
+        }
+        else {
+            return proveContainingModuleExport(checker, specifier.getSourceFile(), newName, sourceSymbol, location);
+        }
+    }
+    if (typescript_1.default.isIdentifier(node) && typescript_1.default.isImportSpecifier(node.parent) && node.parent.propertyName === node) {
+        return proveModuleSpecifierTarget(checker, node.parent, newName, sourceSymbol, location, "import source");
+    }
+    const meanings = activeRenameMeanings(checker, node, oldName, sourceSymbol);
+    if (meanings.length === 0) {
+        return { status: "unresolved", error: `Rename meaning is unresolved at ${location.fileName}:${location.textSpan.start}.` };
+    }
+    for (const meaning of meanings) {
+        const existing = checker.resolveName(newName, node, meaning, false);
+        const collision = differentTarget(existing, checker, sourceSymbol, location, newName, `${meaningLabel(meaning)} scope`);
+        if (collision)
+            return collision;
+    }
+    return null;
+}
+function proveMemberTarget(checker, receiver, newName, sourceSymbol, location, label) {
+    return differentTarget(checker.getPropertyOfType(receiver, newName), checker, sourceSymbol, location, newName, label);
+}
+function proveModuleSpecifierTarget(checker, specifier, newName, sourceSymbol, location, label) {
+    const declaration = containingModuleDeclaration(specifier);
+    if (!declaration?.moduleSpecifier) {
+        return { status: "unresolved", error: `Module target proof is unavailable at ${location.fileName}:${location.textSpan.start}.` };
+    }
+    const module = canonicalSymbol(checker, checker.getSymbolAtLocation(declaration.moduleSpecifier));
+    if (!module)
+        return { status: "unresolved", error: `Module symbol is unresolved at ${location.fileName}:${location.textSpan.start}.` };
+    const existing = checker.getExportsOfModule(module).find((item) => item.name === newName);
+    return differentTarget(existing, checker, sourceSymbol, location, newName, label);
+}
+function containingModuleDeclaration(specifier) {
+    let current = specifier.parent;
+    while (current && !typescript_1.default.isImportDeclaration(current) && !typescript_1.default.isExportDeclaration(current))
+        current = current.parent;
+    return current && (typescript_1.default.isImportDeclaration(current) || typescript_1.default.isExportDeclaration(current)) ? current : null;
+}
+function proveContainingModuleExport(checker, sourceFile, newName, sourceSymbol, location) {
+    const module = checker.getSymbolAtLocation(sourceFile);
+    if (!module)
+        return { status: "unresolved", error: `Containing module symbol is unresolved at ${location.fileName}:${location.textSpan.start}.` };
+    const existing = checker.getExportsOfModule(module).find((item) => item.name === newName);
+    return differentTarget(existing, checker, sourceSymbol, location, newName, "module export surface");
+}
+function differentTarget(existing, checker, sourceSymbol, location, newName, label) {
+    const canonical = canonicalSymbol(checker, existing);
+    return canonical && !symbolsEquivalent(canonical, sourceSymbol) && symbolsShareMeaning(canonical, sourceSymbol)
+        ? {
+            status: "collision",
+            error: `Target ${newName} already binds on the renamed ${label} at ${location.fileName}:${location.textSpan.start}.`,
+            collision: {
+                kind: "targetCollision",
+                reason: "targetAlreadyBound",
+                fileName: path.normalize(location.fileName),
+                start: location.textSpan.start,
+                length: location.textSpan.length,
+                surface: label
+            }
+        }
+        : null;
+}
+function symbolsShareMeaning(left, right) {
+    return RENAME_MEANINGS.some((meaning) => Boolean(left.flags & meaning) && Boolean(right.flags & meaning));
+}
+const RENAME_MEANINGS = [typescript_1.default.SymbolFlags.Value, typescript_1.default.SymbolFlags.Type, typescript_1.default.SymbolFlags.Namespace];
+function activeRenameMeanings(checker, node, oldName, sourceSymbol) {
+    return RENAME_MEANINGS.filter((meaning) => {
+        const resolved = canonicalSymbol(checker, checker.resolveName(oldName, node, meaning, false));
+        return resolved ? symbolsEquivalent(resolved, sourceSymbol) : Boolean(sourceSymbol.flags & meaning);
+    });
+}
+function meaningLabel(meaning) {
+    if (meaning === typescript_1.default.SymbolFlags.Value)
+        return "value";
+    if (meaning === typescript_1.default.SymbolFlags.Type)
+        return "type";
+    return "namespace";
+}
+function sourceMap(program) {
+    return new Map(program.getSourceFiles().map((source) => [pathKey(source.fileName), source]));
+}
+function symbolAtRenameSite(checker, node) {
+    if (typescript_1.default.isIdentifier(node) && typescript_1.default.isShorthandPropertyAssignment(node.parent)) {
+        return checker.getShorthandAssignmentValueSymbol(node.parent) ?? checker.getSymbolAtLocation(node);
+    }
+    const direct = checker.getSymbolAtLocation(node);
+    const binding = relatedShorthandBinding(checker, node);
+    const receiver = binding ? objectBindingSource(binding) : null;
+    if (binding && receiver && typescript_1.default.isIdentifier(binding.name)) {
+        return checker.getPropertyOfType(checker.getTypeAtLocation(receiver), binding.name.text) ?? direct;
+    }
+    return direct;
+}
+function relatedShorthandBinding(checker, node) {
+    return shorthandBindingElement(node) ?? checker.getSymbolAtLocation(node)?.declarations?.find(isShorthandBindingElement) ?? null;
+}
+function shorthandBindingElement(node) {
+    return typescript_1.default.isIdentifier(node) && isShorthandBindingElement(node.parent) && node.parent.name === node
+        ? node.parent
+        : null;
+}
+function isShorthandBindingElement(node) {
+    return typescript_1.default.isBindingElement(node) && !node.propertyName && typescript_1.default.isObjectBindingPattern(node.parent);
+}
+function objectBindingSource(binding) {
+    const declaration = binding.parent.parent;
+    return typescript_1.default.isVariableDeclaration(declaration) && declaration.initializer ? declaration.initializer : null;
+}
+function renameLocationSpanKey(location) {
+    return `${pathKey(location.fileName)}:${location.textSpan.start}:${location.textSpan.length}`;
+}
+function parseConfig(configFilePath) {
+    const source = typescript_1.default.readConfigFile(configFilePath, typescript_1.default.sys.readFile);
+    if (source.error)
+        throw new Error(typescript_1.default.flattenDiagnosticMessageText(source.error.messageText, "\n"));
+    const parsed = typescript_1.default.parseJsonConfigFileContent(source.config, typescript_1.default.sys, path.dirname(configFilePath), undefined, configFilePath);
+    if (parsed.errors.length > 0) {
+        throw new Error(parsed.errors.map((error) => typescript_1.default.flattenDiagnosticMessageText(error.messageText, "\n")).join("\n"));
+    }
+    return parsed;
+}
+function createLanguageService(configFilePath, parsed, overrides, programRootFiles) {
+    const overrideFiles = [...overrides.keys()];
+    const configuredRoots = programRootFiles
+        ? programRootFiles.map((file) => path.resolve(file))
+        : parsed.fileNames;
+    const host = {
+        getScriptFileNames: () => uniqueFileNames([...configuredRoots, ...overrideFiles]),
+        getScriptVersion: (file) => overrides.has(pathKey(file)) ? "snapshot" : safeMtime(file),
+        getScriptSnapshot: (file) => {
+            const override = overrides.get(pathKey(file));
+            if (override !== undefined)
+                return typescript_1.default.ScriptSnapshot.fromString(override);
+            const text = typescript_1.default.sys.readFile(file);
+            return text === undefined ? undefined : typescript_1.default.ScriptSnapshot.fromString(text);
+        },
+        getCurrentDirectory: () => path.dirname(configFilePath),
+        getCompilationSettings: () => parsed.options,
+        getDefaultLibFileName: typescript_1.default.getDefaultLibFilePath,
+        fileExists: typescript_1.default.sys.fileExists,
+        readFile: typescript_1.default.sys.readFile,
+        readDirectory: typescript_1.default.sys.readDirectory,
+        directoryExists: typescript_1.default.sys.directoryExists,
+        getDirectories: typescript_1.default.sys.getDirectories,
+        ...(typescript_1.default.sys.realpath ? { realpath: typescript_1.default.sys.realpath } : {}),
+        useCaseSensitiveFileNames: () => typescript_1.default.sys.useCaseSensitiveFileNames,
+        getNewLine: () => typescript_1.default.sys.newLine
+    };
+    return typescript_1.default.createLanguageService(host, typescript_1.default.createDocumentRegistry());
+}
+function uniqueFileNames(files) {
+    const seen = new Set();
+    return files.filter((file) => {
+        const key = pathKey(file);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function canonicalSymbol(checker, symbol, seen = new Set()) {
+    let current = symbol;
+    while (current && current.flags & typescript_1.default.SymbolFlags.Alias && !seen.has(current)) {
+        seen.add(current);
+        const next = checker.getAliasedSymbol(current);
+        if (next === current)
+            break;
+        current = next;
+    }
+    const specifier = current?.declarations?.find(typescript_1.default.isExportSpecifier);
+    if (specifier) {
+        const local = checker.getExportSpecifierLocalTargetSymbol(specifier);
+        if (local && local !== current && !seen.has(local))
+            return canonicalSymbol(checker, local, seen);
+    }
+    return current;
+}
+function symbolsEquivalent(left, right) {
+    if (!left || !right)
+        return false;
+    if (left === right)
+        return true;
+    const leftDeclarations = new Set((left.declarations ?? []).map(declarationKey));
+    return (right.declarations ?? []).some((declaration) => leftDeclarations.has(declarationKey(declaration)));
+}
+function declarationKey(declaration) {
+    const source = declaration.getSourceFile();
+    return `${pathKey(source.fileName)}:${declaration.getStart(source)}:${declaration.getEnd()}`;
+}
+function symbolDeclaresFile(symbol, fileName) {
+    return (symbol.declarations ?? []).some((declaration) => pathKey(declaration.getSourceFile().fileName) === pathKey(fileName));
+}
+function tokenAt(source, position) {
+    let found = source;
+    const visit = (node) => {
+        if (position < node.getStart(source) || position >= node.getEnd())
+            return;
+        found = node;
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    return found;
+}
+function hashFile(file) {
+    return crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+}
+function safeMtime(file) {
+    try {
+        return String(fs.statSync(file).mtimeMs);
+    }
+    catch {
+        return "0";
+    }
+}
+function pathKey(file) {
+    const normalized = path.normalize(file);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}