@automaton-labs/aib 0.0.6 → 0.0.8

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

@@ -0,0 +1,639 @@
+"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.applyStandaloneSemanticMoveTransaction = applyStandaloneSemanticMoveTransaction;
+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_text_edit_executor_1 = require("../commands/file-text-edit-executor");
+const file_mutation_discovery_1 = require("./file-mutation-discovery");
+const semantic_move_plan_hash_1 = require("./semantic-move-plan-hash");
+const semantic_move_declarations_1 = require("./semantic-move-declarations");
+class StagePreparationCleanupError extends Error {
+    stageFile;
+    cleanupError;
+    constructor(cause, stageFile, cleanupError) {
+        super(`${errorMessage(cause)} Stage cleanup failed: ${errorMessage(cleanupError)}`);
+        this.name = "StagePreparationCleanupError";
+        this.stageFile = stageFile;
+        this.cleanupError = errorMessage(cleanupError);
+    }
+}
+const defaultDependencies = {
+    fs,
+    computeWorkspaceFingerprint: file_mutation_discovery_1.computeFileMutationWorkspaceFingerprint
+};
+function applyStandaloneSemanticMoveTransaction(input, dependencies = defaultDependencies) {
+    const root = path.resolve(input.workspaceRoot);
+    const validation = validatePlan(root, input.plan);
+    if (!validation.ok)
+        return failure(validation.code, validation.error);
+    const targetEdit = input.plan.edits.find((edit) => samePath(edit.fileName, input.plan.targetFile));
+    const targetExisted = targetEdit.expectedExists;
+    const existingEdits = input.plan.edits.filter((edit) => edit.expectedExists);
+    const sourceEdit = existingEdits.find((edit) => samePath(edit.fileName, input.plan.sourceFile));
+    let existing = [];
+    let target = null;
+    const createdDirs = [];
+    let targetClaimed = false;
+    const attempted = [];
+    const prepareStartedAt = input.metrics?.start();
+    let prepareEnded = false;
+    let applyStartedAt;
+    let applyEnded = false;
+    const endPrepare = () => {
+        if (prepareEnded || prepareStartedAt === undefined)
+            return;
+        prepareEnded = true;
+        input.metrics?.end("transaction.prepare", prepareStartedAt);
+    };
+    const endApply = () => {
+        if (applyEnded || applyStartedAt === undefined)
+            return;
+        applyEnded = true;
+        input.metrics?.end("transaction.apply", applyStartedAt);
+    };
+    try {
+        if (dependencies.fs.existsSync(input.plan.targetFile) !== targetExisted) {
+            throw typed("SEMANTIC_MOVE_TARGET_CHANGED", "Target existence changed before semantic move apply.");
+        }
+        const realRoot = dependencies.fs.realpathSync(root);
+        assertWorkspaceFingerprint(root, input.plan, input.computeWorkspaceFingerprint ?? dependencies.computeWorkspaceFingerprint, "SEMANTIC_MOVE_COMMIT_PREFLIGHT_STALE");
+        existing = existingEdits.map((edit) => prepareExistingFile(root, realRoot, edit, dependencies.fs));
+        for (const item of existing) {
+            item.descriptor = dependencies.fs.openSync(item.file, "r+");
+            assertDescriptorSnapshot(item, dependencies.fs, item.originalBytes, "File changed while acquiring semantic move ownership.");
+            assertOwnedPath(item, dependencies.fs, item.originalBytes, "File path changed while acquiring semantic move ownership.");
+        }
+        if (!targetExisted) {
+            createdDirs.push(...ensureDirectoryTree(path.dirname(input.plan.targetFile), dependencies.fs));
+            const parentAuthority = captureTargetParentAuthority(root, realRoot, input.plan.targetFile, dependencies.fs);
+            if (dependencies.fs.existsSync(input.plan.targetFile))
+                throw typed("SEMANTIC_MOVE_TARGET_CHANGED", "Target path exists before no-replace claim.");
+            const sourceMode = sourceEditMode(sourceEdit.fileName, dependencies.fs);
+            const targetBytes = Buffer.from((0, file_text_edit_executor_1.applyTextChanges)(targetEdit.expectedText, targetEdit.textChanges), "utf8");
+            target = createOwnedStagedTarget(input.plan.targetFile, targetBytes, sourceMode, parentAuthority, dependencies.fs);
+        }
+        dependencies.onPhase?.("beforeFinalPreflight", null, -1);
+        dependencies.checkInterrupted?.();
+        assertWorkspaceFingerprint(root, input.plan, input.computeWorkspaceFingerprint ?? dependencies.computeWorkspaceFingerprint, "SEMANTIC_MOVE_COMMIT_PREFLIGHT_STALE");
+        if (dependencies.fs.existsSync(input.plan.targetFile) !== targetExisted)
+            throw typed("SEMANTIC_MOVE_TARGET_CHANGED", "Target existence changed at the final boundary.");
+        for (const item of existing) {
+            assertDescriptorSnapshot(item, dependencies.fs, item.originalBytes, "File changed at the final semantic move boundary.");
+            assertOwnedPath(item, dependencies.fs, item.originalBytes, "File path changed at the final semantic move boundary.");
+        }
+        if (target)
+            assertStagedTarget(target, dependencies.fs, false, "Staged target changed before no-replace claim.");
+        const writeSet = uniquePaths([input.plan.targetFile, ...existing.map((item) => item.file)]);
+        input.beforeApply?.(writeSet);
+        dependencies.checkInterrupted?.();
+        if (dependencies.fs.existsSync(input.plan.targetFile) !== targetExisted)
+            throw typed("SEMANTIC_MOVE_TARGET_CHANGED", "Target existence changed after write-set publication.");
+        assertWorkspaceFingerprint(root, input.plan, input.computeWorkspaceFingerprint ?? dependencies.computeWorkspaceFingerprint, "SEMANTIC_MOVE_COMMIT_PREFLIGHT_STALE");
+        for (const item of existing) {
+            assertDescriptorSnapshot(item, dependencies.fs, item.originalBytes, "File changed after write-set publication.");
+            assertOwnedPath(item, dependencies.fs, item.originalBytes, "File path changed after write-set publication.");
+        }
+        if (target)
+            assertStagedTarget(target, dependencies.fs, false, "Staged target changed after write-set publication.");
+        endPrepare();
+        applyStartedAt = input.metrics?.start();
+        if (target) {
+            dependencies.fs.linkSync(target.stageFile, target.targetFile);
+            targetClaimed = true;
+            assertStagedTarget(target, dependencies.fs, true, "Target ownership claim changed or was replaced.");
+            dependencies.onPhase?.("afterTargetClaim", target.targetFile, -1);
+        }
+        for (const [index, item] of existing.entries()) {
+            dependencies.onPhase?.("beforeWrite", item.file, index);
+            dependencies.checkInterrupted?.();
+            if (target)
+                assertStagedTarget(target, dependencies.fs, true, "Target was replaced before an existing-file write.");
+            assertDescriptorSnapshot(item, dependencies.fs, item.originalBytes, "File changed before its semantic move write.");
+            assertOwnedPath(item, dependencies.fs, item.originalBytes, "File path changed before its semantic move write.");
+            attempted.push(item);
+            writeExact(item, item.finalBytes, dependencies.fs);
+            dependencies.onPhase?.("afterWrite", item.file, index);
+        }
+        dependencies.onPhase?.("beforeFinalVerify", null, existing.length);
+        dependencies.checkInterrupted?.();
+        for (const item of existing) {
+            assertDescriptorSnapshot(item, dependencies.fs, item.finalBytes, "Written file changed before semantic move commit.");
+            assertOwnedPath(item, dependencies.fs, item.finalBytes, "Written path was replaced before semantic move commit.");
+        }
+        if (target) {
+            assertStagedTarget(target, dependencies.fs, true, "Target changed before semantic move commit.");
+            removeOwnedPath(target.stageFile, target.identity, dependencies.fs);
+            assertOwnedTarget(target, dependencies.fs, "Target changed while releasing staged ownership.");
+        }
+        endApply();
+    }
+    catch (error) {
+        endPrepare();
+        endApply();
+        const rollbackStartedAt = input.metrics?.start();
+        const result = rollback(error, attempted, existing, target, targetClaimed, createdDirs, dependencies);
+        if (rollbackStartedAt !== undefined)
+            input.metrics?.end("transaction.rollback", rollbackStartedAt);
+        closeExisting(existing, dependencies.fs);
+        closeTarget(target, dependencies.fs);
+        return result;
+    }
+    closeExisting(existing, dependencies.fs);
+    closeTarget(target, dependencies.fs);
+    return {
+        ok: true,
+        savedFiles: uniquePaths([input.plan.targetFile, ...existing.map((item) => item.file)]),
+        touchedFiles: uniquePaths([input.plan.targetFile, ...existing.map((item) => item.file)]),
+        editCount: input.plan.edits.reduce((sum, edit) => sum + edit.textChanges.length, 0)
+    };
+}
+function validatePlan(root, plan) {
+    if (!plan.complete)
+        return { ok: false, code: plan.code, error: plan.error ?? "Standalone semantic move plan is incomplete." };
+    if (!plan.planHash || (0, semantic_move_plan_hash_1.computeSemanticMovePlanHash)(plan) !== plan.planHash) {
+        return { ok: false, code: "SEMANTIC_MOVE_PLAN_PAYLOAD_CHANGED", error: "Semantic move plan payload changed after planner authorization." };
+    }
+    if (!samePath(root, plan.workspaceRoot) || !plan.discovery.workspaceFingerprint || !plan.snapshotHash ||
+        !isInside(root, plan.sourceFile) || !isInside(root, plan.targetFile) || samePath(plan.sourceFile, plan.targetFile)) {
+        return { ok: false, code: "SEMANTIC_MOVE_PLAN_IDENTITY_INVALID", error: "Planner workspace/source/target identity is missing or mismatched." };
+    }
+    if (plan.entities.length === 0 || plan.edits.length < 2) {
+        return { ok: false, code: "SEMANTIC_MOVE_PLAN_EMPTY", error: "Semantic move requires entities plus source and target edits." };
+    }
+    const files = new Set();
+    let sourceEdit = null;
+    let targetEdit = null;
+    for (const edit of plan.edits) {
+        const file = path.resolve(edit.fileName);
+        const key = pathKey(file);
+        if (!isInside(root, file) || files.has(key)) {
+            return { ok: false, code: "SEMANTIC_MOVE_EDIT_SCOPE_INVALID", error: `Invalid or duplicate semantic move edit: ${edit.fileName}.` };
+        }
+        files.add(key);
+        if (samePath(file, plan.sourceFile))
+            sourceEdit = edit;
+        if (samePath(file, plan.targetFile))
+            targetEdit = edit;
+        const isTarget = samePath(file, plan.targetFile);
+        if ((isTarget && edit.isNewFile !== !edit.expectedExists) || (!isTarget && (edit.isNewFile || !edit.expectedExists))) {
+            return { ok: false, code: "SEMANTIC_MOVE_EDIT_SHAPE_INVALID", error: `New/existing file shape is invalid for ${edit.fileName}.` };
+        }
+        if (sha256(Buffer.from(edit.expectedText, "utf8")) !== edit.expectedHash || edit.textChanges.length === 0) {
+            return { ok: false, code: "SEMANTIC_MOVE_EDIT_SNAPSHOT_INVALID", error: `Expected bytes/hash or changes are invalid for ${edit.fileName}.` };
+        }
+        const spans = validateTextChanges(edit.expectedText, edit.textChanges);
+        if (!spans.ok)
+            return spans;
+    }
+    if (!sourceEdit || !targetEdit) {
+        return { ok: false, code: "SEMANTIC_MOVE_REQUIRED_EDIT_MISSING", error: "Exact source and target edits are required." };
+    }
+    const finalSource = (0, file_text_edit_executor_1.applyTextChanges)(sourceEdit.expectedText, sourceEdit.textChanges);
+    const finalTarget = (0, file_text_edit_executor_1.applyTextChanges)(targetEdit.expectedText, targetEdit.textChanges);
+    if (!finalTarget)
+        return { ok: false, code: "SEMANTIC_MOVE_TARGET_EMPTY", error: "Planned target content is empty." };
+    for (const entity of plan.entities) {
+        const expectedCount = (0, semantic_move_declarations_1.countSemanticMoveDeclarations)(plan.sourceFile, sourceEdit.expectedText, entity.name, entity.kind);
+        if (expectedCount !== entity.declarationStarts.length || (0, semantic_move_declarations_1.countSemanticMoveDeclarations)(plan.sourceFile, finalSource, entity.name, entity.kind) !== 0 ||
+            (0, semantic_move_declarations_1.countSemanticMoveDeclarations)(plan.targetFile, finalTarget, entity.name, entity.kind) !== expectedCount) {
+            return { ok: false, code: "SEMANTIC_MOVE_STRUCTURE_DIVERGENCE", error: `Move payload does not transfer ${entity.name} exactly.` };
+        }
+    }
+    return { ok: true };
+}
+function prepareExistingFile(root, realRoot, edit, fsAdapter) {
+    const file = path.resolve(edit.fileName);
+    const realFile = fsAdapter.realpathSync(file);
+    if (!isInside(root, file) || !isInside(realRoot, realFile))
+        throw typed("SEMANTIC_MOVE_EDIT_OUTSIDE_WORKSPACE", `Edit resolves outside workspace: ${file}.`);
+    const stat = fsAdapter.statSync(file);
+    const identity = readIdentity(file, stat);
+    const mode = stat.mode & 0o7777;
+    const originalBytes = fsAdapter.readFileSync(file);
+    if (sha256(originalBytes) !== edit.expectedHash || !Buffer.from(edit.expectedText, "utf8").equals(originalBytes)) {
+        throw typed("SEMANTIC_MOVE_EDIT_SNAPSHOT_CHANGED", `Exact planned bytes changed: ${file}.`);
+    }
+    const finalBytes = Buffer.from((0, file_text_edit_executor_1.applyTextChanges)(edit.expectedText, edit.textChanges), "utf8");
+    if (finalBytes.equals(originalBytes))
+        throw typed("SEMANTIC_MOVE_EDIT_NOOP", `Semantic move edit does not change ${file}.`);
+    return { file, originalBytes, finalBytes, identity, mode, realFile, realRoot, workspaceRoot: root, descriptor: null };
+}
+function createOwnedStagedTarget(targetFile, bytes, mode, parent, fsAdapter) {
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+        const stageFile = path.join(path.dirname(targetFile), `.${path.basename(targetFile)}.aib-semantic-move-${process.pid}-${crypto.randomUUID()}`);
+        let descriptor;
+        try {
+            descriptor = fsAdapter.openSync(stageFile, "wx+", mode);
+        }
+        catch (error) {
+            if (errorCode(error, "") === "EEXIST")
+                continue;
+            throw error;
+        }
+        let failed = null;
+        let identity = null;
+        try {
+            const openedStat = fsAdapter.fstatSync(descriptor);
+            identity = readIdentity(stageFile, openedStat);
+            fsAdapter.fchmodSync(descriptor, mode);
+            const stat = fsAdapter.fstatSync(descriptor);
+            if (!sameIdentity(identity, readIdentity(stageFile, stat)))
+                throw new Error("Staged target identity changed during preparation.");
+            if ((stat.mode & 0o7777) !== mode)
+                throw new Error("Staged target mode differs from source mode.");
+            writeDescriptor(descriptor, bytes, fsAdapter);
+            fsAdapter.fsyncSync(descriptor);
+            const target = { stageFile, targetFile, bytes, identity, mode, descriptor, parent };
+            assertStagedTarget(target, fsAdapter, false, "Staged target changed during preparation.");
+            return target;
+        }
+        catch (error) {
+            failed = error;
+        }
+        try {
+            fsAdapter.closeSync(descriptor);
+        }
+        catch (error) {
+            failed ??= error;
+        }
+        let cleanupFile = stageFile;
+        try {
+            if (!identity)
+                throw new Error(`Opened staged target identity is unavailable for ${stageFile}.`);
+            cleanupFile = locateOwnedPreparationPath(parent, stageFile, fsAdapter);
+            removeOwnedPath(cleanupFile, identity, fsAdapter);
+        }
+        catch (cleanupError) {
+            throw new StagePreparationCleanupError(failed, cleanupFile, cleanupError);
+        }
+        throw failed;
+    }
+    throw new Error(`Could not reserve a staged semantic move target for ${targetFile}.`);
+}
+function rollback(cause, attempted, all, target, targetClaimed, createdDirs, dependencies) {
+    if (cause instanceof StagePreparationCleanupError) {
+        cleanupDirectories(createdDirs, dependencies.fs);
+        return {
+            ok: false,
+            code: "SEMANTIC_MOVE_ROLLBACK_FAILED",
+            error: cause.message,
+            rollback: "failed",
+            potentiallyModifiedFiles: [cause.stageFile],
+            rollbackErrors: [`${cause.stageFile}: ${cause.cleanupError}`]
+        };
+    }
+    const mutated = targetClaimed || attempted.length > 0;
+    if (!mutated) {
+        cleanupTarget(target, false, dependencies.fs);
+        cleanupDirectories(createdDirs, dependencies.fs);
+        return failure(errorCode(cause, "SEMANTIC_MOVE_TRANSACTION_FAILED"), errorMessage(cause));
+    }
+    const potentiallyModified = new Map();
+    if (targetClaimed && target)
+        potentiallyModified.set(pathKey(target.targetFile), target.targetFile);
+    for (const item of attempted)
+        potentiallyModified.set(pathKey(item.file), item.file);
+    const rollbackErrors = [];
+    for (const [reverseIndex, item] of [...attempted].reverse().entries()) {
+        try {
+            dependencies.onPhase?.("beforeRollback", item.file, reverseIndex);
+            writeExact(item, item.originalBytes, dependencies.fs);
+            assertDescriptorSnapshot(item, dependencies.fs, item.originalBytes, "Rollback bytes or mode differ from original.");
+            assertOwnedPath(item, dependencies.fs, item.originalBytes, "Rollback refused a foreign or replaced path.");
+            potentiallyModified.delete(pathKey(item.file));
+        }
+        catch (error) {
+            rollbackErrors.push(`${item.file}: ${errorMessage(error)}`);
+        }
+    }
+    if (targetClaimed && target) {
+        try {
+            removeOwnedTargetPath(target, target.targetFile, dependencies.fs);
+            potentiallyModified.delete(pathKey(target.targetFile));
+        }
+        catch (error) {
+            rollbackErrors.push(`${target.targetFile}: ${errorMessage(error)}`);
+        }
+    }
+    try {
+        cleanupTarget(target, true, dependencies.fs);
+    }
+    catch (error) {
+        rollbackErrors.push(`${target?.stageFile ?? "staged target"}: ${errorMessage(error)}`);
+        if (target)
+            potentiallyModified.set(pathKey(target.stageFile), target.stageFile);
+    }
+    cleanupDirectories(createdDirs, dependencies.fs);
+    const residual = uniquePaths([...potentiallyModified.values()]);
+    return {
+        ok: false,
+        code: rollbackErrors.length === 0 ? "SEMANTIC_MOVE_TRANSACTION_FAILED" : "SEMANTIC_MOVE_ROLLBACK_FAILED",
+        error: rollbackErrors.length === 0 ? errorMessage(cause) : `${errorMessage(cause)} Rollback failed: ${rollbackErrors.join("; ")}`,
+        rollback: rollbackErrors.length === 0 ? "ok" : "failed",
+        potentiallyModifiedFiles: residual,
+        ...(rollbackErrors.length > 0 ? { rollbackErrors } : {})
+    };
+}
+function writeExact(item, bytes, fsAdapter) {
+    const descriptor = requireDescriptor(item);
+    fsAdapter.ftruncateSync(descriptor, 0);
+    writeDescriptor(descriptor, bytes, fsAdapter);
+    fsAdapter.fchmodSync(descriptor, item.mode);
+    fsAdapter.fsyncSync(descriptor);
+    assertDescriptorSnapshot(item, fsAdapter, bytes, "Descriptor bytes or mode differ from requested semantic move state.");
+}
+function writeDescriptor(descriptor, bytes, fsAdapter) {
+    let offset = 0;
+    while (offset < bytes.length) {
+        const written = fsAdapter.writeSync(descriptor, bytes, offset, bytes.length - offset, offset);
+        if (written <= 0)
+            throw new Error("Descriptor write made no progress.");
+        offset += written;
+    }
+}
+function assertDescriptorSnapshot(item, fsAdapter, expectedBytes, error) {
+    const descriptor = requireDescriptor(item);
+    const stat = fsAdapter.fstatSync(descriptor);
+    if (!sameIdentity(item.identity, readIdentity(item.file, stat)) || (stat.mode & 0o7777) !== item.mode ||
+        !readDescriptor(descriptor, stat.size, fsAdapter).equals(expectedBytes))
+        throw new Error(error);
+}
+function assertOwnedPath(item, fsAdapter, expectedBytes, error) {
+    const currentRoot = fsAdapter.realpathSync(item.workspaceRoot);
+    const currentFile = fsAdapter.realpathSync(item.file);
+    const stat = fsAdapter.statSync(item.file);
+    const bytes = fsAdapter.readFileSync(item.file);
+    if (!samePath(currentRoot, item.realRoot) || !samePath(currentFile, item.realFile) || !isInside(currentRoot, currentFile) ||
+        !sameIdentity(item.identity, readIdentity(item.file, stat)) || (stat.mode & 0o7777) !== item.mode || !bytes.equals(expectedBytes)) {
+        throw new Error(error);
+    }
+}
+function assertStagedTarget(target, fsAdapter, claimed, error) {
+    assertTargetParentAuthority(target.parent, fsAdapter, error);
+    const stat = fsAdapter.fstatSync(target.descriptor);
+    if (!sameIdentity(target.identity, readIdentity(target.stageFile, stat)) || (stat.mode & 0o7777) !== target.mode ||
+        !readDescriptor(target.descriptor, stat.size, fsAdapter).equals(target.bytes))
+        throw new Error(error);
+    assertExactOwnedFile(target.stageFile, target.identity, target.bytes, target.mode, fsAdapter, error);
+    if (claimed)
+        assertOwnedTarget(target, fsAdapter, error);
+}
+function assertOwnedTarget(target, fsAdapter, error) {
+    assertExactOwnedFile(target.targetFile, target.identity, target.bytes, target.mode, fsAdapter, error);
+}
+function assertExactOwnedFile(file, identity, bytes, mode, fsAdapter, error) {
+    if (!fsAdapter.existsSync(file))
+        throw new Error(error);
+    const stat = fsAdapter.statSync(file);
+    if (!sameIdentity(identity, readIdentity(file, stat)) || (stat.mode & 0o7777) !== mode ||
+        !fsAdapter.readFileSync(file).equals(bytes))
+        throw new Error(error);
+}
+function cleanupTarget(target, strict, fsAdapter) {
+    if (!target)
+        return;
+    try {
+        removeOwnedTargetPath(target, target.stageFile, fsAdapter);
+    }
+    catch (error) {
+        if (strict)
+            throw error;
+    }
+}
+function removeOwnedTargetPath(target, lexicalFile, fsAdapter) {
+    const ownedParent = locateOwnedTargetParent(target.parent, fsAdapter);
+    if (!ownedParent)
+        throw new Error(`Owned target parent is no longer reachable for ${lexicalFile}.`);
+    const ownedFile = path.join(ownedParent, path.basename(lexicalFile));
+    removeOwnedPath(ownedFile, target.identity, fsAdapter);
+}
+function locateOwnedPreparationPath(parent, lexicalFile, fsAdapter) {
+    const ownedParent = locateOwnedTargetParent(parent, fsAdapter);
+    if (!ownedParent)
+        throw new Error(`Owned target parent is no longer reachable for ${lexicalFile}.`);
+    return path.join(ownedParent, path.basename(lexicalFile));
+}
+function removeOwnedPath(file, identity, fsAdapter) {
+    if (!fsAdapter.existsSync(file))
+        return;
+    if (!sameIdentity(readIdentity(file, fsAdapter.statSync(file)), identity))
+        throw new Error(`Refusing to remove foreign path ${file}.`);
+    fsAdapter.unlinkSync(file);
+    if (fsAdapter.existsSync(file))
+        throw new Error(`Owned path still exists after cleanup: ${file}.`);
+}
+function validateTextChanges(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 (!Number.isSafeInteger(change.span.start) || !Number.isSafeInteger(change.span.length) || change.span.start < 0 ||
+            change.span.length < 0 || change.span.start + change.span.length > text.length || typeof change.newText !== "string") {
+            return { ok: false, code: "SEMANTIC_MOVE_EDIT_SPAN_INVALID", error: "Semantic move edit has an invalid span or payload." };
+        }
+        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: "Semantic move edits overlap." };
+        }
+    }
+    return { ok: true };
+}
+function assertWorkspaceFingerprint(root, plan, computeWorkspaceFingerprint, code) {
+    if (computeWorkspaceFingerprint(root) !== plan.discovery.workspaceFingerprint) {
+        throw typed(code, "Workspace files, configs, packages, or consumers changed before semantic move apply.");
+    }
+}
+function ensureDirectoryTree(directory, fsAdapter) {
+    const missing = [];
+    let current = directory;
+    while (!fsAdapter.existsSync(current)) {
+        missing.push(current);
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    fsAdapter.mkdirSync(directory, { recursive: true });
+    return missing.map((created) => ({ directory: created, identity: readDirectoryIdentity(created, fsAdapter.statSync(created)) }));
+}
+function cleanupDirectories(directories, fsAdapter) {
+    for (const item of directories) {
+        try {
+            if (sameIdentity(item.identity, readDirectoryIdentity(item.directory, fsAdapter.statSync(item.directory)))) {
+                fsAdapter.rmdirSync(item.directory);
+            }
+        }
+        catch { /* retained if replaced, non-empty, or concurrently reused */ }
+    }
+}
+function captureTargetParentAuthority(workspaceRoot, realWorkspaceRoot, targetFile, fsAdapter) {
+    const lexicalParent = path.dirname(targetFile);
+    const realParent = fsAdapter.realpathSync(lexicalParent);
+    if (!isInside(realWorkspaceRoot, realParent)) {
+        throw typed("SEMANTIC_MOVE_TARGET_OUTSIDE_WORKSPACE", "Target parent resolves outside the real workspace root.");
+    }
+    const stat = fsAdapter.statSync(lexicalParent);
+    const authority = {
+        workspaceRoot,
+        realWorkspaceRoot,
+        lexicalParent,
+        realParent,
+        identity: readDirectoryIdentity(lexicalParent, stat),
+        mode: stat.mode & 0o7777
+    };
+    assertTargetParentAuthority(authority, fsAdapter, "Target parent changed while authority was captured.");
+    return authority;
+}
+function assertTargetParentAuthority(authority, fsAdapter, error) {
+    const realRoot = fsAdapter.realpathSync(authority.workspaceRoot);
+    const realParent = fsAdapter.realpathSync(authority.lexicalParent);
+    const stat = fsAdapter.statSync(authority.lexicalParent);
+    if (!samePath(realRoot, authority.realWorkspaceRoot) || !samePath(realParent, authority.realParent) ||
+        !isInside(realRoot, realParent) || !sameIdentity(authority.identity, readDirectoryIdentity(authority.lexicalParent, stat)) ||
+        (stat.mode & 0o7777) !== authority.mode)
+        throw new Error(error);
+}
+function locateOwnedTargetParent(authority, fsAdapter) {
+    const candidates = [
+        authority.lexicalParent,
+        ...fsAdapter.readdirSync(path.dirname(authority.lexicalParent)).map((name) => path.join(path.dirname(authority.lexicalParent), name))
+    ];
+    for (const candidate of candidates) {
+        try {
+            if (sameIdentity(authority.identity, readDirectoryIdentity(candidate, fsAdapter.statSync(candidate))))
+                return candidate;
+        }
+        catch { /* not the owned directory */ }
+    }
+    return null;
+}
+function readDescriptor(descriptor, size, fsAdapter) {
+    const output = Buffer.alloc(size);
+    let offset = 0;
+    while (offset < size) {
+        const read = fsAdapter.readSync(descriptor, output, offset, size - offset, offset);
+        if (read <= 0)
+            throw new Error("Descriptor read ended before the expected size.");
+        offset += read;
+    }
+    return output;
+}
+function readIdentity(file, stat) {
+    if (!stat.isFile() || !Number.isFinite(stat.dev) || !Number.isFinite(stat.ino) || stat.ino === 0) {
+        throw new Error(`Stable regular-file identity is unavailable for ${file}.`);
+    }
+    return { dev: stat.dev, ino: stat.ino };
+}
+function readDirectoryIdentity(file, stat) {
+    if (!stat.isDirectory() || !Number.isFinite(stat.dev) || !Number.isFinite(stat.ino) || stat.ino === 0) {
+        throw new Error(`Stable directory identity is unavailable for ${file}.`);
+    }
+    return { dev: stat.dev, ino: stat.ino };
+}
+function sourceEditMode(file, fsAdapter) {
+    return fsAdapter.statSync(file).mode & 0o7777;
+}
+function closeExisting(files, fsAdapter) {
+    for (const item of files) {
+        if (item.descriptor === null)
+            continue;
+        try {
+            fsAdapter.closeSync(item.descriptor);
+        }
+        catch { /* result already determined */ }
+        item.descriptor = null;
+    }
+}
+function closeTarget(target, fsAdapter) {
+    if (!target)
+        return;
+    try {
+        fsAdapter.closeSync(target.descriptor);
+    }
+    catch { /* result already determined */ }
+}
+function requireDescriptor(item) {
+    if (item.descriptor === null)
+        throw new Error(`Descriptor is unavailable for ${item.file}.`);
+    return item.descriptor;
+}
+function sameIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+function scriptKindForFile(file) {
+    const extension = path.extname(file).toLowerCase();
+    if (extension === ".tsx")
+        return typescript_1.default.ScriptKind.TSX;
+    if (extension === ".jsx")
+        return typescript_1.default.ScriptKind.JSX;
+    if ([".js", ".mjs", ".cjs"].includes(extension))
+        return typescript_1.default.ScriptKind.JS;
+    return typescript_1.default.ScriptKind.TS;
+}
+function isInside(root, file) {
+    const relative = path.relative(path.resolve(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 uniquePaths(files) {
+    return [...new Map(files.map((file) => [pathKey(file), path.normalize(file)])).values()].sort();
+}
+function sha256(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}
+function typed(code, message) {
+    return Object.assign(new Error(message), { code });
+}
+function errorCode(error, fallback) {
+    return error && typeof error === "object" && typeof error.code === "string"
+        ? error.code
+        : fallback;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function failure(code, error) {
+    return { ok: false, code, error, rollback: "not-needed", potentiallyModifiedFiles: [] };
+}