@automaton-labs/aib 0.0.6 → 0.0.8

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

@@ -0,0 +1,1553 @@
+"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.planStandaloneSemanticMove = planStandaloneSemanticMove;
+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_move_plan_hash_1 = require("./semantic-move-plan-hash");
+const package_manifest_impact_1 = require("./package-manifest-impact");
+const semantic_move_process_1 = require("./semantic-move-process");
+const semantic_move_declarations_1 = require("./semantic-move-declarations");
+const import_rules_1 = require("../config/import-rules");
+const import_specifier_policy_1 = require("../commands/import-specifier-policy");
+const mutation_comments_1 = require("../config/mutation-comments");
+const typescript_preferences_1 = require("../config/typescript-preferences");
+const semantic_move_policy_1 = require("./semantic-move-policy");
+const semantic_program_roots_1 = require("./semantic-program-roots");
+const semantic_move_owner_authority_1 = require("./semantic-move-owner-authority");
+const semantic_move_owner_candidates_1 = require("./semantic-move-owner-candidates");
+const DEFAULT_DEADLINE_MS = 120_000;
+const MAX_CONFIGS = 32;
+async function planStandaloneSemanticMove(input, dependencies = {
+    discover: file_mutation_discovery_1.discoverFileMutationConsumers,
+    fingerprint: file_mutation_discovery_1.computeFileMutationWorkspaceFingerprint,
+    runConfig: semantic_move_process_1.runSemanticMoveConfigWorker
+}) {
+    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 targetFile = path.resolve(root, input.targetFile);
+    const workspacePreferences = input.importRules?.length
+        ? undefined
+        : (0, typescript_preferences_1.readWorkspaceTypeScriptPreferences)(root);
+    const emptyDiscovery = discoverySummary(null);
+    if (!isInside(root, sourceFile) || !isRegularFile(sourceFile)) {
+        return incomplete("SEMANTIC_MOVE_SOURCE_INVALID", "Move source is missing or outside the workspace.", root, sourceFile, targetFile, emptyDiscovery, startedAt);
+    }
+    if (!isInside(root, targetFile) || samePath(sourceFile, targetFile) || (fs.existsSync(targetFile) && !isRegularFile(targetFile))) {
+        return incomplete("SEMANTIC_MOVE_TARGET_INVALID", "Move target must be a regular file or an absent file inside the workspace.", root, sourceFile, targetFile, emptyDiscovery, startedAt);
+    }
+    let sourceBytes;
+    try {
+        sourceBytes = fs.readFileSync(sourceFile);
+    }
+    catch (error) {
+        return incomplete("SEMANTIC_MOVE_SOURCE_UNREADABLE", errorMessage(error), root, sourceFile, targetFile, emptyDiscovery, startedAt);
+    }
+    const sourceText = sourceBytes.toString("utf8");
+    const targetExisted = fs.existsSync(targetFile);
+    let targetBytes;
+    try {
+        targetBytes = targetExisted ? fs.readFileSync(targetFile) : Buffer.alloc(0);
+    }
+    catch (error) {
+        return incomplete("SEMANTIC_MOVE_TARGET_UNREADABLE", errorMessage(error), root, sourceFile, targetFile, emptyDiscovery, startedAt);
+    }
+    const targetText = targetBytes.toString("utf8");
+    const selection = buildSelection(sourceFile, sourceText, input.entities);
+    if (!selection.ok) {
+        return {
+            ...incomplete(selection.code, selection.error, root, sourceFile, targetFile, emptyDiscovery, startedAt),
+            ...(selection.ambiguities ? { ambiguities: selection.ambiguities } : {}),
+            ...(selection.contiguousEntityGroups ? { contiguousEntityGroups: selection.contiguousEntityGroups } : {})
+        };
+    }
+    const targetDeclarations = (0, semantic_move_declarations_1.collectSemanticMoveDeclarations)(targetFile, targetText);
+    const duplicateTarget = selection.entities.find((entity) => targetDeclarations.some((candidate) => candidate.name === entity.name && (!entity.kind || candidate.kind === entity.kind)));
+    if (duplicateTarget) {
+        return incomplete("TARGET_SYMBOL_ALREADY_EXISTS", `Target already declares moved symbol: ${duplicateTarget.name}`, root, sourceFile, targetFile, emptyDiscovery, startedAt);
+    }
+    const mutationComments = input.mutationComments ?? mutation_comments_1.DEFAULT_MUTATION_COMMENTS_POLICY;
+    const topFileHeader = (0, semantic_move_policy_1.findDetachedTopFileHeader)(sourceFile, sourceText, selection.firstSelectedName);
+    if (topFileHeader && mutationComments.topFileHeader === "fail") {
+        return incomplete("TS_MOVE_TO_FILE_TOP_FILE_HEADER_BLOCKED", "Detached top-of-file header policy is configured to fail instead of preserving the header in source.", root, sourceFile, targetFile, emptyDiscovery, startedAt);
+    }
+    const preservedHeader = topFileHeader && mutationComments.topFileHeader === "preserveInSource" ? topFileHeader : null;
+    const workerSourceText = preservedHeader ? sourceText.slice(preservedHeader.end) : sourceText;
+    const workerSelection = preservedHeader ? buildSelection(sourceFile, workerSourceText, input.entities) : selection;
+    if (!workerSelection.ok) {
+        return {
+            ...incomplete(workerSelection.code, workerSelection.error, root, sourceFile, targetFile, emptyDiscovery, startedAt),
+            ...(workerSelection.ambiguities ? { ambiguities: workerSelection.ambiguities } : {})
+        };
+    }
+    let discovery;
+    const discoveryStartedAt = input.metrics?.start();
+    try {
+        discovery = input.discovery ?? discover({ workspaceRoot: root, sourceFiles: [sourceFile] });
+    }
+    catch (error) {
+        if (discoveryStartedAt !== undefined)
+            input.metrics?.end("planner.discovery", discoveryStartedAt);
+        return incomplete("SEMANTIC_MOVE_DISCOVERY_FAILED", errorMessage(error), root, sourceFile, targetFile, emptyDiscovery, startedAt);
+    }
+    if (discoveryStartedAt !== undefined)
+        input.metrics?.end("planner.discovery", discoveryStartedAt);
+    const summary = discoverySummary(discovery);
+    if (!discovery.complete || !discovery.sourceFiles.some((file) => samePath(file, sourceFile))) {
+        return incomplete("SEMANTIC_MOVE_DISCOVERY_INCOMPLETE", discovery.uncertainties.map((item) => `${item.kind}:${item.file}:${item.moduleSpecifier}`).join("; ") || "Neutral module discovery is incomplete.", root, sourceFile, targetFile, summary, startedAt);
+    }
+    if (discovery.ownerConfigs.length === 0 || discovery.ownerConfigs.length > MAX_CONFIGS) {
+        return incomplete("SEMANTIC_MOVE_OWNER_SET_UNSUPPORTED", `Expected 1-${MAX_CONFIGS} exact owner configs, found ${discovery.ownerConfigs.length}.`, root, sourceFile, targetFile, summary, startedAt);
+    }
+    const sourceOwners = ownersForFile(discovery, sourceFile);
+    if (sourceOwners.length === 0) {
+        return incomplete("SEMANTIC_MOVE_SOURCE_OWNER_MISSING", "Neutral discovery did not provide an exact source owner.", root, sourceFile, targetFile, summary, startedAt);
+    }
+    const snapshotStartedAt = input.metrics?.start();
+    let initialFingerprint;
+    try {
+        initialFingerprint = fingerprint(root);
+    }
+    catch (error) {
+        if (snapshotStartedAt !== undefined)
+            input.metrics?.end("planner.snapshot", snapshotStartedAt);
+        return incomplete("SEMANTIC_MOVE_SNAPSHOT_UNREADABLE", errorMessage(error), root, sourceFile, targetFile, summary, startedAt);
+    }
+    if (initialFingerprint !== discovery.workspaceFingerprint) {
+        if (snapshotStartedAt !== undefined)
+            input.metrics?.end("planner.snapshot", snapshotStartedAt);
+        return incomplete("SEMANTIC_MOVE_DISCOVERY_STALE", "Workspace changed after neutral discovery.", root, sourceFile, targetFile, summary, startedAt);
+    }
+    let acceptedSourceBytes;
+    try {
+        acceptedSourceBytes = fs.readFileSync(sourceFile);
+    }
+    catch (error) {
+        if (snapshotStartedAt !== undefined)
+            input.metrics?.end("planner.snapshot", snapshotStartedAt);
+        return incomplete("SEMANTIC_MOVE_SOURCE_SNAPSHOT_CHANGED", errorMessage(error), root, sourceFile, targetFile, summary, startedAt);
+    }
+    if (!acceptedSourceBytes.equals(sourceBytes)) {
+        if (snapshotStartedAt !== undefined)
+            input.metrics?.end("planner.snapshot", snapshotStartedAt);
+        return incomplete("SEMANTIC_MOVE_SOURCE_SNAPSHOT_CHANGED", "Move source changed while neutral discovery was being computed.", root, sourceFile, targetFile, summary, startedAt);
+    }
+    const evidenceFiles = uniquePaths([sourceFile, ...(targetExisted ? [targetFile] : []), ...discovery.consumerFiles]);
+    const snapshotHash = hashFiles(evidenceFiles);
+    if (snapshotStartedAt !== undefined)
+        input.metrics?.end("planner.snapshot", snapshotStartedAt);
+    const workerPath = input.testing?.configWorkerPath ?? path.join(__dirname, "semantic-move-config-worker-child.js");
+    const results = [];
+    const workerEvidence = [];
+    const workersStartedAt = input.metrics?.start();
+    for (const configFilePath of discovery.ownerConfigs) {
+        const exportStarCandidates = discovery.edges
+            .filter((edge) => edge.kind === "exportStar" && samePath(edge.targetFile, sourceFile) &&
+            !samePath(edge.fromFile, sourceFile) && ownersForFile(discovery, edge.fromFile).some((owner) => samePath(owner, configFilePath)))
+            .map((edge) => ({
+            barrelFile: edge.fromFile,
+            moduleSpecifier: edge.moduleSpecifier,
+            specifierStart: edge.specifierStart,
+            entities: selection.entities.map((entity) => ({
+                name: entity.name,
+                ...(entity.kind ? { kind: entity.kind } : {})
+            }))
+        }));
+        const request = {
+            type: "semanticMoveConfig",
+            id: crypto.randomUUID(),
+            workspaceRoot: root,
+            configFilePath: path.normalize(configFilePath),
+            sourceFile,
+            sourceText: workerSourceText,
+            targetFile,
+            targetText,
+            selection: workerSelection.selection,
+            preferences: (0, semantic_move_policy_1.semanticMovePreferences)(targetFile, input.importRules ?? [], input.preferences, workspacePreferences),
+            programRootFiles: (0, semantic_program_roots_1.focusedSemanticProgramRootFiles)({
+                discovery,
+                configFilePath,
+                requiredFiles: [sourceFile, targetFile]
+            }),
+            ...(exportStarCandidates.length > 0 ? { exportStarCandidates } : {}),
+            ...(import_rules_1.SEMANTIC_MOVE_UNUSED_IMPORT_CLEANUP_ENABLED && input.importRules?.some((rule) => rule.unusedImports === "remove")
+                ? { unusedImportCleanupRules: [...input.importRules] }
+                : {}),
+            ...(input.metrics ? { metricsEnabled: true } : {})
+        };
+        let outcome;
+        try {
+            outcome = await dependencies.runConfig({
+                modulePath: workerPath,
+                request,
+                deadlineMs: input.deadlineMs ?? DEFAULT_DEADLINE_MS
+            });
+        }
+        catch (error) {
+            if (workersStartedAt !== undefined)
+                input.metrics?.end("planner.ownerWorkers", workersStartedAt);
+            return incomplete(readErrorCode(error) ?? "SEMANTIC_MOVE_CONFIG_WORKER_FAILED", errorMessage(error), root, sourceFile, targetFile, summary, startedAt, snapshotHash, workerEvidence);
+        }
+        workerEvidence.push({
+            configFilePath: outcome.result.configFilePath,
+            pid: outcome.result.pid,
+            rssMiB: outcome.result.rssMiB,
+            durationMs: outcome.durationMs,
+            terminationConfirmed: outcome.terminationConfirmed,
+            fileEditCount: outcome.result.edits.length,
+            textChangeCount: outcome.result.edits.reduce((sum, edit) => sum + edit.textChanges.length, 0)
+        });
+        input.metrics?.observeWorker({
+            ...(outcome.metrics ?? {}),
+            ...(outcome.result.metrics ?? {})
+        });
+        const acceptedResult = rebasePreservedHeaderResult(outcome.result, sourceFile, sourceText, workerSourceText, preservedHeader);
+        dependencies.observeConfigResult?.(acceptedResult);
+        if (!outcome.terminationConfirmed || !outcome.result.ok || !outcome.result.containsSource) {
+            if (workersStartedAt !== undefined)
+                input.metrics?.end("planner.ownerWorkers", workersStartedAt);
+            return incomplete(outcome.result.failureKind === "provider-unsupported"
+                ? "SEMANTIC_MOVE_PROVIDER_UNSUPPORTED"
+                : outcome.result.failureKind === "changes-overlap"
+                    ? "SEMANTIC_MOVE_CHANGES_OVERLAP"
+                    : outcome.result.failureKind === "provider-failed"
+                        ? "SEMANTIC_MOVE_PROVIDER_FAILED"
+                        : "SEMANTIC_MOVE_OWNER_PROOF_FAILED", outcome.result.error ?? `Exact owner projection ${configFilePath} did not provide a move plan.`, root, sourceFile, targetFile, summary, startedAt, snapshotHash, workerEvidence);
+        }
+        results.push(acceptedResult);
+    }
+    if (workersStartedAt !== undefined)
+        input.metrics?.end("planner.ownerWorkers", workersStartedAt);
+    const mergeStartedAt = input.metrics?.start();
+    const moduleSpecifierResolver = (0, semantic_move_owner_candidates_1.createSemanticMoveModuleSpecifierResolver)();
+    const canonicalModuleResolver = (0, semantic_move_owner_candidates_1.createSemanticMoveCanonicalModuleResolver)();
+    const merged = mergeOwnerEvidence({
+        root,
+        sourceFile,
+        targetFile,
+        sourceOwners,
+        targetExisted,
+        discovery,
+        results,
+        importRules: input.importRules ?? [],
+        moduleSpecifierResolver,
+        canonicalModuleResolver,
+        ...(workspacePreferences ? { workspacePreferences } : {}),
+        ...(input.metrics ? { metrics: input.metrics } : {})
+    });
+    if (mergeStartedAt !== undefined)
+        input.metrics?.end("planner.merge", mergeStartedAt);
+    if (!merged.ok) {
+        return incomplete(merged.code, merged.error, root, sourceFile, targetFile, summary, startedAt, snapshotHash, workerEvidence, merged.divergence ? [merged.divergence] : []);
+    }
+    const validationStartedAt = input.metrics?.start();
+    let validationEnded = false;
+    const endValidation = () => {
+        if (validationEnded || validationStartedAt === undefined)
+            return;
+        validationEnded = true;
+        input.metrics?.end("planner.validation", validationStartedAt);
+    };
+    const policyEdits = (0, semantic_move_policy_1.applySemanticMoveImportPolicies)({
+        workspaceRoot: root,
+        edits: merged.edits,
+        importRules: input.importRules ?? [],
+        ...(workspacePreferences ? { workspacePreferences } : {}),
+        acceptsModuleSpecifier: ({ fileName, specifier, targetFile: resolvedTarget }) => {
+            const ownerConfigs = merged.moduleSpecifierOwners.get(pathKey(fileName));
+            return Boolean(ownerConfigs?.length && moduleSpecifierResolver({
+                specifier,
+                containingFile: fileName,
+                targetFile: resolvedTarget,
+                ownerConfigs
+            }));
+        },
+        resolveVirtualModuleTarget: ({ fileName, specifier }) => {
+            const ownerConfigs = merged.moduleSpecifierOwners.get(pathKey(fileName));
+            return ownerConfigs?.length && moduleSpecifierResolver({
+                specifier,
+                containingFile: fileName,
+                targetFile,
+                ownerConfigs
+            })
+                ? targetFile
+                : null;
+        }
+    });
+    const semanticEdits = applySafeDynamicImportMoveEdits({
+        workspaceRoot: root,
+        sourceFile,
+        targetFile,
+        entities: selection.entities,
+        discovery,
+        edits: policyEdits,
+        importRules: input.importRules ?? [],
+        ...(workspacePreferences ? { workspacePreferences } : {}),
+        moduleSpecifierResolver
+    });
+    const namedReexportEdits = applySafeNamedReexportMoveEdits({
+        workspaceRoot: root,
+        sourceFile,
+        targetFile,
+        entities: selection.entities,
+        discovery,
+        edits: semanticEdits,
+        importRules: input.importRules ?? [],
+        ...(workspacePreferences ? { workspacePreferences } : {}),
+        moduleSpecifierResolver
+    });
+    const structure = verifyMoveStructure(sourceFile, targetFile, sourceText, selection.entities, namedReexportEdits);
+    if (!structure.ok) {
+        endValidation();
+        return incomplete(structure.code, structure.error, root, sourceFile, targetFile, summary, startedAt, snapshotHash, workerEvidence);
+    }
+    const exportStarCompletion = applySafeExportStarMoveEdits({
+        workspaceRoot: root,
+        sourceFile,
+        targetFile,
+        entities: selection.entities,
+        discovery,
+        edits: namedReexportEdits,
+        results,
+        importRules: input.importRules ?? [],
+        ...(workspacePreferences ? { workspacePreferences } : {}),
+        moduleSpecifierResolver
+    });
+    const completeEdits = exportStarCompletion.edits;
+    const edgeCoverage = verifyMovedEntityEdgeCoverage(sourceFile, selection.entities, discovery, completeEdits, exportStarCompletion.coveredEdges);
+    if (!edgeCoverage.ok) {
+        endValidation();
+        return incomplete(edgeCoverage.code, edgeCoverage.error, root, sourceFile, targetFile, summary, startedAt, snapshotHash, workerEvidence);
+    }
+    const synthesizedEditFiles = new Set(completeEdits
+        .filter((edit) => !policyEdits.some((candidate) => samePath(candidate.fileName, edit.fileName)))
+        .map((edit) => pathKey(edit.fileName)));
+    if (!verifyBeforeHashes(results, completeEdits, synthesizedEditFiles)) {
+        endValidation();
+        return incomplete("SEMANTIC_MOVE_EDIT_SNAPSHOT_CHANGED", "A config or edited file changed during planning.", root, sourceFile, targetFile, summary, startedAt, snapshotHash, workerEvidence);
+    }
+    let finalFingerprint;
+    try {
+        finalFingerprint = fingerprint(root);
+    }
+    catch (error) {
+        endValidation();
+        return incomplete("SEMANTIC_MOVE_SNAPSHOT_UNREADABLE", errorMessage(error), root, sourceFile, targetFile, summary, startedAt, snapshotHash, workerEvidence);
+    }
+    const finalTargetMatches = fs.existsSync(targetFile) === targetExisted &&
+        (!targetExisted || fs.readFileSync(targetFile).equals(targetBytes));
+    if (finalFingerprint !== discovery.workspaceFingerprint || hashFiles(evidenceFiles) !== snapshotHash || !finalTargetMatches) {
+        endValidation();
+        return incomplete("SEMANTIC_MOVE_SNAPSHOT_CHANGED", "Workspace files, configs, packages, consumers, or target existence changed during planning.", root, sourceFile, targetFile, summary, startedAt, snapshotHash, workerEvidence);
+    }
+    endValidation();
+    const completePlan = {
+        complete: true,
+        code: "SEMANTIC_MOVE_PLAN_COMPLETE",
+        workspaceRoot: root,
+        sourceFile,
+        targetFile,
+        targetExisted,
+        entities: selection.entities,
+        edits: completeEdits,
+        discovery: summary,
+        configWorkers: workerEvidence,
+        snapshotHash,
+        planHash: "",
+        totalMs: Date.now() - startedAt,
+        packageManifestImpacts: (0, package_manifest_impact_1.collectMutationPackageManifestImpacts)({
+            mutationKind: "declaration-move",
+            sourceFile,
+            targetFile,
+            changedFiles: completeEdits.map((edit) => edit.fileName),
+            packageManifests: discovery.packageManifests
+        })
+    };
+    completePlan.planHash = (0, semantic_move_plan_hash_1.computeSemanticMovePlanHash)(completePlan);
+    return completePlan;
+}
+function buildSelection(sourceFile, sourceText, rawEntities) {
+    if (rawEntities.length === 0)
+        return { ok: false, code: "SEMANTIC_MOVE_ENTITY_REQUIRED", error: "At least one top-level entity is required." };
+    const candidates = (0, semantic_move_declarations_1.collectSemanticMoveDeclarations)(sourceFile, sourceText);
+    const seenCandidates = new Set();
+    const selected = [];
+    const entities = [];
+    const entityStatementRanges = [];
+    for (const [index, item] of rawEntities.entries()) {
+        if (!isValidIdentifierName(item.name)) {
+            return { ok: false, code: "SEMANTIC_MOVE_ENTITY_INVALID", error: `Invalid or duplicate entity: ${item.name}` };
+        }
+        const matches = candidates.filter((candidate) => candidate.name === item.name && (!item.kind || candidate.kind === item.kind));
+        if (matches.length === 0) {
+            return { ok: false, code: "SEMANTIC_MOVE_ENTITY_NOT_FOUND", error: `Top-level entity not found: ${item.kind ? `${item.kind}:` : ""}${item.name}` };
+        }
+        const matchedKinds = [...new Set(matches.map((candidate) => candidate.kind))];
+        if (!item.kind && matchedKinds.length > 1) {
+            return {
+                ok: false,
+                code: "SEMANTIC_MOVE_ENTITY_AMBIGUOUS",
+                error: `Top-level entity matches multiple declaration kinds: ${item.name} (${matchedKinds.join(", ")}). Specify the declaration kind.`,
+                ambiguities: [{ entity: item.name, kinds: matchedKinds }]
+            };
+        }
+        if (matches.some((candidate) => seenCandidates.has(candidateKey(candidate)))) {
+            return { ok: false, code: "SEMANTIC_MOVE_ENTITY_INVALID", error: `Invalid or duplicate entity: ${item.name}` };
+        }
+        const indexes = [...new Set(matches.map((candidate) => candidate.statementIndex))].sort((left, right) => left - right);
+        if (indexes.some((value, candidateIndex) => candidateIndex > 0 && value !== indexes[candidateIndex - 1] + 1)) {
+            return { ok: false, code: "SEMANTIC_MOVE_ENTITY_AMBIGUOUS", error: `Non-contiguous declarations found for: ${item.name}` };
+        }
+        for (const match of matches)
+            seenCandidates.add(candidateKey(match));
+        selected.push(...matches);
+        entityStatementRanges.push({
+            id: item.id ?? item.name,
+            first: indexes[0],
+            last: indexes[indexes.length - 1]
+        });
+        entities.push({
+            id: item.id ?? `entity-${index + 1}`,
+            name: item.name,
+            ...(item.kind ?? (new Set(matches.map((candidate) => candidate.kind)).size === 1 ? matches[0].kind : null)
+                ? { kind: item.kind ?? matches[0].kind }
+                : {}),
+            declarationStarts: matches.map((candidate) => candidate.nameStart)
+        });
+    }
+    const statementIndexes = [...new Set(selected.map((candidate) => candidate.statementIndex))].sort((left, right) => left - right);
+    for (const statementIndex of statementIndexes) {
+        const unrequested = candidates.find((candidate) => candidate.statementIndex === statementIndex && !seenCandidates.has(candidateKey(candidate)));
+        if (unrequested) {
+            return {
+                ok: false,
+                code: "SEMANTIC_MOVE_DECLARATION_GROUP_INCOMPLETE",
+                error: `Moving this declaration would also move unrequested top-level entity: ${unrequested.name}`
+            };
+        }
+    }
+    if (statementIndexes.some((value, index) => index > 0 && value !== statementIndexes[index - 1] + 1)) {
+        return {
+            ok: false,
+            code: "SEMANTIC_MOVE_ENTITIES_NOT_CONTIGUOUS",
+            error: "Requested top-level entities are not contiguous.",
+            contiguousEntityGroups: groupContiguousEntityRanges(entityStatementRanges)
+        };
+    }
+    const ordered = [...selected].sort((left, right) => left.statementStart - right.statementStart || left.nameStart - right.nameStart);
+    const selection = ordered.length === 1
+        ? { pos: ordered[0].nameStart, end: ordered[0].nameEnd }
+        : { pos: ordered[0].statementStart, end: ordered[ordered.length - 1].statementEnd };
+    return { ok: true, entities, selection, firstSelectedName: ordered[0].name };
+}
+function candidateKey(candidate) {
+    return `${candidate.statementIndex}:${candidate.nameStart}:${candidate.kind}`;
+}
+function rebasePreservedHeaderResult(result, sourceFile, sourceText, workerSourceText, header) {
+    if (!header || !result.ok)
+        return result;
+    return {
+        ...result,
+        edits: result.edits.map((edit) => {
+            if (!samePath(edit.fileName, sourceFile))
+                return edit;
+            const rendered = applyTextChanges(workerSourceText, edit.textChanges);
+            return {
+                ...edit,
+                isNewFile: false,
+                textChanges: [{
+                        span: { start: 0, length: sourceText.length },
+                        newText: `${header.text}${rendered}`
+                    }]
+            };
+        })
+    };
+}
+function mergeOwnerEvidence(input) {
+    const resultMap = new Map(input.results.map((result) => [pathKey(result.configFilePath), result]));
+    const ownerAuthority = (0, semantic_move_owner_authority_1.createSemanticMoveOwnerAuthority)(input.discovery);
+    const observations = new Map();
+    const allowed = new Set(uniquePaths([input.sourceFile, input.targetFile, ...input.discovery.consumerFiles]).map(pathKey));
+    for (const result of input.results) {
+        const config = pathKey(result.configFilePath);
+        const perFile = new Map();
+        for (const rawEdit of result.edits) {
+            const edit = normalizeFileEdit(rawEdit);
+            const file = pathKey(edit.fileName);
+            if (!isInside(input.root, edit.fileName) || !allowed.has(file) || perFile.has(file)) {
+                return { ok: false, code: "SEMANTIC_MOVE_EDIT_SCOPE_INVALID", error: `Unexpected or duplicate edit from ${result.configFilePath}: ${edit.fileName}` };
+            }
+            perFile.set(file, edit);
+            const fileObservations = observations.get(file) ?? new Map();
+            fileObservations.set(config, edit);
+            observations.set(file, fileObservations);
+        }
+    }
+    const requiredFiles = [pathKey(input.sourceFile), pathKey(input.targetFile)];
+    if (requiredFiles.some((file) => !observations.has(file))) {
+        return { ok: false, code: "SEMANTIC_MOVE_REQUIRED_EDIT_MISSING", error: "Move plan did not contain both source and target edits." };
+    }
+    const edits = [];
+    const moduleSpecifierOwners = new Map();
+    for (const [file, fileObservations] of observations) {
+        const firstObservation = fileObservations.values().next().value;
+        if (!firstObservation)
+            continue;
+        const owners = samePath(firstObservation.fileName, input.sourceFile) || samePath(firstObservation.fileName, input.targetFile)
+            ? input.sourceOwners
+            : ownersForFile(input.discovery, firstObservation.fileName);
+        if (owners.length === 0) {
+            return ownerDivergenceFailure({
+                reason: "owner-evidence-missing",
+                fileName: firstObservation.fileName,
+                owners,
+                observations: fileObservations,
+                error: `No exact owner evidence exists for ${firstObservation.fileName}.`
+            });
+        }
+        if (owners.length > 1)
+            input.metrics?.observeDivergence("multiOwnerFiles", firstObservation.fileName);
+        const ownerRoles = new Map(owners.map((owner) => [
+            pathKey(owner),
+            ownerAuthority.roleForConsumer({ consumerFile: firstObservation.fileName, ownerConfig: owner })
+        ]));
+        const requiredOwners = owners.filter((owner) => ownerRoles.get(pathKey(owner)) !== "generated-declaration-projection");
+        let candidate = requiredOwners
+            .map((owner) => fileObservations.get(pathKey(owner)))
+            .find((observation) => Boolean(observation));
+        if (!candidate) {
+            return ownerDivergenceFailure({
+                reason: "owner-evidence-missing",
+                fileName: firstObservation.fileName,
+                owners,
+                ownerRoles,
+                observations: fileObservations,
+                error: `No non-projection owner edit exists for ${firstObservation.fileName}.`
+            });
+        }
+        const requiredObservations = requiredOwners
+            .map((owner) => fileObservations.get(pathKey(owner)))
+            .filter((observation) => Boolean(observation));
+        if (requiredObservations.length !== requiredOwners.length) {
+            return ownerDivergenceFailure({
+                reason: "owner-edit-missing",
+                fileName: candidate.fileName,
+                owners,
+                ownerRoles,
+                observations: fileObservations,
+                error: `An exact owner omitted ${candidate.fileName}.`
+            });
+        }
+        let reconciledModuleSpecifiers = false;
+        if (new Set(requiredObservations.map(editSignature)).size > 1) {
+            input.metrics?.observeDivergence("divergentProposalFiles", candidate.fileName);
+            const isNewTarget = samePath(candidate.fileName, input.targetFile) && !input.targetExisted;
+            if (samePath(candidate.fileName, input.sourceFile) || samePath(candidate.fileName, input.targetFile) && !isNewTarget ||
+                !isRegularFile(candidate.fileName) && !isNewTarget) {
+                input.metrics?.observeDivergence("unresolvedDivergences", candidate.fileName);
+                return ownerDivergenceFailure({
+                    reason: "source-target-edit-disagreement",
+                    fileName: candidate.fileName,
+                    owners,
+                    ownerRoles,
+                    observations: fileObservations,
+                    error: `Exact owners disagree on ${candidate.fileName}.`
+                });
+            }
+            const configuredEnding = input.importRules.length > 0
+                ? (0, import_rules_1.resolveImportRuleForFile)(candidate.fileName, input.importRules)?.ending
+                : input.workspacePreferences
+                    ? (0, typescript_preferences_1.resolveWorkspaceImportPreferences)(input.workspacePreferences, candidate.fileName).ending
+                    : undefined;
+            const preferredEnding = configuredEnding === "auto" || configuredEnding === "js" || configuredEnding === "minimal"
+                ? configuredEnding
+                : undefined;
+            const reconciliation = isNewTarget
+                ? (0, semantic_move_owner_candidates_1.reconcileSemanticMoveNewTargetCandidates)({
+                    fileName: candidate.fileName,
+                    sourceFile: input.sourceFile,
+                    sourceText: fs.readFileSync(input.sourceFile, "utf8"),
+                    ownerConfigs: requiredOwners,
+                    observations: requiredObservations,
+                    ...(preferredEnding ? { preferredEnding } : {}),
+                    resolver: input.canonicalModuleResolver
+                })
+                : (0, semantic_move_owner_candidates_1.reconcileSemanticMoveOwnerCandidates)({
+                    fileName: candidate.fileName,
+                    expectedText: fs.readFileSync(candidate.fileName, "utf8"),
+                    targetFile: input.targetFile,
+                    ownerConfigs: requiredOwners,
+                    observations: requiredObservations,
+                    resolver: input.moduleSpecifierResolver
+                });
+            const policyCanSelect = !isNewTarget && reconciliation.status === "ambiguous" && Boolean(input.importRules.length > 0
+                ? (0, import_rules_1.resolveImportRuleForFile)(candidate.fileName, input.importRules)?.specifier
+                : input.workspacePreferences &&
+                    (0, typescript_preferences_1.resolveWorkspaceImportPreferences)(input.workspacePreferences, candidate.fileName).specifier);
+            if (reconciliation.status !== "selected" && !policyCanSelect) {
+                input.metrics?.observeDivergence("unresolvedDivergences", candidate.fileName);
+                const reason = reconciliation.status === "ambiguous"
+                    ? `${reconciliation.validCandidateCount} module-specifier candidates are valid for every exact owner`
+                    : reconciliation.status === "none-valid"
+                        ? "no module-specifier candidate is valid for every exact owner"
+                        : "owner plans differ outside module-specifier literals";
+                return ownerDivergenceFailure({
+                    reason: reconciliation.status === "ambiguous"
+                        ? "module-specifier-ambiguous"
+                        : reconciliation.status === "none-valid"
+                            ? "module-specifier-none-valid"
+                            : isNewTarget
+                                ? "source-target-edit-disagreement"
+                                : "non-module-specifier-disagreement",
+                    fileName: candidate.fileName,
+                    owners,
+                    ownerRoles,
+                    observations: fileObservations,
+                    ...(reconciliation.status === "ambiguous"
+                        ? { universallyValidCandidateCount: reconciliation.validCandidateCount }
+                        : reconciliation.status === "none-valid"
+                            ? { universallyValidCandidateCount: 0 }
+                            : {}),
+                    error: `${reason}: ${candidate.fileName}.`
+                });
+            }
+            candidate = reconciliation.edit;
+            reconciledModuleSpecifiers = true;
+            input.metrics?.observeDivergence("policyResolvedDivergences", candidate.fileName);
+        }
+        moduleSpecifierOwners.set(pathKey(candidate.fileName), requiredOwners);
+        const signature = editSignature(candidate);
+        for (const owner of owners) {
+            const ownerKey = pathKey(owner);
+            const observation = fileObservations.get(pathKey(owner));
+            if (!resultMap.has(ownerKey)) {
+                return ownerDivergenceFailure({
+                    reason: "owner-evidence-missing",
+                    fileName: candidate.fileName,
+                    owners,
+                    ownerRoles,
+                    observations: fileObservations,
+                    error: `${owner} disagrees on ${candidate.fileName}.`
+                });
+            }
+            // A proven declaration output describes the pre-build package view. Its worker must finish,
+            // but neither an empty nor a conflicting proposal can overrule the exact source owner.
+            if (ownerRoles.get(ownerKey) === "generated-declaration-projection")
+                continue;
+            if (!observation) {
+                return ownerDivergenceFailure({
+                    reason: "owner-edit-missing",
+                    fileName: candidate.fileName,
+                    owners,
+                    ownerRoles,
+                    observations: fileObservations,
+                    error: `${owner} disagrees on ${candidate.fileName}.`
+                });
+            }
+            if (!reconciledModuleSpecifiers && editSignature(observation) !== signature) {
+                return ownerDivergenceFailure({
+                    reason: "owner-edit-disagreement",
+                    fileName: candidate.fileName,
+                    owners,
+                    ownerRoles,
+                    observations: fileObservations,
+                    error: `${owner} disagrees on ${candidate.fileName}.`
+                });
+            }
+        }
+        const exactOwnerKeys = new Set(owners.map(pathKey));
+        if ([...fileObservations].some(([config, observation]) => !exactOwnerKeys.has(config) && editSignature(observation) !== signature)) {
+            return ownerDivergenceFailure({
+                reason: "non-owner-projection-disagreement",
+                fileName: candidate.fileName,
+                owners: uniquePaths([...owners, ...fileObservations.keys()]),
+                ownerRoles,
+                observations: fileObservations,
+                error: `A non-owning projection disagrees on ${candidate.fileName}.`
+            });
+        }
+        const isTarget = samePath(candidate.fileName, input.targetFile);
+        const expectedExists = isTarget ? input.targetExisted : true;
+        if (candidate.isNewFile !== !expectedExists || (expectedExists && !isRegularFile(candidate.fileName))) {
+            return { ok: false, code: "SEMANTIC_MOVE_FILE_SHAPE_INVALID", error: `Invalid new/existing file evidence for ${candidate.fileName}.` };
+        }
+        const expectedBytes = expectedExists ? fs.readFileSync(candidate.fileName) : Buffer.alloc(0);
+        const expectedText = expectedBytes.toString("utf8");
+        const textChanges = normalizeExistingTargetEndOfFileSentinel({
+            fileName: candidate.fileName,
+            expectedText,
+            changes: candidate.textChanges,
+            enabled: isTarget && expectedExists
+        });
+        const validation = validateTextChanges(candidate.fileName, expectedText, textChanges);
+        if (!validation.ok)
+            return validation;
+        edits.push({
+            ...candidate,
+            textChanges,
+            expectedExists,
+            expectedText,
+            expectedHash: crypto.createHash("sha256").update(expectedBytes).digest("hex")
+        });
+        observations.set(file, fileObservations);
+    }
+    return {
+        ok: true,
+        edits: edits.sort((left, right) => left.fileName.localeCompare(right.fileName)),
+        moduleSpecifierOwners
+    };
+}
+function ownerDivergenceFailure(input) {
+    const signatures = new Set();
+    const ownerEvidence = uniquePaths(input.owners).map((owner) => {
+        const observation = input.observations.get(pathKey(owner));
+        if (observation)
+            signatures.add(editSignature(observation));
+        return {
+            configFilePath: path.normalize(owner),
+            role: input.ownerRoles?.get(pathKey(owner)) ?? "unproven",
+            proposal: observation ? "present" : "missing",
+            ...(observation
+                ? { proposalHash: crypto.createHash("sha256").update(editSignature(observation)).digest("hex") }
+                : {})
+        };
+    });
+    return {
+        ok: false,
+        code: "SEMANTIC_MOVE_OWNER_DIVERGENCE",
+        error: input.error,
+        divergence: {
+            reason: input.reason,
+            fileName: path.normalize(input.fileName),
+            ownerEvidence,
+            candidateCount: signatures.size,
+            ...(input.universallyValidCandidateCount !== undefined
+                ? { universallyValidCandidateCount: input.universallyValidCandidateCount }
+                : {})
+        }
+    };
+}
+function verifyMoveStructure(sourceFile, targetFile, sourceText, entities, edits) {
+    const sourceEdit = edits.find((edit) => samePath(edit.fileName, sourceFile));
+    const targetEdit = edits.find((edit) => samePath(edit.fileName, targetFile));
+    if (!sourceEdit || !targetEdit)
+        return { ok: false, code: "SEMANTIC_MOVE_REQUIRED_EDIT_MISSING", error: "Source or target edit is missing." };
+    const renderedSource = applyTextChanges(sourceEdit.expectedText, sourceEdit.textChanges);
+    const renderedTarget = applyTextChanges(targetEdit.expectedText, targetEdit.textChanges);
+    for (const entity of entities) {
+        const expectedCount = (0, semantic_move_declarations_1.countSemanticMoveDeclarations)(sourceFile, sourceText, entity.name, entity.kind);
+        if (expectedCount !== entity.declarationStarts.length || (0, semantic_move_declarations_1.countSemanticMoveDeclarations)(sourceFile, renderedSource, entity.name, entity.kind) !== 0 ||
+            (0, semantic_move_declarations_1.countSemanticMoveDeclarations)(targetFile, renderedTarget, entity.name, entity.kind) !== expectedCount) {
+            return {
+                ok: false,
+                code: "SEMANTIC_MOVE_STRUCTURE_DIVERGENCE",
+                error: `TypeScript move did not transfer the exact top-level declaration group for ${entity.name}.`
+            };
+        }
+    }
+    const requestedKinds = new Set(entities.map((entity) => `${entity.name}\0${entity.kind ?? "*"}`));
+    const protectedDeclarations = new Map();
+    for (const candidate of (0, semantic_move_declarations_1.collectSemanticMoveDeclarations)(sourceFile, sourceText)) {
+        if (requestedKinds.has(`${candidate.name}\0*`) || requestedKinds.has(`${candidate.name}\0${candidate.kind}`))
+            continue;
+        const key = `${candidate.name}\0${candidate.kind}`;
+        const current = protectedDeclarations.get(key);
+        protectedDeclarations.set(key, { name: candidate.name, kind: candidate.kind, count: (current?.count ?? 0) + 1 });
+    }
+    for (const declaration of protectedDeclarations.values()) {
+        if ((0, semantic_move_declarations_1.countSemanticMoveDeclarations)(sourceFile, renderedSource, declaration.name, declaration.kind) !== declaration.count) {
+            return {
+                ok: false,
+                code: "SEMANTIC_MOVE_STRUCTURE_DIVERGENCE",
+                error: `TypeScript move changed unrequested top-level ${declaration.kind} declaration ${declaration.name}.`
+            };
+        }
+    }
+    return { ok: true };
+}
+function groupContiguousEntityRanges(ranges) {
+    const ordered = [...ranges].sort((left, right) => left.first - right.first || left.last - right.last);
+    const groups = [];
+    for (const range of ordered) {
+        const current = groups[groups.length - 1];
+        if (current && range.first <= current.last + 1) {
+            current.last = Math.max(current.last, range.last);
+            current.ids.push(range.id);
+        }
+        else {
+            groups.push({ last: range.last, ids: [range.id] });
+        }
+    }
+    return groups.map((group) => group.ids);
+}
+function chooseSemanticMoveTargetSpecifier(input) {
+    let configuredRule = input.importRules.length > 0
+        ? (0, import_rules_1.resolveImportRuleForFile)(input.fromFile, input.importRules)
+        : null;
+    if (!configuredRule && input.workspacePreferences) {
+        const preferences = (0, typescript_preferences_1.resolveWorkspaceImportPreferences)(input.workspacePreferences, input.fromFile);
+        if (preferences.specifier || preferences.ending) {
+            configuredRule = {
+                scope: ".",
+                scopePath: input.workspaceRoot,
+                ...(preferences.specifier ? { specifier: preferences.specifier } : {}),
+                ...(preferences.ending ? { ending: preferences.ending } : {})
+            };
+        }
+    }
+    const inferredEnding = /\.[cm]?js$/i.test(input.originalSpecifier) ? "js" : "minimal";
+    const rule = (0, import_specifier_policy_1.materializeAutoImportEnding)({
+        scope: configuredRule?.scope ?? ".",
+        scopePath: configuredRule?.scopePath ?? input.workspaceRoot,
+        specifier: configuredRule?.specifier ?? "relative",
+        ending: configuredRule?.ending ?? inferredEnding,
+        ...(configuredRule?.builtin ? { builtin: configuredRule.builtin } : {}),
+        ...(configuredRule?.unusedImports ? { unusedImports: configuredRule.unusedImports } : {})
+    }, input.originalSpecifier);
+    const config = (0, import_specifier_policy_1.readNearestTsConfig)(input.fromFile, input.workspaceRoot, input.configCache);
+    const preferred = (0, import_specifier_policy_1.chooseImportSpecifier)({
+        fromFile: input.fromFile,
+        targetFile: input.targetFile,
+        config,
+        rule,
+        allowIndexCollapse: true
+    });
+    const relative = (0, import_specifier_policy_1.chooseImportSpecifier)({
+        fromFile: input.fromFile,
+        targetFile: input.targetFile,
+        config,
+        rule: { ...rule, specifier: "relative" },
+        allowIndexCollapse: true
+    });
+    return [preferred, relative].find((specifier) => input.moduleSpecifierResolver({
+        specifier,
+        containingFile: input.fromFile,
+        targetFile: input.targetFile,
+        ownerConfigs: input.owners
+    })) ?? null;
+}
+function applySafeDynamicImportMoveEdits(input) {
+    const names = new Set(input.entities.map((entity) => entity.name));
+    const editsByFile = new Map(input.edits.map((edit) => [pathKey(edit.fileName), edit]));
+    const renderedByFile = new Map();
+    const processed = new Set();
+    const configCache = new Map();
+    for (const edge of input.discovery.edges) {
+        if (edge.kind !== "dynamic" || !samePath(edge.targetFile, input.sourceFile) || !isRegularFile(edge.fromFile)) {
+            continue;
+        }
+        const key = `${pathKey(edge.fromFile)}\0${edge.moduleSpecifier}`;
+        if (processed.has(key))
+            continue;
+        processed.add(key);
+        const edit = editsByFile.get(pathKey(edge.fromFile));
+        const expectedText = edit?.expectedText ?? fs.readFileSync(edge.fromFile, "utf8");
+        const currentText = renderedByFile.get(pathKey(edge.fromFile)) ??
+            (edit ? applyTextChanges(edit.expectedText, edit.textChanges) : expectedText);
+        const source = typescript_1.default.createSourceFile(edge.fromFile, currentText, typescript_1.default.ScriptTarget.Latest, true, scriptKindForFile(edge.fromFile));
+        const literals = collectSafeDynamicImportLiterals(source, edge.moduleSpecifier, names);
+        if (literals.length === 0)
+            continue;
+        const owners = ownersForFile(input.discovery, edge.fromFile);
+        if (owners.length === 0)
+            continue;
+        const nextSpecifier = chooseSemanticMoveTargetSpecifier({
+            workspaceRoot: input.workspaceRoot,
+            fromFile: edge.fromFile,
+            targetFile: input.targetFile,
+            originalSpecifier: edge.moduleSpecifier,
+            owners,
+            importRules: input.importRules,
+            ...(input.workspacePreferences ? { workspacePreferences: input.workspacePreferences } : {}),
+            moduleSpecifierResolver: input.moduleSpecifierResolver,
+            configCache
+        });
+        if (!nextSpecifier)
+            continue;
+        let nextText = currentText;
+        for (const literal of literals.sort((left, right) => right.start - left.start)) {
+            nextText = `${nextText.slice(0, literal.start)}${nextSpecifier}${nextText.slice(literal.start + literal.length)}`;
+        }
+        renderedByFile.set(pathKey(edge.fromFile), nextText);
+    }
+    return mergeSemanticMoveRenderedFiles(input.edits, renderedByFile, input.discovery);
+}
+function exportStarEdgeKey(edge) {
+    return `${pathKey(edge.fromFile)}\0${edge.specifierStart}`;
+}
+function applySafeNamedReexportMoveEdits(input) {
+    const names = new Set(input.entities.map((entity) => entity.name));
+    const editsByFile = new Map(input.edits.map((edit) => [pathKey(edit.fileName), edit]));
+    const renderedByFile = new Map();
+    const processed = new Set();
+    const configCache = new Map();
+    const sourceEdit = editsByFile.get(pathKey(input.sourceFile));
+    const renderedSource = sourceEdit
+        ? applyTextChanges(sourceEdit.expectedText, sourceEdit.textChanges)
+        : fs.readFileSync(input.sourceFile, "utf8");
+    const retainedNames = new Set((0, semantic_move_declarations_1.collectSemanticMoveDeclarations)(input.sourceFile, renderedSource).map((declaration) => declaration.name));
+    for (const edge of input.discovery.edges) {
+        if (edge.kind !== "reexport" || !samePath(edge.targetFile, input.sourceFile) || !isRegularFile(edge.fromFile))
+            continue;
+        const key = `${pathKey(edge.fromFile)}\0${edge.moduleSpecifier}`;
+        if (processed.has(key))
+            continue;
+        processed.add(key);
+        const edit = editsByFile.get(pathKey(edge.fromFile));
+        const expectedText = edit?.expectedText ?? fs.readFileSync(edge.fromFile, "utf8");
+        const currentText = renderedByFile.get(pathKey(edge.fromFile)) ??
+            (edit ? applyTextChanges(edit.expectedText, edit.textChanges) : expectedText);
+        const source = typescript_1.default.createSourceFile(edge.fromFile, currentText, typescript_1.default.ScriptTarget.Latest, true, scriptKindForFile(edge.fromFile));
+        const matching = source.statements.filter((statement) => typescript_1.default.isExportDeclaration(statement) && statement.exportClause !== undefined && typescript_1.default.isNamedExports(statement.exportClause) &&
+            statement.moduleSpecifier !== undefined && typescript_1.default.isStringLiteralLike(statement.moduleSpecifier) &&
+            statement.moduleSpecifier.text === edge.moduleSpecifier);
+        if (matching.length === 0)
+            continue;
+        const owners = ownersForFile(input.discovery, edge.fromFile);
+        if (owners.length === 0)
+            continue;
+        const nextSpecifier = chooseSemanticMoveTargetSpecifier({
+            workspaceRoot: input.workspaceRoot,
+            fromFile: edge.fromFile,
+            targetFile: input.targetFile,
+            originalSpecifier: edge.moduleSpecifier,
+            owners,
+            importRules: input.importRules,
+            ...(input.workspacePreferences ? { workspacePreferences: input.workspacePreferences } : {}),
+            moduleSpecifierResolver: input.moduleSpecifierResolver,
+            configCache
+        });
+        if (!nextSpecifier)
+            continue;
+        const replacements = matching.flatMap((statement) => {
+            const replacement = renderSemanticMoveNamedReexportReplacement(source, statement, edge.moduleSpecifier, nextSpecifier, names, retainedNames);
+            return replacement === null
+                ? []
+                : [{ start: statement.getStart(source), length: statement.getWidth(source), replacement }];
+        });
+        if (replacements.length === 0)
+            continue;
+        let rendered = currentText;
+        for (const replacement of replacements.sort((left, right) => right.start - left.start)) {
+            rendered = `${rendered.slice(0, replacement.start)}${replacement.replacement}${rendered.slice(replacement.start + replacement.length)}`;
+        }
+        renderedByFile.set(pathKey(edge.fromFile), rendered);
+    }
+    return mergeSemanticMoveRenderedFiles(input.edits, renderedByFile, input.discovery);
+}
+function renderSemanticMoveNamedReexportReplacement(source, statement, sourceSpecifier, targetSpecifier, movedNames, retainedNames) {
+    const clause = statement.exportClause;
+    if (!clause || !typescript_1.default.isNamedExports(clause) || statement.attributes)
+        return null;
+    const clauseStart = clause.getStart(source);
+    const comments = [...clause.getText(source).matchAll(/\/\/[^\r\n]*|\/\*[\s\S]*?\*\//g)].map((match) => ({
+        pos: clauseStart + match.index,
+        text: match[0]
+    }));
+    const claimedComments = new Set();
+    const descriptors = [];
+    for (const element of clause.elements) {
+        if (!typescript_1.default.isIdentifier(element.name) || element.propertyName && !typescript_1.default.isIdentifier(element.propertyName))
+            return null;
+        const sourceName = (element.propertyName ?? element.name).text;
+        const alias = element.propertyName ? `${element.propertyName.text} as ${element.name.text}` : element.name.text;
+        const typeOnly = statement.isTypeOnly || element.isTypeOnly;
+        const leadingComments = (typescript_1.default.getLeadingCommentRanges(source.text, element.getFullStart()) ?? [])
+            .filter((range) => range.pos >= clauseStart && range.end <= clause.getEnd());
+        for (const range of leadingComments)
+            claimedComments.add(range.pos);
+        descriptors.push({
+            sourceName,
+            text: !statement.isTypeOnly && element.isTypeOnly ? `type ${alias}` : alias,
+            typeOnly,
+            comments: leadingComments.map((range) => source.text.slice(range.pos, range.end)),
+            end: element.getEnd()
+        });
+    }
+    for (const comment of comments.filter((candidate) => !claimedComments.has(candidate.pos))) {
+        let previous;
+        for (let index = descriptors.length - 1; index >= 0; index--) {
+            if (descriptors[index].end <= comment.pos) {
+                previous = descriptors[index];
+                break;
+            }
+        }
+        if (previous && source.getLineAndCharacterOfPosition(previous.end).line === source.getLineAndCharacterOfPosition(comment.pos).line) {
+            previous.comments.push(comment.text);
+            claimedComments.add(comment.pos);
+        }
+    }
+    const moved = descriptors.filter((descriptor) => movedNames.has(descriptor.sourceName) && !retainedNames.has(descriptor.sourceName));
+    if (moved.length === 0)
+        return null;
+    const retained = descriptors.filter((descriptor) => !movedNames.has(descriptor.sourceName) || retainedNames.has(descriptor.sourceName));
+    const rawSpecifier = statement.moduleSpecifier?.getText(source) ?? "";
+    const quote = rawSpecifier.startsWith("'") ? "'" : '"';
+    const semicolon = statement.getText(source).trimEnd().endsWith(";");
+    return [
+        ...comments.filter((comment) => !claimedComments.has(comment.pos)).map((comment) => comment.text),
+        ...(retained.length > 0
+            ? [renderSemanticMoveNamedReexport(sourceSpecifier, quote, statement.isTypeOnly, retained, semicolon)]
+            : []),
+        renderSemanticMoveNamedReexport(targetSpecifier, quote, statement.isTypeOnly, moved, semicolon)
+    ].join("\n");
+}
+function renderSemanticMoveNamedReexport(moduleSpecifier, quote, statementTypeOnly, descriptors, semicolon) {
+    const prefix = statementTypeOnly ? "export type" : "export";
+    const suffix = semicolon ? ";" : "";
+    const typeModes = new Set(descriptors.map((descriptor) => descriptor.typeOnly));
+    if (descriptors.length <= 2 && typeModes.size === 1 && descriptors.every((descriptor) => descriptor.comments.length === 0)) {
+        return `${prefix} { ${descriptors.map((descriptor) => descriptor.text).join(", ")} } from ${quote}${moduleSpecifier}${quote}${suffix}`;
+    }
+    return [
+        `${prefix} {`,
+        ...descriptors.flatMap((descriptor) => [
+            ...descriptor.comments.flatMap((comment) => comment.split(/\r?\n/).map((line) => `  ${line.trimStart()}`)),
+            `  ${descriptor.text},`
+        ]),
+        `} from ${quote}${moduleSpecifier}${quote}${suffix}`
+    ].join("\n");
+}
+function applySafeExportStarMoveEdits(input) {
+    const coveredEdges = new Set();
+    const editsByFile = new Map(input.edits.map((edit) => [pathKey(edit.fileName), edit]));
+    const sourceEdit = editsByFile.get(pathKey(input.sourceFile));
+    const renderedSource = sourceEdit
+        ? applyTextChanges(sourceEdit.expectedText, sourceEdit.textChanges)
+        : fs.readFileSync(input.sourceFile, "utf8");
+    if (!typescript_1.default.isExternalModule(typescript_1.default.createSourceFile(input.sourceFile, renderedSource, typescript_1.default.ScriptTarget.Latest, true, scriptKindForFile(input.sourceFile)))) {
+        return { edits: [...input.edits], coveredEdges };
+    }
+    const renderedByFile = new Map();
+    const configCache = new Map();
+    for (const edge of input.discovery.edges) {
+        if (edge.kind !== "exportStar" || !samePath(edge.targetFile, input.sourceFile) || !isRegularFile(edge.fromFile))
+            continue;
+        const owners = ownersForFile(input.discovery, edge.fromFile);
+        if (owners.length === 0)
+            continue;
+        const valueEntities = [];
+        const typeEntities = [];
+        let completeProof = true;
+        for (const entity of input.entities) {
+            const proofs = owners.map((owner) => input.results
+                .find((result) => samePath(result.configFilePath, owner))
+                ?.exportStarProofs?.find((proof) => samePath(proof.barrelFile, edge.fromFile) &&
+                proof.specifierStart === edge.specifierStart && proof.entity === entity.name));
+            if (proofs.some((proof) => !proof?.checked)) {
+                completeProof = false;
+                break;
+            }
+            const matches = proofs.map((proof) => proof.matchesSourceSymbol);
+            if (new Set(matches).size !== 1) {
+                completeProof = false;
+                break;
+            }
+            if (!matches[0]) {
+                completeProof = false;
+                break;
+            }
+            const typeOnly = proofs.map((proof) => proof.typeOnly);
+            if (new Set(typeOnly).size !== 1) {
+                completeProof = false;
+                break;
+            }
+            (typeOnly[0] ? typeEntities : valueEntities).push(entity.name);
+        }
+        if (!completeProof)
+            continue;
+        const uniqueValueEntities = [...new Set(valueEntities)];
+        const valueEntityNames = new Set(uniqueValueEntities);
+        const uniqueTypeEntities = [...new Set(typeEntities)].filter((name) => !valueEntityNames.has(name));
+        const nextSpecifier = chooseSemanticMoveTargetSpecifier({
+            workspaceRoot: input.workspaceRoot,
+            fromFile: edge.fromFile,
+            targetFile: input.targetFile,
+            originalSpecifier: edge.moduleSpecifier,
+            owners,
+            importRules: input.importRules,
+            ...(input.workspacePreferences ? { workspacePreferences: input.workspacePreferences } : {}),
+            moduleSpecifierResolver: input.moduleSpecifierResolver,
+            configCache
+        });
+        if (!nextSpecifier)
+            continue;
+        const existing = editsByFile.get(pathKey(edge.fromFile));
+        const expectedText = existing?.expectedText ?? fs.readFileSync(edge.fromFile, "utf8");
+        const currentText = renderedByFile.get(pathKey(edge.fromFile)) ??
+            (existing ? applyTextChanges(existing.expectedText, existing.textChanges) : expectedText);
+        const barrelSource = typescript_1.default.createSourceFile(edge.fromFile, currentText, typescript_1.default.ScriptTarget.Latest, true, scriptKindForFile(edge.fromFile));
+        const star = barrelSource.statements.find((statement) => typescript_1.default.isExportDeclaration(statement) && !statement.exportClause && statement.moduleSpecifier !== undefined &&
+            typescript_1.default.isStringLiteralLike(statement.moduleSpecifier) && statement.moduleSpecifier.text === edge.moduleSpecifier);
+        if (!star?.moduleSpecifier || !typescript_1.default.isStringLiteralLike(star.moduleSpecifier))
+            continue;
+        const rawSpecifier = star.moduleSpecifier.getText(barrelSource);
+        const quote = rawSpecifier.startsWith("'") ? "'" : '"';
+        renderedByFile.set(pathKey(edge.fromFile), mergeOrAppendSemanticMoveNamedExport({
+            source: barrelSource,
+            text: currentText,
+            moduleSpecifier: nextSpecifier,
+            quote,
+            valueEntities: uniqueValueEntities,
+            typeEntities: uniqueTypeEntities
+        }));
+        coveredEdges.add(exportStarEdgeKey(edge));
+    }
+    return {
+        edits: mergeSemanticMoveRenderedFiles(input.edits, renderedByFile, input.discovery),
+        coveredEdges
+    };
+}
+function mergeSemanticMoveRenderedFiles(edits, renderedByFile, discovery) {
+    if (renderedByFile.size === 0)
+        return [...edits];
+    const result = [...edits];
+    for (const [fileKey, rendered] of renderedByFile) {
+        const existingIndex = result.findIndex((edit) => pathKey(edit.fileName) === fileKey);
+        if (existingIndex >= 0) {
+            const existing = result[existingIndex];
+            result[existingIndex] = {
+                ...existing,
+                textChanges: [{ span: { start: 0, length: existing.expectedText.length }, newText: rendered }]
+            };
+            continue;
+        }
+        const fileName = discovery.edges.find((edge) => pathKey(edge.fromFile) === fileKey).fromFile;
+        const expectedBytes = fs.readFileSync(fileName);
+        const expectedText = expectedBytes.toString("utf8");
+        result.push({
+            fileName,
+            isNewFile: false,
+            textChanges: [{ span: { start: 0, length: expectedText.length }, newText: rendered }],
+            expectedExists: true,
+            expectedText,
+            expectedHash: crypto.createHash("sha256").update(expectedBytes).digest("hex")
+        });
+    }
+    return result.sort((left, right) => left.fileName.localeCompare(right.fileName));
+}
+function renderSemanticMoveNamedExport(moduleSpecifier, quote, valueEntities, typeEntities) {
+    const specifiers = [
+        ...valueEntities,
+        ...typeEntities.map((name) => `type ${name}`)
+    ];
+    if (specifiers.length <= 2 && (valueEntities.length === 0 || typeEntities.length === 0)) {
+        return `export { ${specifiers.join(", ")} } from ${quote}${moduleSpecifier}${quote};`;
+    }
+    return [
+        "export {",
+        ...specifiers.map((specifier) => `  ${specifier},`),
+        `} from ${quote}${moduleSpecifier}${quote};`
+    ].join("\n");
+}
+function mergeOrAppendSemanticMoveNamedExport(input) {
+    const matching = input.source.statements.filter((statement) => typescript_1.default.isExportDeclaration(statement) && statement.exportClause !== undefined && typescript_1.default.isNamedExports(statement.exportClause) &&
+        statement.moduleSpecifier !== undefined && typescript_1.default.isStringLiteralLike(statement.moduleSpecifier) &&
+        statement.moduleSpecifier.text === input.moduleSpecifier);
+    const append = () => {
+        const rendered = renderSemanticMoveNamedExport(input.moduleSpecifier, input.quote, input.valueEntities, input.typeEntities);
+        const separator = input.text.length === 0 || input.text.endsWith("\n") ? "" : "\n";
+        return `${input.text}${separator}${rendered}\n`;
+    };
+    if (matching.length === 0)
+        return append();
+    const indexes = matching.map((statement) => input.source.statements.indexOf(statement));
+    if (indexes.some((value, index) => index > 0 && value !== indexes[index - 1] + 1))
+        return append();
+    const existingValues = [];
+    const existingTypes = [];
+    for (const statement of matching) {
+        const clause = statement.exportClause;
+        if (!clause || !typescript_1.default.isNamedExports(clause))
+            return append();
+        const statementValues = [];
+        const statementTypes = [];
+        for (const element of clause.elements) {
+            if (element.propertyName || !typescript_1.default.isIdentifier(element.name))
+                return append();
+            (statement.isTypeOnly || element.isTypeOnly ? statementTypes : statementValues).push(element.name.text);
+        }
+        const rawSpecifier = statement.moduleSpecifier?.getText(input.source) ?? "";
+        const statementQuote = rawSpecifier.startsWith("'") ? "'" : '"';
+        if (statement.getText(input.source) !== renderSemanticMoveNamedExport(input.moduleSpecifier, statementQuote, statementValues, statementTypes))
+            return append();
+        existingValues.push(...statementValues);
+        existingTypes.push(...statementTypes);
+    }
+    const valueEntities = [...new Set([...existingValues, ...input.valueEntities])];
+    const valueNames = new Set(valueEntities);
+    const typeEntities = [...new Set([...existingTypes, ...input.typeEntities])].filter((name) => !valueNames.has(name));
+    const rendered = renderSemanticMoveNamedExport(input.moduleSpecifier, input.quote, valueEntities, typeEntities);
+    const first = matching[0];
+    const last = matching[matching.length - 1];
+    return `${input.text.slice(0, first.getStart(input.source))}${rendered}${input.text.slice(last.getEnd())}`;
+}
+function collectSafeDynamicImportLiterals(source, moduleSpecifier, names) {
+    const literals = [];
+    const visit = (node) => {
+        if (typescript_1.default.isCallExpression(node) && node.expression.kind === typescript_1.default.SyntaxKind.ImportKeyword &&
+            node.arguments.length === 1 && typescript_1.default.isStringLiteralLike(node.arguments[0]) &&
+            node.arguments[0].text === moduleSpecifier && analyzeDynamicImportUsage(source, node, names) === "movedOnly") {
+            const literal = node.arguments[0];
+            literals.push({ start: literal.getStart(source) + 1, length: literal.text.length });
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    return literals;
+}
+function analyzeDynamicImportUsage(source, call, names) {
+    const initializer = typescript_1.default.isAwaitExpression(call.parent) ? call.parent : call;
+    const declaration = initializer.parent;
+    if (!typescript_1.default.isVariableDeclaration(declaration) || declaration.initializer !== initializer || !typescript_1.default.isIdentifier(declaration.name)) {
+        return "uncertain";
+    }
+    const binding = declaration.name;
+    let moved = false;
+    let retained = false;
+    let uncertain = false;
+    const visit = (node) => {
+        if (uncertain)
+            return;
+        if (typescript_1.default.isIdentifier(node) && node.text === binding.text && node !== binding) {
+            const parent = node.parent;
+            let property = null;
+            if (typescript_1.default.isPropertyAccessExpression(parent) && parent.expression === node) {
+                property = parent.name.text;
+            }
+            else if (typescript_1.default.isElementAccessExpression(parent) && parent.expression === node &&
+                parent.argumentExpression && typescript_1.default.isStringLiteralLike(parent.argumentExpression)) {
+                property = parent.argumentExpression.text;
+            }
+            else {
+                uncertain = true;
+                return;
+            }
+            if (names.has(property))
+                moved = true;
+            else
+                retained = true;
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    if (uncertain)
+        return "uncertain";
+    if (moved && retained)
+        return "mixed";
+    if (moved)
+        return "movedOnly";
+    if (retained)
+        return "unaffected";
+    return "uncertain";
+}
+function verifyMovedEntityEdgeCoverage(sourceFile, entities, discovery, edits, coveredExportStarEdges = new Set()) {
+    const names = new Set(entities.map((entity) => entity.name));
+    const editsByFile = new Map(edits.map((edit) => [pathKey(edit.fileName), edit]));
+    const sourceEdit = editsByFile.get(pathKey(sourceFile));
+    const renderedSource = sourceEdit ? applyTextChanges(sourceEdit.expectedText, sourceEdit.textChanges) : fs.readFileSync(sourceFile, "utf8");
+    const sourceRemainsModule = typescript_1.default.isExternalModule(typescript_1.default.createSourceFile(sourceFile, renderedSource, typescript_1.default.ScriptTarget.Latest, true, scriptKindForFile(sourceFile)));
+    for (const edge of discovery.edges.filter((candidate) => samePath(candidate.targetFile, sourceFile))) {
+        if (samePath(edge.fromFile, sourceFile) || !isRegularFile(edge.fromFile))
+            continue;
+        if (edge.kind === "exportStar" && coveredExportStarEdges.has(exportStarEdgeKey(edge)))
+            continue;
+        const originalText = fs.readFileSync(edge.fromFile, "utf8");
+        const originalAffected = sourceRemainsModule
+            ? moduleEdgeCarriesMovedEntity(edge.kind, edge.moduleSpecifier, originalText, edge.fromFile, names)
+            : containsModuleEdge(originalText, edge.fromFile, edge.moduleSpecifier);
+        if (!originalAffected)
+            continue;
+        const edit = editsByFile.get(pathKey(edge.fromFile));
+        const finalText = edit ? applyTextChanges(edit.expectedText, edit.textChanges) : originalText;
+        const finalAffected = sourceRemainsModule
+            ? moduleEdgeCarriesMovedEntity(edge.kind, edge.moduleSpecifier, finalText, edge.fromFile, names)
+            : containsModuleEdge(finalText, edge.fromFile, edge.moduleSpecifier);
+        if (finalAffected) {
+            return {
+                ok: false,
+                code: "SEMANTIC_MOVE_REQUIRED_EDGE_UNCHANGED",
+                error: `TypeScript move left a required ${edge.kind} edge pointing at the old source: ${edge.fromFile}:${edge.line}.`
+            };
+        }
+    }
+    return { ok: true };
+}
+function containsModuleEdge(text, fileName, moduleSpecifier) {
+    const source = typescript_1.default.createSourceFile(fileName, text, typescript_1.default.ScriptTarget.Latest, true, scriptKindForFile(fileName));
+    return containsModuleSpecifier(source, moduleSpecifier);
+}
+function moduleEdgeCarriesMovedEntity(kind, moduleSpecifier, text, fileName, names) {
+    const source = typescript_1.default.createSourceFile(fileName, text, typescript_1.default.ScriptTarget.Latest, true, scriptKindForFile(fileName));
+    if (kind === "dynamic") {
+        let carries = false;
+        const visit = (node) => {
+            if (carries)
+                return;
+            if (typescript_1.default.isCallExpression(node) && node.expression.kind === typescript_1.default.SyntaxKind.ImportKeyword &&
+                node.arguments.length === 1 && typescript_1.default.isStringLiteralLike(node.arguments[0]) &&
+                node.arguments[0].text === moduleSpecifier && analyzeDynamicImportUsage(source, node, names) !== "unaffected") {
+                carries = true;
+                return;
+            }
+            typescript_1.default.forEachChild(node, visit);
+        };
+        visit(source);
+        return carries;
+    }
+    let carries = false;
+    source.forEachChild((node) => {
+        if (carries)
+            return;
+        if (typescript_1.default.isImportDeclaration(node) && moduleText(node.moduleSpecifier) === moduleSpecifier) {
+            const bindings = node.importClause?.namedBindings;
+            if (bindings && typescript_1.default.isNamedImports(bindings)) {
+                carries = bindings.elements.some((element) => names.has((element.propertyName ?? element.name).text));
+            }
+            else if (bindings && typescript_1.default.isNamespaceImport(bindings)) {
+                carries = namespaceReferencesEntity(source, bindings.name.text, names);
+            }
+            return;
+        }
+        if (typescript_1.default.isExportDeclaration(node) && node.moduleSpecifier && moduleText(node.moduleSpecifier) === moduleSpecifier) {
+            if (!node.exportClause || typescript_1.default.isNamespaceExport(node.exportClause))
+                carries = true;
+            else
+                carries = node.exportClause.elements.some((element) => names.has((element.propertyName ?? element.name).text));
+            return;
+        }
+        if (kind === "require" || kind === "importEquals") {
+            carries = containsModuleSpecifier(node, moduleSpecifier);
+        }
+    });
+    return carries;
+}
+function namespaceReferencesEntity(source, namespaceName, names) {
+    let found = false;
+    const visit = (node) => {
+        if (found)
+            return;
+        if (typescript_1.default.isPropertyAccessExpression(node) && typescript_1.default.isIdentifier(node.expression) && node.expression.text === namespaceName && names.has(node.name.text)) {
+            found = true;
+            return;
+        }
+        if (typescript_1.default.isQualifiedName(node) && typescript_1.default.isIdentifier(node.left) && node.left.text === namespaceName && names.has(node.right.text)) {
+            found = true;
+            return;
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    typescript_1.default.forEachChild(source, visit);
+    return found;
+}
+function containsModuleSpecifier(node, moduleSpecifier) {
+    let found = false;
+    const visit = (candidate) => {
+        if (found)
+            return;
+        if (typescript_1.default.isStringLiteralLike(candidate) && candidate.text === moduleSpecifier) {
+            found = true;
+            return;
+        }
+        typescript_1.default.forEachChild(candidate, visit);
+    };
+    visit(node);
+    return found;
+}
+function moduleText(node) {
+    return typescript_1.default.isStringLiteralLike(node) ? node.text : null;
+}
+function verifyBeforeHashes(results, edits, synthesizedFiles = new Set()) {
+    if (results.some((result) => !result.configHash || result.configHash !== hashFile(result.configFilePath)))
+        return false;
+    for (const edit of edits.filter((item) => item.expectedExists)) {
+        const observed = results.flatMap((result) => Object.entries(result.beforeHashes))
+            .filter(([file]) => samePath(file, edit.fileName))
+            .map(([, hash]) => hash);
+        if ((observed.length === 0 && !synthesizedFiles.has(pathKey(edit.fileName))) ||
+            observed.some((hash) => hash !== edit.expectedHash) || hashFile(edit.fileName) !== edit.expectedHash)
+            return false;
+    }
+    return true;
+}
+function validateTextChanges(fileName, text, changes) {
+    const ordered = [...changes].sort((left, right) => left.span.start - right.span.start || left.span.length - right.span.length);
+    for (const [index, change] of ordered.entries()) {
+        if (change.span.start < 0 || change.span.length < 0 || change.span.start + change.span.length > text.length) {
+            return { ok: false, code: "SEMANTIC_MOVE_EDIT_SPAN_INVALID", error: `Invalid edit span in ${fileName}.` };
+        }
+        const previous = index > 0 ? ordered[index - 1] : undefined;
+        if (previous && previous.span.start + previous.span.length > change.span.start) {
+            return { ok: false, code: "SEMANTIC_MOVE_EDIT_OVERLAP", error: `Overlapping edits in ${fileName}.` };
+        }
+    }
+    return { ok: true };
+}
+function normalizeExistingTargetEndOfFileSentinel(input) {
+    if (!input.enabled)
+        return [...input.changes];
+    const source = typescript_1.default.createSourceFile(input.fileName, input.expectedText, typescript_1.default.ScriptTarget.Latest, true, scriptKindForFile(input.fileName));
+    if (source.statements.length > 0)
+        return [...input.changes];
+    return input.changes.map((change) => change.span.length === 0 && change.span.start === input.expectedText.length + 1
+        ? { ...change, span: { start: input.expectedText.length, length: 0 } }
+        : change);
+}
+function normalizeFileEdit(edit) {
+    return {
+        fileName: path.normalize(edit.fileName),
+        isNewFile: edit.isNewFile,
+        textChanges: edit.textChanges.map((change) => ({
+            span: { start: change.span.start, length: change.span.length },
+            newText: change.newText
+        }))
+    };
+}
+function editSignature(edit) {
+    return JSON.stringify({ isNewFile: edit.isNewFile, textChanges: edit.textChanges });
+}
+function applyTextChanges(text, changes) {
+    const ordered = [...changes].sort((left, right) => left.span.start - right.span.start || left.span.length - right.span.length);
+    let cursor = 0;
+    let output = "";
+    for (const change of ordered) {
+        output += text.slice(cursor, change.span.start) + change.newText;
+        cursor = change.span.start + change.span.length;
+    }
+    return output + text.slice(cursor);
+}
+function ownersForFile(discovery, fileName) {
+    return discovery.fileOwners.find((item) => samePath(item.file, fileName))?.ownerConfigs.map(path.normalize).sort() ?? [];
+}
+function discoverySummary(discovery) {
+    return {
+        filesScanned: discovery?.filesScanned ?? 0,
+        bytesScanned: discovery?.bytesScanned ?? 0,
+        consumerCount: discovery?.consumerFiles.length ?? 0,
+        edgeCount: discovery?.edgeCount ?? 0,
+        ownerConfigCount: discovery?.ownerConfigs.length ?? 0,
+        workspaceFingerprint: discovery?.workspaceFingerprint ?? ""
+    };
+}
+function incomplete(code, error, root, sourceFile, targetFile, discovery, startedAt, snapshotHash = "", configWorkers = [], divergences = []) {
+    return {
+        complete: false,
+        code,
+        error,
+        workspaceRoot: root,
+        sourceFile,
+        targetFile,
+        targetExisted: fs.existsSync(targetFile),
+        entities: [],
+        edits: [],
+        discovery,
+        configWorkers,
+        snapshotHash,
+        planHash: "",
+        totalMs: Date.now() - startedAt,
+        ...(divergences.length > 0 ? { divergences } : {})
+    };
+}
+function isValidIdentifierName(value) {
+    const source = typescript_1.default.createSourceFile("name.ts", `const ${value}=1`, typescript_1.default.ScriptTarget.Latest, true, typescript_1.default.ScriptKind.TS);
+    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 scriptKindForFile(file) {
+    const extension = path.extname(file).toLowerCase();
+    if (extension === ".tsx")
+        return typescript_1.default.ScriptKind.TSX;
+    if ([".js", ".mjs", ".cjs"].includes(extension))
+        return typescript_1.default.ScriptKind.JS;
+    if (extension === ".jsx")
+        return typescript_1.default.ScriptKind.JSX;
+    return typescript_1.default.ScriptKind.TS;
+}
+function isRegularFile(file) {
+    try {
+        return fs.statSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function hashFiles(files) {
+    const hash = crypto.createHash("sha256");
+    for (const file of uniquePaths(files))
+        hash.update(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) {
+    return [...new Map(files.map((file) => [pathKey(file), path.normalize(file)])).values()].sort();
+}
+function isInside(root, file) {
+    const relative = path.relative(root, path.resolve(file));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+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 errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function readErrorCode(error) {
+    return error && typeof error === "object" && typeof error.code === "string"
+        ? error.code
+        : null;
+}