@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/mutation/file-mutation-eta.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateFileMutationDurationMs = estimateFileMutationDurationMs;
+exports.estimateFileMutationEta = estimateFileMutationEta;
+exports.estimateFileMutationDefaultDurationMs = estimateFileMutationDefaultDurationMs;
+exports.estimateFileMutationScanDurationMs = estimateFileMutationScanDurationMs;
+const FILE_MUTATION_SCAN_MIN_MS = 10_000;
+const FILE_MUTATION_SCAN_MAX_MS = 180_000;
+const FILE_MUTATION_SCAN_BASE_MS = 4_000;
+const FILE_MUTATION_SCAN_ROW_MS = 500;
+const FILE_MUTATION_SCAN_ADDITIONAL_SOURCE_MS = 5_000;
+const FILE_MUTATION_SCAN_TARGET_DIR_MS = 500;
+const FILE_MUTATION_SCAN_DIR_TO_CREATE_MS = 500;
+const FILE_MUTATION_SCAN_IMPORTING_FILE_MS = 200;
+const FILE_MUTATION_SCAN_IMPORTING_FILE_SQRT_MS = 1_750;
+const FILE_MUTATION_SCAN_EXTRA_IMPORT_STATEMENT_MS = 15;
+const FILE_MUTATION_SCAN_BARREL_EXPORT_MS = 200;
+function estimateFileMutationDurationMs(input) {
+    return estimateFileMutationEta(toEtaInput(input)).selectedMs;
+}
+function estimateFileMutationEta(input) {
+    const normalized = normalizeInput(input);
+    const defaultMs = estimateFileMutationDefaultDurationMs(normalized);
+    const scanMs = estimateFileMutationScanDurationMs(normalized);
+    const scan = buildScanStatus(normalized);
+    return {
+        defaultMs,
+        scanMs,
+        selectedMs: scanMs ?? defaultMs,
+        source: scanMs === null ? "default" : "scan",
+        scan
+    };
+}
+function estimateFileMutationDefaultDurationMs(input) {
+    const normalized = normalizeInput(input);
+    return 90_000 +
+        normalized.rowCount * 25_000 +
+        normalized.targetDirCount * 5_000 +
+        normalized.dirsToCreate * 5_000;
+}
+function estimateFileMutationScanDurationMs(input) {
+    const normalized = normalizeInput(input);
+    const scan = buildScanStatus(normalized);
+    if (!scan.available) {
+        return null;
+    }
+    const additionalSourceCount = Math.max(0, normalized.sourceFileCount - 1);
+    const extraImportStatementCount = Math.max(0, normalized.importStatementCount - normalized.importingFileCount);
+    return clampMs(FILE_MUTATION_SCAN_BASE_MS +
+        normalized.rowCount * FILE_MUTATION_SCAN_ROW_MS +
+        additionalSourceCount * FILE_MUTATION_SCAN_ADDITIONAL_SOURCE_MS +
+        normalized.targetDirCount * FILE_MUTATION_SCAN_TARGET_DIR_MS +
+        normalized.dirsToCreate * FILE_MUTATION_SCAN_DIR_TO_CREATE_MS +
+        Math.sqrt(normalized.importingFileCount) * FILE_MUTATION_SCAN_IMPORTING_FILE_SQRT_MS +
+        normalized.importingFileCount * FILE_MUTATION_SCAN_IMPORTING_FILE_MS +
+        extraImportStatementCount * FILE_MUTATION_SCAN_EXTRA_IMPORT_STATEMENT_MS +
+        normalized.barrelExportCount * FILE_MUTATION_SCAN_BARREL_EXPORT_MS, FILE_MUTATION_SCAN_MIN_MS, FILE_MUTATION_SCAN_MAX_MS);
+}
+function buildScanStatus(input) {
+    const reason = input.scanTruncated
+        ? "truncated"
+        : input.sourceFileCount <= 0
+            ? "no-source-files"
+            : input.existingSourceFileCount <= 0
+                ? "missing-source-files"
+                : "ok";
+    return {
+        available: reason === "ok",
+        reason,
+        importingFileCount: input.importingFileCount,
+        importStatementCount: input.importStatementCount,
+        barrelExportCount: input.barrelExportCount,
+        sourceFileCount: input.sourceFileCount,
+        existingSourceFileCount: input.existingSourceFileCount,
+        truncated: input.scanTruncated
+    };
+}
+function toEtaInput(input) {
+    return typeof input === "number" ? { rowCount: input } : input;
+}
+function normalizeInput(input) {
+    return {
+        rowCount: readCount(input.rowCount),
+        targetDirCount: readCount(input.targetDirCount),
+        dirsToCreate: readCount(input.dirsToCreate),
+        importingFileCount: readCount(input.importingFileCount),
+        importStatementCount: readCount(input.importStatementCount),
+        barrelExportCount: readCount(input.barrelExportCount),
+        sourceFileCount: readCount(input.sourceFileCount),
+        existingSourceFileCount: readCount(input.existingSourceFileCount),
+        scanTruncated: input.scanTruncated === true
+    };
+}
+function readCount(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.round(value) : 0;
+}
+function clampMs(value, minMs, maxMs) {
+    return Math.min(maxMs, Math.max(minMs, Math.round(value)));
+}

