@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/mutation/semantic-rename-standalone-planner.js

@@ -0,0 +1,567 @@
+"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.planStandaloneSemanticRename = planStandaloneSemanticRename;
+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 file_mutation_discovery_1 = require("./file-mutation-discovery");
+const semantic_rename_locations_1 = require("./semantic-rename-locations");
+const semantic_rename_process_1 = require("./semantic-rename-process");
+const semantic_program_roots_1 = require("./semantic-program-roots");
+const DEFAULT_DEADLINE_MS = 120_000;
+const MAX_CONFIGS = 32;
+async function planStandaloneSemanticRename(input, dependencies = {
+    discover: file_mutation_discovery_1.discoverFileMutationConsumers,
+    fingerprint: file_mutation_discovery_1.computeFileMutationWorkspaceFingerprint,
+    runConfig: semantic_rename_process_1.runSemanticRenameConfigWorker
+}) {
+    const startedAt = Date.now();
+    const root = path.resolve(input.workspaceRoot);
+    const discover = input.semanticContextPool
+        ? (request) => (0, file_mutation_discovery_1.discoverFileMutationConsumersWithProjectIndexLease)(input.semanticContextPool, request)
+        : dependencies.discover;
+    const fingerprint = input.semanticContextPool
+        ? (workspaceRoot) => input.semanticContextPool.withWorkspaceProjectIndex((index) => (0, file_mutation_discovery_1.computeFileMutationWorkspaceFingerprintWithProjectIndex)(index, workspaceRoot))
+        : dependencies.fingerprint;
+    const sourceFile = path.resolve(root, input.sourceFile);
+    const emptyDiscovery = discoverySummary(null);
+    if (!isInside(root, sourceFile) || !fs.existsSync(sourceFile) || !fs.statSync(sourceFile).isFile()) {
+        return incomplete("SEMANTIC_RENAME_SOURCE_INVALID", "Rename source is missing or outside the workspace.", root, sourceFile, emptyDiscovery, startedAt);
+    }
+    let sourceText;
+    try {
+        sourceText = fs.readFileSync(sourceFile, "utf8");
+    }
+    catch (error) {
+        return incomplete("SEMANTIC_RENAME_SOURCE_UNREADABLE", errorMessage(error), root, sourceFile, emptyDiscovery, startedAt);
+    }
+    const intents = buildIntents(sourceFile, sourceText, input.intents);
+    if (!intents.ok)
+        return incomplete(intents.code, intents.error, root, sourceFile, emptyDiscovery, startedAt);
+    let discovery;
+    try {
+        discovery = input.discovery ?? discover({ workspaceRoot: root, sourceFiles: [sourceFile] });
+    }
+    catch (error) {
+        return incomplete("SEMANTIC_RENAME_DISCOVERY_FAILED", errorMessage(error), root, sourceFile, emptyDiscovery, startedAt);
+    }
+    const summary = discoverySummary(discovery);
+    if (!discovery.complete || !discovery.sourceFiles.some((file) => samePath(file, sourceFile))) {
+        return incomplete("SEMANTIC_RENAME_DISCOVERY_INCOMPLETE", discovery.uncertainties.map((item) => `${item.kind}:${item.file}:${item.moduleSpecifier}`).join("; ") || "Neutral module discovery is incomplete.", root, sourceFile, summary, startedAt);
+    }
+    if (discovery.ownerConfigs.length === 0 || discovery.ownerConfigs.length > MAX_CONFIGS) {
+        return incomplete("SEMANTIC_RENAME_OWNER_SET_UNSUPPORTED", `Expected 1-${MAX_CONFIGS} exact owner configs, found ${discovery.ownerConfigs.length}.`, root, sourceFile, summary, startedAt);
+    }
+    let initialFingerprint;
+    try {
+        initialFingerprint = fingerprint(root);
+    }
+    catch (error) {
+        return incomplete("SEMANTIC_RENAME_SNAPSHOT_UNREADABLE", errorMessage(error), root, sourceFile, summary, startedAt);
+    }
+    if (initialFingerprint !== discovery.workspaceFingerprint) {
+        return incomplete("SEMANTIC_RENAME_DISCOVERY_STALE", "Workspace changed after neutral discovery.", root, sourceFile, summary, startedAt);
+    }
+    const evidenceFiles = uniquePaths([sourceFile, ...discovery.consumerFiles]);
+    const snapshotHash = hashFiles(evidenceFiles);
+    const starBoundaries = buildStarBoundaries(discovery.edges, intents.intents, sourceFile, sourceText);
+    if (!starBoundaries.ok) {
+        return incomplete(starBoundaries.code, starBoundaries.error, root, sourceFile, summary, startedAt, snapshotHash);
+    }
+    const stableAliases = collectStableAliasIntentIds(discovery.edges, intents.intents, sourceFile, sourceText);
+    const workerPath = input.testing?.configWorkerPath ?? path.join(__dirname, "semantic-rename-config-worker-child.js");
+    const results = [];
+    const workerEvidence = [];
+    for (const configFilePath of discovery.ownerConfigs) {
+        const request = {
+            type: "semanticRenameConfig",
+            id: crypto.randomUUID(),
+            configFilePath: path.normalize(configFilePath),
+            sourceFile,
+            sourceText,
+            intents: intents.intents,
+            preserveIntentIds: [...stableAliases],
+            starBoundaries: starBoundaries.boundaries,
+            programRootFiles: (0, semantic_program_roots_1.focusedSemanticProgramRootFiles)({
+                discovery,
+                configFilePath,
+                requiredFiles: [sourceFile]
+            })
+        };
+        let outcome;
+        try {
+            outcome = await dependencies.runConfig({
+                modulePath: workerPath,
+                request,
+                deadlineMs: input.deadlineMs ?? DEFAULT_DEADLINE_MS
+            });
+        }
+        catch (error) {
+            return incomplete(readErrorCode(error) ?? "SEMANTIC_RENAME_CONFIG_WORKER_FAILED", errorMessage(error), root, sourceFile, summary, startedAt, snapshotHash, workerEvidence);
+        }
+        workerEvidence.push({
+            configFilePath: outcome.result.configFilePath,
+            pid: outcome.result.pid,
+            rssMiB: outcome.result.rssMiB,
+            durationMs: outcome.durationMs,
+            terminationConfirmed: outcome.terminationConfirmed
+        });
+        const collision = outcome.result.collisionProofs.find((proof) => proof.status === "collision");
+        const unresolvedCollision = outcome.result.collisionProofs.find((proof) => proof.status === "unresolved");
+        if (collision || unresolvedCollision) {
+            return incomplete(collision ? "SEMANTIC_RENAME_TARGET_COLLISION" : "SEMANTIC_RENAME_OWNER_DIVERGENCE", (collision ?? unresolvedCollision).error ?? `Exact owner ${configFilePath} could not prove the renamed bindings.`, root, sourceFile, summary, startedAt, snapshotHash, workerEvidence, collision?.blocker ? [collision.blocker] : []);
+        }
+        const commonJsBlocker = outcome.result.commonJsBlockers[0];
+        if (commonJsBlocker) {
+            return incomplete("SEMANTIC_RENAME_COMMONJS_REFERENCE_UNPROVEN", `A raw CommonJS reference could not be proven safe in ${commonJsBlocker.fileName}.`, root, sourceFile, summary, startedAt, snapshotHash, workerEvidence, [commonJsBlocker]);
+        }
+        if (!outcome.terminationConfirmed || !outcome.result.ok || !outcome.result.containsSource ||
+            outcome.result.intents.length !== intents.intents.length) {
+            return incomplete("SEMANTIC_RENAME_OWNER_PROOF_FAILED", outcome.result.error ?? `Exact owner ${configFilePath} could not prove every rename intent.`, root, sourceFile, summary, startedAt, snapshotHash, workerEvidence);
+        }
+        results.push(outcome.result);
+    }
+    const merged = mergeConfigEvidence(intents.intents, results, stableAliases, discovery.fileOwners);
+    if (!merged.ok) {
+        return incomplete(merged.code, merged.error, root, sourceFile, summary, startedAt, snapshotHash, workerEvidence);
+    }
+    if (!verifyStarProofs(starBoundaries.boundaries, discovery, results)) {
+        return incomplete("SEMANTIC_RENAME_STAR_PROOF_FAILED", "An exact export-star owner did not prove the requested symbol projection.", root, sourceFile, summary, startedAt, snapshotHash, workerEvidence);
+    }
+    const edits = buildCombinedEdits(merged.intents);
+    if (!edits.ok) {
+        return incomplete(edits.code, edits.error, root, sourceFile, summary, startedAt, snapshotHash, workerEvidence);
+    }
+    if (!verifyBeforeHashes(results, edits.edits.map((item) => item.fileName))) {
+        return incomplete("SEMANTIC_RENAME_EDIT_SNAPSHOT_CHANGED", "A config or edited file changed during planning.", root, sourceFile, summary, startedAt, snapshotHash, workerEvidence);
+    }
+    let finalFingerprint;
+    try {
+        finalFingerprint = fingerprint(root);
+    }
+    catch (error) {
+        return incomplete("SEMANTIC_RENAME_SNAPSHOT_UNREADABLE", errorMessage(error), root, sourceFile, summary, startedAt, snapshotHash, workerEvidence);
+    }
+    if (finalFingerprint !== discovery.workspaceFingerprint || hashFiles(evidenceFiles) !== snapshotHash) {
+        return incomplete("SEMANTIC_RENAME_SNAPSHOT_CHANGED", "Workspace files, configs, packages, or candidate consumers changed during planning.", root, sourceFile, summary, startedAt, snapshotHash, workerEvidence);
+    }
+    return {
+        complete: true,
+        code: "SEMANTIC_RENAME_PLAN_COMPLETE",
+        workspaceRoot: root,
+        sourceFile,
+        intents: merged.intents,
+        edits: edits.edits,
+        blockers: [],
+        discovery: summary,
+        configWorkers: workerEvidence,
+        snapshotHash,
+        totalMs: Date.now() - startedAt
+    };
+}
+function buildIntents(sourceFile, sourceText, rawIntents) {
+    if (rawIntents.length === 0)
+        return { ok: false, code: "SEMANTIC_RENAME_INTENTS_REQUIRED", error: "At least one rename intent is required." };
+    const oldNames = rawIntents.map((item) => item.oldName);
+    const newNames = rawIntents.map((item) => item.newName);
+    if (new Set(oldNames).size !== rawIntents.length || new Set(newNames).size !== rawIntents.length ||
+        oldNames.some((name) => newNames.includes(name))) {
+        return { ok: false, code: "SEMANTIC_RENAME_INTENT_CONFLICT", error: "Rename intent names must be unique and non-cyclic." };
+    }
+    if (rawIntents.some((item) => !isValidIdentifierName(item.newName))) {
+        return { ok: false, code: "SEMANTIC_RENAME_NAME_INVALID", error: "Every rename target must be a TypeScript identifier." };
+    }
+    const source = typescript_1.default.createSourceFile(sourceFile, sourceText, typescript_1.default.ScriptTarget.Latest, true);
+    const declarations = collectTopLevelDeclarations(source);
+    const intents = [];
+    for (const [index, item] of rawIntents.entries()) {
+        const candidates = declarations.get(item.oldName) ?? [];
+        const position = selectDeclarationPosition(candidates);
+        if (position === null) {
+            return {
+                ok: false,
+                code: candidates.length === 0 ? "SEMANTIC_RENAME_SYMBOL_NOT_FOUND" : "SEMANTIC_RENAME_SYMBOL_AMBIGUOUS",
+                error: `Expected one top-level declaration or one function overload group for ${item.oldName}, found ${candidates.length}.`
+            };
+        }
+        intents.push({ id: item.id ?? `rename-${index + 1}`, oldName: item.oldName, newName: item.newName, position });
+    }
+    return { ok: true, intents };
+}
+function collectTopLevelDeclarations(source) {
+    const result = new Map();
+    const add = (name, kind, hasBody = false) => {
+        const values = result.get(name.text) ?? [];
+        values.push({ position: name.getStart(source), kind, hasBody });
+        result.set(name.text, values);
+    };
+    for (const statement of source.statements) {
+        if (typescript_1.default.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (typescript_1.default.isIdentifier(declaration.name))
+                    add(declaration.name, "other");
+            }
+            continue;
+        }
+        if (typescript_1.default.isFunctionDeclaration(statement) && statement.name) {
+            add(statement.name, "function", statement.body !== undefined);
+            continue;
+        }
+        if ((typescript_1.default.isClassDeclaration(statement) || typescript_1.default.isInterfaceDeclaration(statement) || typescript_1.default.isTypeAliasDeclaration(statement) ||
+            typescript_1.default.isEnumDeclaration(statement) || typescript_1.default.isModuleDeclaration(statement)) && statement.name && typescript_1.default.isIdentifier(statement.name)) {
+            add(statement.name, "other");
+        }
+    }
+    return result;
+}
+function selectDeclarationPosition(candidates) {
+    if (candidates.length === 1)
+        return candidates[0].position;
+    if (candidates.length === 0 || candidates.some((candidate) => candidate.kind !== "function"))
+        return null;
+    const implementations = candidates.filter((candidate) => candidate.hasBody);
+    if (implementations.length > 1)
+        return null;
+    return (implementations[0] ?? candidates[0]).position;
+}
+function buildStarBoundaries(edges, intents, sourceFile, sourceText) {
+    const exported = exportedDeclarationNames(sourceFile, sourceText);
+    const boundaries = [];
+    for (const edge of edges) {
+        if (edge.kind !== "exportStar")
+            continue;
+        const typeOnly = readExportStarTypeOnly(edge);
+        if (typeOnly === null) {
+            return { ok: false, code: "SEMANTIC_RENAME_STAR_SNAPSHOT_INVALID", error: `Export-star syntax changed in ${edge.fromFile}.` };
+        }
+        for (const intent of intents) {
+            if (!exported.has(intent.oldName))
+                continue;
+            boundaries.push({
+                id: `${intent.id}:${pathKey(edge.fromFile)}:${edge.specifierStart}`,
+                intentId: intent.id,
+                file: path.normalize(edge.fromFile),
+                targetFile: path.normalize(edge.targetFile),
+                start: edge.specifierStart,
+                oldName: intent.oldName,
+                newName: intent.newName,
+                typeOnly
+            });
+        }
+    }
+    return { ok: true, boundaries };
+}
+function exportedDeclarationNames(sourceFile, sourceText) {
+    const source = typescript_1.default.createSourceFile(sourceFile, sourceText, typescript_1.default.ScriptTarget.Latest, true);
+    const result = new Set();
+    for (const statement of source.statements) {
+        const modifiers = typescript_1.default.canHaveModifiers(statement) ? typescript_1.default.getModifiers(statement) ?? [] : [];
+        const exported = modifiers.some((modifier) => modifier.kind === typescript_1.default.SyntaxKind.ExportKeyword);
+        const declarationName = readTopLevelDeclarationName(statement);
+        if (exported && declarationName)
+            result.add(declarationName);
+        if (typescript_1.default.isVariableStatement(statement) && exported) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (typescript_1.default.isIdentifier(declaration.name))
+                    result.add(declaration.name.text);
+            }
+        }
+        if (typescript_1.default.isExportDeclaration(statement) && !statement.moduleSpecifier && statement.exportClause && typescript_1.default.isNamedExports(statement.exportClause)) {
+            for (const element of statement.exportClause.elements)
+                result.add(element.name.text);
+        }
+    }
+    return result;
+}
+function readExportStarTypeOnly(edge) {
+    try {
+        const text = fs.readFileSync(edge.fromFile, "utf8");
+        const source = typescript_1.default.createSourceFile(edge.fromFile, text, typescript_1.default.ScriptTarget.Latest, true);
+        const statement = source.statements.find((item) => typescript_1.default.isExportDeclaration(item) && !item.exportClause && item.moduleSpecifier !== undefined &&
+            typescript_1.default.isStringLiteralLike(item.moduleSpecifier) && item.moduleSpecifier.getStart(source) + 1 === edge.specifierStart);
+        return statement?.isTypeOnly ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function collectStableAliasIntentIds(edges, intents, sourceFile, sourceText) {
+    const stable = new Set();
+    const source = typescript_1.default.createSourceFile(sourceFile, sourceText, typescript_1.default.ScriptTarget.Latest, true);
+    for (const statement of source.statements) {
+        if (!typescript_1.default.isExportDeclaration(statement) || statement.moduleSpecifier || !statement.exportClause || !typescript_1.default.isNamedExports(statement.exportClause))
+            continue;
+        for (const intent of intents) {
+            if (statement.exportClause.elements.some((element) => (element.propertyName?.text ?? element.name.text) === intent.oldName && element.name.text !== intent.oldName))
+                stable.add(intent.id);
+        }
+    }
+    for (const edge of edges) {
+        if (edge.kind !== "reexport")
+            continue;
+        try {
+            const text = fs.readFileSync(edge.fromFile, "utf8");
+            const source = typescript_1.default.createSourceFile(edge.fromFile, text, typescript_1.default.ScriptTarget.Latest, true);
+            const statement = source.statements.find((item) => typescript_1.default.isExportDeclaration(item) && item.moduleSpecifier !== undefined && typescript_1.default.isStringLiteralLike(item.moduleSpecifier) &&
+                item.moduleSpecifier.getStart(source) + 1 === edge.specifierStart);
+            if (!statement?.exportClause || !typescript_1.default.isNamedExports(statement.exportClause))
+                continue;
+            for (const intent of intents) {
+                if (statement.exportClause.elements.some((element) => (element.propertyName?.text ?? element.name.text) === intent.oldName && element.name.text !== intent.oldName))
+                    stable.add(intent.id);
+            }
+        }
+        catch { /* discovery/fingerprint validation owns unreadable files */ }
+    }
+    return stable;
+}
+function mergeConfigEvidence(intents, results, stableAliasIntentIds, fileOwners) {
+    const resultMap = new Map(results.map((result) => [pathKey(result.configFilePath), result]));
+    const ownerMap = new Map(fileOwners.map((item) => [pathKey(item.file), item.ownerConfigs.map(pathKey)]));
+    const output = [];
+    for (const intent of intents) {
+        const locations = [];
+        const observations = new Map();
+        for (const result of results) {
+            const evidence = result.intents.find((item) => item.id === intent.id);
+            if (!evidence?.canRename)
+                return { ok: false, code: "SEMANTIC_RENAME_OWNER_PROOF_FAILED", error: `${result.configFilePath} could not rename ${intent.oldName}.` };
+            const preserve = new Set(evidence.preserveLocations.map(locationSpanKey));
+            const projectLocations = stableAliasIntentIds.has(intent.id)
+                ? evidence.completeLocations.filter((location) => preserve.has(locationSpanKey(location)))
+                : evidence.completeLocations;
+            locations.push(...projectLocations);
+            observations.set(pathKey(result.configFilePath), new Set(projectLocations.map(locationSpanKey)));
+        }
+        const merged = mergeLocations(locations);
+        if (!merged.ok)
+            return merged;
+        for (const location of merged.locations) {
+            const owners = ownerMap.get(pathKey(location.fileName));
+            if (!owners || owners.length === 0) {
+                return { ok: false, code: "SEMANTIC_RENAME_OWNER_DIVERGENCE", error: `No exact owner evidence exists for ${location.fileName}.` };
+            }
+            for (const owner of owners) {
+                const observation = observations.get(owner);
+                if (!resultMap.has(owner) || !observation?.has(locationSpanKey(location))) {
+                    return {
+                        ok: false,
+                        code: "SEMANTIC_RENAME_OWNER_DIVERGENCE",
+                        error: `${owner} disagrees on ${location.fileName}:${location.start}:${location.length}.`
+                    };
+                }
+            }
+        }
+        output.push({ id: intent.id, oldName: intent.oldName, newName: intent.newName, locations: merged.locations });
+    }
+    if (hasInterIntentOverlap(output)) {
+        return { ok: false, code: "SEMANTIC_RENAME_INTENT_OVERLAP", error: "Rename intents produce overlapping text spans." };
+    }
+    return { ok: true, intents: output };
+}
+function mergeLocations(locations) {
+    const merged = [];
+    const replacements = new Map();
+    const seen = new Set();
+    for (const location of locations) {
+        const normalized = { ...location, fileName: path.normalize(location.fileName) };
+        const span = locationSpanKey(normalized);
+        const shape = `${normalized.prefixText ?? ""}\0${normalized.suffixText ?? ""}`;
+        const previous = replacements.get(span);
+        if (previous !== undefined && previous !== shape) {
+            return { ok: false, code: "SEMANTIC_RENAME_LOCATION_CONFLICT", error: `Conflicting replacement shape at ${span}.` };
+        }
+        replacements.set(span, shape);
+        const exact = `${span}:${shape}`;
+        if (!seen.has(exact)) {
+            seen.add(exact);
+            merged.push(normalized);
+        }
+    }
+    return { ok: true, locations: merged.sort(compareLocations) };
+}
+function buildCombinedEdits(intents) {
+    const byFile = new Map();
+    for (const intent of intents) {
+        for (const location of intent.locations) {
+            const text = fs.readFileSync(location.fileName, "utf8");
+            if (location.start < 0 || location.length <= 0 || location.start + location.length > text.length) {
+                return { ok: false, code: "SEMANTIC_RENAME_EDIT_SPAN_INVALID", error: `Invalid rename span in ${location.fileName}.` };
+            }
+            const current = byFile.get(path.normalize(location.fileName)) ?? [];
+            current.push({
+                span: { start: location.start, length: location.length },
+                newText: (0, semantic_rename_locations_1.semanticRenameReplacement)(location, intent.newName)
+            });
+            byFile.set(path.normalize(location.fileName), current);
+        }
+    }
+    const edits = [];
+    for (const [fileName, textChanges] of byFile) {
+        const ordered = [...textChanges].sort((left, right) => left.span.start - right.span.start);
+        for (let index = 1; index < ordered.length; index += 1) {
+            const previous = ordered[index - 1];
+            const current = ordered[index];
+            if (previous.span.start + previous.span.length > current.span.start) {
+                return { ok: false, code: "SEMANTIC_RENAME_EDIT_OVERLAP", error: `Overlapping combined edits in ${fileName}.` };
+            }
+        }
+        const expectedBytes = fs.readFileSync(fileName);
+        const expectedText = expectedBytes.toString("utf8");
+        edits.push({
+            fileName,
+            expectedText,
+            expectedHash: crypto.createHash("sha256").update(expectedBytes).digest("hex"),
+            textChanges: ordered
+        });
+    }
+    return { ok: true, edits: edits.sort((left, right) => left.fileName.localeCompare(right.fileName)) };
+}
+function verifyStarProofs(boundaries, discovery, results) {
+    const owners = new Map(discovery.fileOwners.map((item) => [pathKey(item.file), item.ownerConfigs.map(pathKey)]));
+    const resultMap = new Map(results.map((result) => [pathKey(result.configFilePath), result]));
+    return boundaries.every((boundary) => {
+        const configs = owners.get(pathKey(boundary.file));
+        return configs && configs.length > 0 && configs.every((config) => resultMap.get(config)?.starProofs.some((proof) => proof.id === boundary.id && proof.status === "proven") === true);
+    });
+}
+function verifyBeforeHashes(results, files) {
+    if (results.some((result) => !result.configHash || result.configHash !== hashFile(result.configFilePath)))
+        return false;
+    for (const file of files) {
+        const hashes = new Set();
+        for (const result of results) {
+            const entry = Object.entries(result.beforeHashes).find(([candidate]) => samePath(candidate, file));
+            if (entry)
+                hashes.add(entry[1]);
+        }
+        if (hashes.size !== 1 || !hashes.has(hashFile(file)))
+            return false;
+    }
+    return true;
+}
+function hasInterIntentOverlap(intents) {
+    const byFile = new Map();
+    for (const intent of intents) {
+        for (const location of intent.locations) {
+            const list = byFile.get(pathKey(location.fileName)) ?? [];
+            list.push({ id: intent.id, start: location.start, end: location.start + location.length });
+            byFile.set(pathKey(location.fileName), list);
+        }
+    }
+    return [...byFile.values()].some((items) => items.some((left, index) => items.slice(index + 1).some((right) => left.id !== right.id && left.start < right.end && right.start < left.end)));
+}
+function incomplete(code, error, root, sourceFile, discovery, startedAt, snapshotHash = "", configWorkers = [], blockers = []) {
+    return {
+        complete: false,
+        code,
+        error,
+        workspaceRoot: root,
+        sourceFile,
+        intents: [],
+        edits: [],
+        blockers,
+        discovery,
+        configWorkers,
+        snapshotHash,
+        totalMs: Date.now() - startedAt
+    };
+}
+function discoverySummary(discovery) {
+    return discovery ? {
+        filesScanned: discovery.filesScanned,
+        bytesScanned: discovery.bytesScanned,
+        consumerCount: discovery.consumerFiles.length,
+        edgeCount: discovery.edges.length,
+        ownerConfigCount: discovery.ownerConfigs.length,
+        workspaceFingerprint: discovery.workspaceFingerprint
+    } : { filesScanned: 0, bytesScanned: 0, consumerCount: 0, edgeCount: 0, ownerConfigCount: 0, workspaceFingerprint: "" };
+}
+function isValidIdentifierName(value) {
+    const source = typescript_1.default.createSourceFile("identifier.ts", `const ${value} = 1;`, typescript_1.default.ScriptTarget.Latest, true);
+    const parseDiagnostics = source.parseDiagnostics ?? [];
+    const statement = source.statements[0];
+    return parseDiagnostics.length === 0 && statement !== undefined && typescript_1.default.isVariableStatement(statement) &&
+        statement.declarationList.declarations.length === 1 &&
+        typescript_1.default.isIdentifier(statement.declarationList.declarations[0].name) &&
+        statement.declarationList.declarations[0].name.text === value;
+}
+function readTopLevelDeclarationName(statement) {
+    if ((typescript_1.default.isFunctionDeclaration(statement) || typescript_1.default.isClassDeclaration(statement) || typescript_1.default.isInterfaceDeclaration(statement) ||
+        typescript_1.default.isTypeAliasDeclaration(statement) || typescript_1.default.isEnumDeclaration(statement) || typescript_1.default.isModuleDeclaration(statement)) &&
+        statement.name && typescript_1.default.isIdentifier(statement.name))
+        return statement.name.text;
+    return null;
+}
+function compareLocations(left, right) {
+    return left.fileName.localeCompare(right.fileName) || left.start - right.start || left.length - right.length;
+}
+function locationSpanKey(location) {
+    return `${pathKey(location.fileName)}:${location.start}:${location.length}`;
+}
+function hashFiles(files) {
+    const hash = crypto.createHash("sha256");
+    for (const file of uniquePaths(files).sort()) {
+        hash.update(path.normalize(file)).update("\0").update(fs.readFileSync(file)).update("\0");
+    }
+    return hash.digest("hex");
+}
+function hashFile(file) {
+    return crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+}
+function uniquePaths(files) {
+    const unique = new Map();
+    for (const file of files)
+        unique.set(pathKey(file), path.normalize(file));
+    return [...unique.values()];
+}
+function samePath(left, right) { return pathKey(left) === pathKey(right); }
+function pathKey(file) {
+    const normalized = path.normalize(file);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function isInside(root, file) {
+    const relative = path.relative(root, file);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function errorMessage(error) { return error instanceof Error ? error.message : String(error); }
+function readErrorCode(error) {
+    return error && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : null;
+}