package/dist/mutation/file-mutation-standalone-apply.js

@@ -0,0 +1,584 @@
+"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.applyStandaloneFileMutationTransaction = applyStandaloneFileMutationTransaction;
+exports.removeUnusedImportBindings = removeUnusedImportBindings;
+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 import_rules_1 = require("../config/import-rules");
+const file_text_edit_executor_1 = require("../commands/file-text-edit-executor");
+const file_mutation_discovery_1 = require("./file-mutation-discovery");
+const targeted_import_canonicalizer_1 = require("./targeted-import-canonicalizer");
+function applyStandaloneFileMutationTransaction(input, dependencies = {
+    fs,
+    computeWorkspaceFingerprint: file_mutation_discovery_1.computeFileMutationWorkspaceFingerprint
+}) {
+    if (!input.plan.complete) {
+        return failure(input.plan.code, input.plan.error ?? "Standalone file mutation plan is incomplete.");
+    }
+    const root = path.resolve(input.workspaceRoot);
+    const sourceFile = path.resolve(root, input.sourceFile);
+    const targetFile = path.resolve(root, input.targetFile);
+    const snapshots = new Map(input.plan.fileSnapshots.map((item) => [pathKey(item.file), item]));
+    try {
+        if (dependencies.computeWorkspaceFingerprint(root) !== input.plan.workspaceFingerprint) {
+            return failure("FILE_MUTATION_COMMIT_PREFLIGHT_STALE", "Workspace files, configs, or package metadata changed before apply.");
+        }
+    }
+    catch (error) {
+        return failure("FILE_MUTATION_COMMIT_PREFLIGHT_FAILED", error instanceof Error ? error.message : String(error));
+    }
+    if (!dependencies.fs.existsSync(sourceFile) || !dependencies.fs.statSync(sourceFile).isFile()) {
+        return failure("FILE_MUTATION_SOURCE_CHANGED", "Source file is missing or is no longer a file.");
+    }
+    if (dependencies.fs.existsSync(targetFile)) {
+        return failure("FILE_MUTATION_TARGET_CHANGED", "Target path exists immediately before apply.");
+    }
+    if (input.plan.targetSnapshot.exists || !samePath(input.plan.targetSnapshot.file, targetFile)) {
+        return failure("FILE_MUTATION_TARGET_SNAPSHOT_MISMATCH", "Planner target snapshot does not authorize this target path.");
+    }
+    const originals = new Map();
+    for (const snapshot of input.plan.fileSnapshots) {
+        let text;
+        try {
+            text = dependencies.fs.readFileSync(snapshot.file, "utf8");
+        }
+        catch {
+            return failure("FILE_MUTATION_TOUCHED_FILE_CHANGED", `Planned file disappeared before apply: ${snapshot.file}`);
+        }
+        if (sha256(text) !== snapshot.hash) {
+            return failure("FILE_MUTATION_TOUCHED_FILE_CHANGED", `Planned file changed before apply: ${snapshot.file}`);
+        }
+        originals.set(pathKey(snapshot.file), text);
+    }
+    if (!snapshots.has(pathKey(sourceFile))) {
+        return failure("FILE_MUTATION_SOURCE_SNAPSHOT_MISSING", "Planner did not publish the source file snapshot.");
+    }
+    const changesByFile = new Map();
+    for (const edit of input.plan.edits) {
+        const key = pathKey(edit.fileName);
+        if (!snapshots.has(key)) {
+            return failure("FILE_MUTATION_EDIT_SNAPSHOT_MISSING", `Planner edit lacks an exact snapshot: ${edit.fileName}`);
+        }
+        changesByFile.set(key, [...(changesByFile.get(key) ?? []), ...edit.textChanges]);
+    }
+    const prepared = new Map();
+    const cleanup = [];
+    let assetImportEditCount = 0;
+    for (const snapshot of input.plan.fileSnapshots) {
+        const key = pathKey(snapshot.file);
+        const originalText = originals.get(key);
+        const changes = changesByFile.get(key) ?? [];
+        const validation = validateTextChanges(changes, originalText.length);
+        if (validation) {
+            return failure(validation.code, `${snapshot.file}: ${validation.error}`);
+        }
+        let nextText = (0, file_text_edit_executor_1.applyTextChanges)(originalText, changes);
+        const destination = samePath(snapshot.file, sourceFile) ? targetFile : snapshot.file;
+        if (samePath(destination, targetFile)) {
+            const assetChanges = buildMovedFileAssetImportTextChanges(sourceFile, targetFile, nextText);
+            const assetValidation = validateTextChanges(assetChanges, nextText.length);
+            if (assetValidation) {
+                return failure(assetValidation.code, `${targetFile}: ${assetValidation.error}`);
+            }
+            nextText = (0, file_text_edit_executor_1.applyTextChanges)(nextText, assetChanges);
+            assetImportEditCount += assetChanges.length;
+        }
+        nextText = (0, targeted_import_canonicalizer_1.formatChangedNamedImports)(originalText, nextText, destination).text;
+        const cleanupEligible = samePath(destination, targetFile) || changes.length > 0;
+        if (import_rules_1.MUTATION_UNUSED_IMPORT_CLEANUP_ENABLED &&
+            cleanupEligible &&
+            input.postProcessImports &&
+            (0, import_rules_1.resolveImportRuleForFile)(destination, input.importRules)?.unusedImports === "remove") {
+            const cleaned = removeUnusedImportBindings(destination, nextText);
+            if (cleaned !== nextText) {
+                cleanup.push({ ok: true, phase: "removeUnusedImports", file: destination, editCount: 1, applied: true, savedFiles: [destination] });
+                nextText = cleaned;
+            }
+        }
+        prepared.set(pathKey(destination), { file: destination, originalText, nextText });
+    }
+    const sourceOriginal = originals.get(pathKey(sourceFile));
+    const targetPrepared = prepared.get(pathKey(targetFile)) ?? {
+        file: targetFile,
+        originalText: sourceOriginal,
+        nextText: sourceOriginal
+    };
+    prepared.set(pathKey(targetFile), targetPrepared);
+    const attemptedWrites = [];
+    const createdDirs = [];
+    let targetClaimed = false;
+    let sourceRemoved = false;
+    let stagedFile = null;
+    let sourceGuard = null;
+    let sourceIdentity = null;
+    let sourceMode = null;
+    let ownedIdentity = null;
+    try {
+        createdDirs.push(...ensureDirectoryTree(path.dirname(targetFile), dependencies.fs));
+        const finalPreflight = verifyFinalCommitPreflight(root, sourceFile, targetFile, input.plan, dependencies);
+        if (finalPreflight) {
+            for (const dir of [...createdDirs].reverse()) {
+                try {
+                    dependencies.fs.rmdirSync(dir);
+                }
+                catch { /* retained if non-empty */ }
+            }
+            return finalPreflight;
+        }
+        sourceIdentity = readRegularFileIdentity(sourceFile, dependencies.fs);
+        sourceMode = dependencies.fs.statSync(sourceFile).mode & 0o7777;
+        const staged = createOwnedStagedFile(targetFile, targetPrepared.nextText, sourceMode, dependencies.fs);
+        stagedFile = staged.file;
+        ownedIdentity = staged.identity;
+        sourceGuard = createUniqueAdjacentPath(sourceFile, "source-guard");
+        dependencies.fs.linkSync(sourceFile, sourceGuard);
+        if (!sameFileIdentity(readRegularFileIdentity(sourceGuard, dependencies.fs), sourceIdentity)) {
+            throw new Error("Source guard identity does not match the exact preflight source.");
+        }
+        dependencies.fs.linkSync(stagedFile, targetFile);
+        targetClaimed = true;
+        if (!sameFileIdentity(readRegularFileIdentity(targetFile, dependencies.fs), ownedIdentity) ||
+            !sameFileIdentity(readRegularFileIdentity(stagedFile, dependencies.fs), ownedIdentity) ||
+            !sameFileIdentity(readRegularFileIdentity(sourceFile, dependencies.fs), sourceIdentity) ||
+            readPermissionBits(targetFile, dependencies.fs) !== sourceMode ||
+            readPermissionBits(stagedFile, dependencies.fs) !== sourceMode ||
+            readPermissionBits(sourceFile, dependencies.fs) !== sourceMode ||
+            sha256(dependencies.fs.readFileSync(targetFile, "utf8")) !== sha256(targetPrepared.nextText)) {
+            throw new Error("Source or staged target identity changed during no-replace ownership claim.");
+        }
+        if (input.forceFailureAfterMove) {
+            throw new Error("Forced file mutation failure after filesystem move for test.");
+        }
+        for (const item of prepared.values()) {
+            if (samePath(item.file, targetFile) || item.nextText === item.originalText) {
+                continue;
+            }
+            attemptedWrites.push(item.file);
+            dependencies.fs.writeFileSync(item.file, item.nextText, "utf8");
+        }
+        assertExactOwnedFile(sourceFile, sourceIdentity, sourceOriginal, sourceMode, dependencies.fs, "Source changed before commit.");
+        assertExactOwnedFile(sourceGuard, sourceIdentity, sourceOriginal, sourceMode, dependencies.fs, "Source guard changed before commit.");
+        assertExactOwnedFile(targetFile, ownedIdentity, targetPrepared.nextText, sourceMode, dependencies.fs, "Target changed before commit.");
+        assertExactOwnedFile(stagedFile, ownedIdentity, targetPrepared.nextText, sourceMode, dependencies.fs, "Staged target changed before commit.");
+        dependencies.fs.unlinkSync(sourceFile);
+        sourceRemoved = true;
+        if (dependencies.fs.existsSync(sourceFile)) {
+            throw new Error("Source path still exists after the final commit unlink.");
+        }
+        assertExactOwnedFile(targetFile, ownedIdentity, targetPrepared.nextText, sourceMode, dependencies.fs, "Target changed at commit.");
+        removeOwnedPath(stagedFile, ownedIdentity, dependencies.fs);
+        stagedFile = null;
+        removeOwnedPath(sourceGuard, sourceIdentity, dependencies.fs);
+        sourceGuard = null;
+    }
+    catch (error) {
+        if (!targetClaimed && attemptedWrites.length === 0) {
+            cleanupOwnedTemp(stagedFile, ownedIdentity, dependencies.fs);
+            cleanupOwnedTemp(sourceGuard, sourceIdentity, dependencies.fs);
+            for (const dir of [...createdDirs].reverse()) {
+                try {
+                    dependencies.fs.rmdirSync(dir);
+                }
+                catch { /* retained if non-empty */ }
+            }
+            const errorCode = readErrorCode(error) === "EEXIST"
+                ? "FILE_MUTATION_TARGET_CHANGED"
+                : readErrorCode(error) === "EXDEV"
+                    ? "FILE_MUTATION_NO_REPLACE_UNSUPPORTED"
+                    : "FILE_MUTATION_TARGET_CLAIM_FAILED";
+            return failure(errorCode, message(error));
+        }
+        const rollbackErrors = [];
+        const potentiallyModified = new Map(attemptedWrites.map((file) => [pathKey(file), path.normalize(file)]));
+        for (const file of uniquePaths(attemptedWrites).reverse()) {
+            if (samePath(file, targetFile)) {
+                continue;
+            }
+            const item = prepared.get(pathKey(file));
+            if (!item)
+                continue;
+            try {
+                dependencies.fs.writeFileSync(file, item.originalText, "utf8");
+                const restored = dependencies.fs.existsSync(file) &&
+                    sha256(dependencies.fs.readFileSync(file, "utf8")) === sha256(item.originalText);
+                if (!restored)
+                    throw new Error("restored bytes do not match the exact preflight snapshot");
+                potentiallyModified.delete(pathKey(file));
+            }
+            catch (restoreError) {
+                rollbackErrors.push(`${file}: ${message(restoreError)}`);
+            }
+        }
+        if (targetClaimed) {
+            potentiallyModified.set(pathKey(sourceFile), path.normalize(sourceFile));
+            potentiallyModified.set(pathKey(targetFile), path.normalize(targetFile));
+            try {
+                if (!sourceIdentity || sourceMode === null)
+                    throw new Error("Source identity or mode was not captured before apply.");
+                if (sourceRemoved && !dependencies.fs.existsSync(sourceFile)) {
+                    if (!sourceGuard)
+                        throw new Error("Source guard is unavailable after commit failure.");
+                    assertExactOwnedFile(sourceGuard, sourceIdentity, sourceOriginal, sourceMode, dependencies.fs, "Source guard changed before rollback.");
+                    dependencies.fs.linkSync(sourceGuard, sourceFile);
+                }
+                assertExactOwnedFile(sourceFile, sourceIdentity, sourceOriginal, sourceMode, dependencies.fs, "Source path is foreign or changed; refusing to overwrite it.");
+                potentiallyModified.delete(pathKey(sourceFile));
+            }
+            catch (restoreError) {
+                rollbackErrors.push(`${sourceFile}: ${message(restoreError)}`);
+            }
+            try {
+                if (!ownedIdentity)
+                    throw new Error("Target identity was not captured before apply.");
+                removeOwnedPath(targetFile, ownedIdentity, dependencies.fs);
+                potentiallyModified.delete(pathKey(targetFile));
+            }
+            catch (restoreError) {
+                rollbackErrors.push(`${targetFile}: ${message(restoreError)}`);
+            }
+        }
+        try {
+            cleanupOwnedTemp(stagedFile, ownedIdentity, dependencies.fs, true);
+        }
+        catch (cleanupError) {
+            rollbackErrors.push(`${stagedFile}: ${message(cleanupError)}`);
+            if (stagedFile)
+                potentiallyModified.set(pathKey(stagedFile), path.normalize(stagedFile));
+        }
+        try {
+            cleanupOwnedTemp(sourceGuard, sourceIdentity, dependencies.fs, true);
+        }
+        catch (cleanupError) {
+            rollbackErrors.push(`${sourceGuard}: ${message(cleanupError)}`);
+            if (sourceGuard)
+                potentiallyModified.set(pathKey(sourceGuard), path.normalize(sourceGuard));
+        }
+        for (const dir of [...createdDirs].reverse()) {
+            try {
+                dependencies.fs.rmdirSync(dir);
+            }
+            catch {
+                // A non-empty or concurrently reused directory is intentionally retained.
+            }
+        }
+        const potentiallyModifiedFiles = rollbackErrors.length === 0 ? [] : uniquePaths([...potentiallyModified.values()]);
+        return {
+            ok: false,
+            code: rollbackErrors.length === 0 ? "FILE_MUTATION_TRANSACTION_FAILED" : "FILE_MUTATION_ROLLBACK_FAILED",
+            error: rollbackErrors.length === 0
+                ? message(error)
+                : `${message(error)} Rollback failed: ${rollbackErrors.join("; ")}`,
+            rollback: rollbackErrors.length === 0 ? "ok" : "failed",
+            potentiallyModifiedFiles,
+            ...(rollbackErrors.length > 0 ? { rollbackErrors } : {})
+        };
+    }
+    const changedFiles = [...prepared.values()]
+        .filter((item) => item.nextText !== item.originalText)
+        .map((item) => item.file);
+    return {
+        ok: true,
+        savedFiles: uniquePaths([targetFile, ...changedFiles]),
+        touchedFiles: uniquePaths([targetFile, ...changedFiles]),
+        importEditCount: input.plan.edits.reduce((sum, edit) => sum + edit.textChanges.length, 0),
+        assetImportEditCount,
+        cleanup
+    };
+}
+function verifyFinalCommitPreflight(root, sourceFile, targetFile, plan, dependencies) {
+    try {
+        if (dependencies.computeWorkspaceFingerprint(root) !== plan.workspaceFingerprint) {
+            return failure("FILE_MUTATION_COMMIT_PREFLIGHT_STALE", "Workspace files, configs, or package metadata changed at the final apply boundary.");
+        }
+        if (dependencies.fs.existsSync(targetFile)) {
+            return failure("FILE_MUTATION_TARGET_CHANGED", "Target path exists at the final no-replace apply boundary.");
+        }
+        for (const snapshot of plan.fileSnapshots) {
+            if (!dependencies.fs.existsSync(snapshot.file) ||
+                sha256(dependencies.fs.readFileSync(snapshot.file, "utf8")) !== snapshot.hash) {
+                return failure("FILE_MUTATION_TOUCHED_FILE_CHANGED", `Planned file changed at the final apply boundary: ${snapshot.file}`);
+            }
+        }
+        if (!dependencies.fs.existsSync(sourceFile) || !dependencies.fs.statSync(sourceFile).isFile()) {
+            return failure("FILE_MUTATION_SOURCE_CHANGED", "Source file changed at the final apply boundary.");
+        }
+        return null;
+    }
+    catch (error) {
+        return failure("FILE_MUTATION_COMMIT_PREFLIGHT_FAILED", message(error));
+    }
+}
+function readRegularFileIdentity(file, fsAdapter) {
+    return readRegularFileIdentityFromStat(file, fsAdapter.statSync(file));
+}
+function readRegularFileIdentityFromStat(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 createOwnedStagedFile(targetFile, text, mode, fsAdapter) {
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+        const file = createUniqueAdjacentPath(targetFile, "target-stage");
+        let descriptor;
+        try {
+            descriptor = fsAdapter.openSync(file, "wx", mode);
+        }
+        catch (error) {
+            if (readErrorCode(error) === "EEXIST")
+                continue;
+            throw error;
+        }
+        let identity = null;
+        let writeError = null;
+        try {
+            identity = readRegularFileIdentityFromStat(file, fsAdapter.fstatSync(descriptor));
+            fsAdapter.fchmodSync(descriptor, mode);
+            const stagedStat = fsAdapter.fstatSync(descriptor);
+            identity = readRegularFileIdentityFromStat(file, stagedStat);
+            if ((stagedStat.mode & 0o7777) !== mode) {
+                throw new Error(`Staged target mode does not match source mode for ${file}.`);
+            }
+            const bytes = Buffer.from(text, "utf8");
+            let offset = 0;
+            while (offset < bytes.length) {
+                const written = fsAdapter.writeSync(descriptor, bytes, offset, bytes.length - offset, offset);
+                if (written <= 0)
+                    throw new Error(`Staged target write made no progress for ${file}.`);
+                offset += written;
+            }
+        }
+        catch (error) {
+            writeError = error;
+        }
+        finally {
+            try {
+                fsAdapter.closeSync(descriptor);
+            }
+            catch (error) {
+                writeError ??= error;
+            }
+        }
+        if (writeError) {
+            cleanupOwnedTemp(file, identity, fsAdapter);
+            throw writeError;
+        }
+        if (!identity)
+            throw new Error(`Staged target identity was not captured for ${file}.`);
+        assertExactOwnedFile(file, identity, text, mode, fsAdapter, "Staged target bytes or mode changed during preparation.");
+        return { file, identity };
+    }
+    throw new Error(`Could not reserve a unique staged target adjacent to ${targetFile}.`);
+}
+function createUniqueAdjacentPath(file, label) {
+    return path.join(path.dirname(file), `.${path.basename(file)}.aib-${label}-${process.pid}-${crypto.randomUUID()}`);
+}
+function assertExactOwnedFile(file, identity, expectedText, expectedMode, fsAdapter, error) {
+    if (!fsAdapter.existsSync(file) ||
+        !sameFileIdentity(readRegularFileIdentity(file, fsAdapter), identity) ||
+        readPermissionBits(file, fsAdapter) !== expectedMode ||
+        sha256(fsAdapter.readFileSync(file, "utf8")) !== sha256(expectedText)) {
+        throw new Error(error);
+    }
+}
+function readPermissionBits(file, fsAdapter) {
+    return fsAdapter.statSync(file).mode & 0o7777;
+}
+function removeOwnedPath(file, identity, fsAdapter) {
+    if (!fsAdapter.existsSync(file))
+        return;
+    if (!sameFileIdentity(readRegularFileIdentity(file, fsAdapter), 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 cleanupOwnedTemp(file, identity, fsAdapter, strict = false) {
+    if (!file || !fsAdapter.existsSync(file))
+        return;
+    if (!identity) {
+        if (strict)
+            throw new Error(`Temporary path identity is unavailable for ${file}.`);
+        return;
+    }
+    if (!sameFileIdentity(readRegularFileIdentity(file, fsAdapter), identity)) {
+        if (strict)
+            throw new Error(`Refusing to remove foreign temporary path ${file}.`);
+        return;
+    }
+    removeOwnedPath(file, identity, fsAdapter);
+}
+function sameFileIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+function readErrorCode(error) {
+    return error && typeof error === "object" && "code" in error && typeof error.code === "string" ? error.code : null;
+}
+function failure(code, error) {
+    return { ok: false, code, error, rollback: "not-needed", potentiallyModifiedFiles: [] };
+}
+function validateTextChanges(changes, textLength) {
+    const sorted = [...changes].sort((left, right) => left.span.start - right.span.start || left.span.length - right.span.length);
+    let previousEnd = -1;
+    for (const change of sorted) {
+        const { start, length } = change.span;
+        if (!Number.isInteger(start) || !Number.isInteger(length) || start < 0 || length < 0 || start + length > textLength) {
+            return { code: "FILE_TEXT_EDIT_INVALID_SPAN", error: `Invalid text edit span ${start}:${length}.` };
+        }
+        if (start < previousEnd || start === previousEnd && length > 0 && previousEnd >= 0) {
+            return { code: "FILE_TEXT_EDIT_OVERLAP", error: `Overlapping text edit span ${start}:${length}.` };
+        }
+        previousEnd = Math.max(previousEnd, start + length);
+    }
+    return null;
+}
+function buildMovedFileAssetImportTextChanges(sourceFile, targetFile, sourceText) {
+    if (!/\.(?:tsx?|jsx?|mjs|cjs)$/i.test(targetFile))
+        return [];
+    const sourceAst = typescript_1.default.createSourceFile(targetFile, sourceText, typescript_1.default.ScriptTarget.Latest, true, scriptKindForFile(targetFile));
+    const changes = [];
+    for (const statement of sourceAst.statements) {
+        if (!typescript_1.default.isImportDeclaration(statement) || statement.importClause || !typescript_1.default.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const parsed = /^(\.\.?\/.*\.(?:css|scss))([?#].*)?$/i.exec(statement.moduleSpecifier.text);
+        if (!parsed)
+            continue;
+        const assetBefore = path.resolve(path.dirname(sourceFile), (parsed[1] ?? "").replace(/\//g, path.sep));
+        const relative = path.relative(path.dirname(targetFile), assetBefore).replace(/\\/g, "/");
+        const next = `${relative.startsWith(".") ? relative : `./${relative}`}${parsed[2] ?? ""}`;
+        if (next !== statement.moduleSpecifier.text) {
+            changes.push({
+                span: { start: statement.moduleSpecifier.getStart(sourceAst) + 1, length: statement.moduleSpecifier.text.length },
+                newText: next
+            });
+        }
+    }
+    return changes;
+}
+function removeUnusedImportBindings(file, text) {
+    const source = typescript_1.default.createSourceFile(file, text, typescript_1.default.ScriptTarget.Latest, true, scriptKindForFile(file));
+    const referenced = new Set();
+    const visit = (node) => {
+        if (typescript_1.default.isImportDeclaration(node))
+            return;
+        if (typescript_1.default.isIdentifier(node))
+            referenced.add(node.text);
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    const changes = [];
+    for (const statement of source.statements) {
+        if (!typescript_1.default.isImportDeclaration(statement) || !statement.importClause || !typescript_1.default.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const clause = statement.importClause;
+        const clauseText = text.slice(clause.getStart(source), clause.getEnd());
+        if (/\/\*|\/\//.test(clauseText))
+            continue;
+        const defaultName = clause.name && referenced.has(clause.name.text) ? clause.name.text : null;
+        const named = clause.namedBindings && typescript_1.default.isNamedImports(clause.namedBindings)
+            ? clause.namedBindings.elements.filter((item) => referenced.has(item.name.text))
+            : [];
+        const namespace = clause.namedBindings && typescript_1.default.isNamespaceImport(clause.namedBindings) && referenced.has(clause.namedBindings.name.text)
+            ? clause.namedBindings.name.text
+            : null;
+        let replacement = "";
+        if (defaultName || namespace || named.length > 0) {
+            const bindings = [
+                defaultName,
+                namespace ? `* as ${namespace}` : null,
+                named.length > 0 ? `{ ${named.map((item) => item.getText(source)).join(", ")} }` : null
+            ].filter((item) => Boolean(item)).join(", ");
+            const suffix = text.slice(statement.moduleSpecifier.getEnd(), statement.getEnd()).replace(/;?\s*$/, "");
+            replacement = `import ${clause.isTypeOnly ? "type " : ""}${bindings} from ${statement.moduleSpecifier.getText(source)}${suffix};`;
+        }
+        const start = source.getPositionOfLineAndCharacter(source.getLineAndCharacterOfPosition(statement.getStart(source)).line, 0);
+        let end = statement.getEnd();
+        if (text.startsWith("\r\n", end))
+            end += 2;
+        else if (text[end] === "\n" || text[end] === "\r")
+            end += 1;
+        const current = text.slice(start, end);
+        const next = replacement ? `${replacement}${current.endsWith("\r\n") ? "\r\n" : current.endsWith("\n") ? "\n" : ""}` : "";
+        if (current !== next)
+            changes.push({ span: { start, length: end - start }, newText: next });
+    }
+    return (0, file_text_edit_executor_1.applyTextChanges)(text, changes);
+}
+function ensureDirectoryTree(dir, fsAdapter) {
+    const missing = [];
+    let current = dir;
+    while (!fsAdapter.existsSync(current)) {
+        missing.push(current);
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    fsAdapter.mkdirSync(dir, { recursive: true });
+    return missing;
+}
+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 sha256(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function uniquePaths(files) {
+    return [...new Map(files.map((file) => [pathKey(file), path.normalize(file)])).values()].sort();
+}
+function samePath(left, right) {
+    return pathKey(left) === pathKey(right);
+}
+function pathKey(file) {
+    const normalized = path.normalize(file);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}