@bleedingdev/modern-js-ultramodern-create 3.8.3-ultramodern.2

package/dist/cjs/ultramodern-workspace/add-vertical/transaction.cjs

@@ -0,0 +1,590 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    WorkspaceTransactionConflictError: ()=>WorkspaceTransactionConflictError,
+    __transactionTestHooks: ()=>__transactionTestHooks,
+    relocateStagedWorkspaceReferences: ()=>relocateStagedWorkspaceReferences,
+    runFreshWorkspaceTransaction: ()=>runFreshWorkspaceTransaction,
+    runWorkspaceTransaction: ()=>runWorkspaceTransaction
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_generation_result_cjs_namespaceObject = require("../generation-result.cjs");
+const external_naming_cjs_namespaceObject = require("../naming.cjs");
+class WorkspaceTransactionConflictError extends Error {
+    constructor(message, options){
+        super(message, options), this.code = 'workspace-transaction-conflict';
+        this.name = 'WorkspaceTransactionConflictError';
+    }
+}
+const __transactionTestHooks = {};
+function isIgnoredRelativePath(relativePath) {
+    return (0, external_naming_cjs_namespaceObject.normalizePath)(relativePath).split('/').some((segment)=>external_generation_result_cjs_namespaceObject.ignoredSnapshotDirectories.has(segment));
+}
+function walkWorkspaceFiles(root, onFile) {
+    if (!external_node_fs_default().existsSync(root)) return;
+    const collect = (currentDir)=>{
+        for (const entry of external_node_fs_default().readdirSync(currentDir, {
+            withFileTypes: true
+        }).sort((left, right)=>left.name.localeCompare(right.name))){
+            const entryPath = external_node_path_default().join(currentDir, entry.name);
+            const relativePath = (0, external_naming_cjs_namespaceObject.normalizePath)(external_node_path_default().relative(root, entryPath));
+            if (!isIgnoredRelativePath(relativePath)) if (entry.isDirectory()) collect(entryPath);
+            else if (entry.isFile()) onFile(relativePath, entryPath);
+            else throw new WorkspaceTransactionConflictError(`Staged workspace contains an unsupported link or special file: ${relativePath}`);
+        }
+    };
+    collect(root);
+}
+function captureWorkspace(root) {
+    const files = new Map();
+    walkWorkspaceFiles(root, (relativePath, absolutePath)=>{
+        const stat = external_node_fs_default().statSync(absolutePath);
+        files.set(relativePath, {
+            content: external_node_fs_default().readFileSync(absolutePath),
+            mode: 511 & stat.mode
+        });
+    });
+    return files;
+}
+function sameFile(left, right) {
+    if (void 0 === left || void 0 === right) return left === right;
+    return left.mode === right.mode && left.content.equals(right.content);
+}
+function buildChangePlan(before, after) {
+    return [
+        ...new Set([
+            ...before.keys(),
+            ...after.keys()
+        ])
+    ].sort().flatMap((relativePath)=>{
+        const previous = before.get(relativePath);
+        const next = after.get(relativePath);
+        return sameFile(previous, next) ? [] : [
+            {
+                relativePath,
+                before: previous,
+                after: next
+            }
+        ];
+    });
+}
+function createTemporarySibling(root) {
+    const absoluteRoot = external_node_path_default().resolve(root);
+    const parent = external_node_path_default().dirname(absoluteRoot);
+    external_node_fs_default().mkdirSync(parent, {
+        recursive: true
+    });
+    return external_node_fs_default().mkdtempSync(external_node_path_default().join(parent, `.${external_node_path_default().basename(absoluteRoot)}.ultramodern-stage-`));
+}
+function removeOwnedTemporaryDirectory(temporaryRoot, identity) {
+    let current;
+    try {
+        current = external_node_fs_default().lstatSync(temporaryRoot);
+    } catch (error) {
+        if ('ENOENT' === error.code) return;
+        throw error;
+    }
+    if (current.dev !== identity.dev || current.ino !== identity.ino) throw new WorkspaceTransactionConflictError(`Owned staging path was replaced before cleanup: ${temporaryRoot}`);
+    external_node_fs_default().rmSync(temporaryRoot, {
+        force: true,
+        recursive: true
+    });
+}
+function cleanOwnedTemporaryDirectory(temporaryRoot, identity) {
+    try {
+        removeOwnedTemporaryDirectory(temporaryRoot, identity);
+    } catch (error) {
+        process.emitWarning(`UltraModern temporary workspace cleanup failed for ${temporaryRoot}: ${String(error)}`, {
+            code: 'ULTRAMODERN_TEMP_CLEANUP_FAILED'
+        });
+    }
+}
+function inspectFreshTarget(targetDir) {
+    try {
+        const stat = external_node_fs_default().lstatSync(targetDir);
+        if (!stat.isDirectory() || stat.isSymbolicLink() || external_node_fs_default().readdirSync(targetDir).length > 0) throw new WorkspaceTransactionConflictError(`Refusing to replace existing workspace target: ${targetDir}`);
+        return {
+            kind: 'empty',
+            dev: stat.dev,
+            ino: stat.ino,
+            mode: 511 & stat.mode
+        };
+    } catch (error) {
+        if ('ENOENT' === error.code) return {
+            kind: 'absent',
+            mode: 511 & ~process.umask()
+        };
+        throw error;
+    }
+}
+function assertFreshTarget(targetDir, expected) {
+    const current = inspectFreshTarget(targetDir);
+    if ('absent' === expected.kind) {
+        if ('absent' !== current.kind) throw new WorkspaceTransactionConflictError(`Workspace target appeared during generation: ${targetDir}`);
+        return;
+    }
+    if ('empty' !== current.kind || current.dev !== expected.dev || current.ino !== expected.ino) throw new WorkspaceTransactionConflictError(`Workspace target changed during generation: ${targetDir}`);
+}
+function publishFileExclusive(sourcePath, targetPath) {
+    try {
+        external_node_fs_default().linkSync(sourcePath, targetPath);
+    } catch (error) {
+        if (![
+            'EPERM',
+            'EOPNOTSUPP',
+            'ENOTSUP',
+            'EXDEV'
+        ].includes(error.code ?? '')) throw error;
+        external_node_fs_default().copyFileSync(sourcePath, targetPath, external_node_fs_default().constants.COPYFILE_EXCL);
+    }
+}
+function copyWorkspaceToStage(root, stagingRoot) {
+    external_node_fs_default().cpSync(root, stagingRoot, {
+        mode: external_node_fs_default().constants.COPYFILE_FICLONE,
+        recursive: true,
+        filter (sourcePath) {
+            const relativePath = external_node_path_default().relative(root, sourcePath);
+            if ('' === relativePath) return true;
+            if (isIgnoredRelativePath(relativePath)) return false;
+            return !external_node_fs_default().lstatSync(sourcePath).isSymbolicLink();
+        }
+    });
+}
+function replaceBuffer(content, search, replacement) {
+    const chunks = [];
+    let from = 0;
+    let index = content.indexOf(search, from);
+    while(-1 !== index){
+        chunks.push(content.subarray(from, index), replacement);
+        from = index + search.length;
+        index = content.indexOf(search, from);
+    }
+    chunks.push(content.subarray(from));
+    return Buffer.concat(chunks);
+}
+function relocateStagedWorkspaceReferences(stagingRoot, workspaceRoot) {
+    const stagedPath = Buffer.from(stagingRoot);
+    const publishedPath = Buffer.from(workspaceRoot);
+    walkWorkspaceFiles(stagingRoot, (_relativePath, absolutePath)=>{
+        const content = external_node_fs_default().readFileSync(absolutePath);
+        if (!content.includes(stagedPath)) return;
+        external_node_fs_default().writeFileSync(absolutePath, replaceBuffer(content, stagedPath, publishedPath));
+    });
+}
+function readWorkspaceFile(root, relativePath) {
+    return readFilePath(external_node_path_default().join(root, relativePath), relativePath);
+}
+function readFilePath(absolutePath, displayPath) {
+    let stat;
+    try {
+        stat = external_node_fs_default().lstatSync(absolutePath);
+    } catch (error) {
+        if ('ENOENT' === error.code) return;
+        throw error;
+    }
+    if (!stat.isFile()) throw new WorkspaceTransactionConflictError(`Workspace target changed type during generation: ${displayPath}`);
+    return {
+        content: external_node_fs_default().readFileSync(absolutePath),
+        mode: 511 & stat.mode
+    };
+}
+function assertPreimage(root, change) {
+    if (!sameFile(readWorkspaceFile(root, change.relativePath), change.before)) throw new WorkspaceTransactionConflictError(`Workspace target changed during generation: ${change.relativePath}`);
+}
+function ensureOwnedParentDirectories(root, relativePath, createdDirectories) {
+    const segments = relativePath.split('/').slice(0, -1);
+    let currentPath = root;
+    for (const segment of segments){
+        currentPath = external_node_path_default().join(currentPath, segment);
+        try {
+            const stat = external_node_fs_default().lstatSync(currentPath);
+            if (!stat.isDirectory() || stat.isSymbolicLink()) throw new WorkspaceTransactionConflictError(`Workspace parent changed type during generation: ${(0, external_naming_cjs_namespaceObject.normalizePath)(external_node_path_default().relative(root, currentPath))}`);
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+            try {
+                external_node_fs_default().mkdirSync(currentPath);
+                createdDirectories.push(currentPath);
+            } catch (mkdirError) {
+                if ('EEXIST' !== mkdirError.code) throw mkdirError;
+                const stat = external_node_fs_default().lstatSync(currentPath);
+                if (!stat.isDirectory() || stat.isSymbolicLink()) throw new WorkspaceTransactionConflictError(`Workspace parent changed type during generation: ${(0, external_naming_cjs_namespaceObject.normalizePath)(external_node_path_default().relative(root, currentPath))}`);
+            }
+        }
+    }
+}
+function temporaryFilePath(root, relativePath, role) {
+    const targetPath = external_node_path_default().join(root, relativePath);
+    return external_node_path_default().join(external_node_path_default().dirname(targetPath), `.${external_node_path_default().basename(targetPath)}.ultramodern-${role}-${(0, external_node_crypto_namespaceObject.randomUUID)()}.tmp`);
+}
+function writeTemporaryFile(filePath, file) {
+    external_node_fs_default().writeFileSync(filePath, file.content, {
+        flag: 'wx',
+        mode: file.mode
+    });
+}
+function removeIfPresent(filePath) {
+    if (!filePath) return;
+    try {
+        external_node_fs_default().rmSync(filePath, {
+            force: true
+        });
+    } catch (error) {
+        if ('ENOENT' !== error.code) throw error;
+    }
+}
+function prepareChanges(root, changes, createdDirectories, preparedChanges) {
+    for (const change of changes){
+        ensureOwnedParentDirectories(root, change.relativePath, createdDirectories);
+        const prepared = {
+            ...change,
+            published: false
+        };
+        preparedChanges.push(prepared);
+        if (change.after) {
+            prepared.publishPath = temporaryFilePath(root, change.relativePath, 'publish');
+            writeTemporaryFile(prepared.publishPath, change.after);
+        }
+        if (change.before) prepared.rollbackPath = temporaryFilePath(root, change.relativePath, change.after ? 'rollback' : 'removed');
+    }
+}
+function assertPublishedState(root, change) {
+    if (!sameFile(readWorkspaceFile(root, change.relativePath), change.after)) throw new WorkspaceTransactionConflictError(`Workspace target changed while rolling back generation: ${change.relativePath}`);
+}
+function rollbackPublishedChanges(root, preparedChanges) {
+    for (const change of [
+        ...preparedChanges
+    ].reverse()){
+        if (!change.published) continue;
+        if (change.rollbackPath) change.preserveRollback = true;
+        assertPublishedState(root, change);
+        const targetPath = external_node_path_default().join(root, change.relativePath);
+        if (void 0 === change.before) {
+            const discardedPath = quarantinePublishedFile(root, change, targetPath);
+            removeIfPresent(discardedPath);
+            if (external_node_fs_default().existsSync(targetPath)) throw new WorkspaceTransactionConflictError(`Workspace target changed while rolling back generation: ${change.relativePath}`);
+        } else if (void 0 === change.after) {
+            if (!change.rollbackPath) throw new WorkspaceTransactionConflictError(`Workspace deletion could not be rolled back: ${change.relativePath}`);
+            try {
+                publishFileExclusive(change.rollbackPath, targetPath);
+            } catch (error) {
+                throw new WorkspaceTransactionConflictError(`Workspace deletion could not be rolled back; prior bytes are preserved at ${change.rollbackPath}`, {
+                    cause: error
+                });
+            }
+            removeIfPresent(change.rollbackPath);
+            change.rollbackPath = void 0;
+            change.preserveRollback = false;
+        } else {
+            if (!change.rollbackPath) throw new WorkspaceTransactionConflictError(`Workspace replacement could not be rolled back: ${change.relativePath}`);
+            const discardedPath = quarantinePublishedFile(root, change, targetPath);
+            try {
+                publishFileExclusive(change.rollbackPath, targetPath);
+            } catch (error) {
+                removeIfPresent(discardedPath);
+                throw new WorkspaceTransactionConflictError(`Workspace replacement could not be rolled back; prior bytes are preserved at ${change.rollbackPath}`, {
+                    cause: error
+                });
+            }
+            removeIfPresent(discardedPath);
+            removeIfPresent(change.rollbackPath);
+            change.rollbackPath = void 0;
+            change.preserveRollback = false;
+        }
+    }
+}
+function preservePath(change, filePath) {
+    change.preservedPaths ??= [];
+    change.preservedPaths.push(filePath);
+}
+function quarantinePublishedFile(root, change, targetPath) {
+    const discardedPath = temporaryFilePath(root, change.relativePath, 'discard');
+    external_node_fs_default().renameSync(targetPath, discardedPath);
+    let matches = false;
+    try {
+        matches = sameFile(readFilePath(discardedPath, change.relativePath), change.after);
+    } catch  {
+        matches = false;
+    }
+    if (matches) return discardedPath;
+    if (!restoreQuarantinedPath(discardedPath, targetPath)) {
+        preservePath(change, discardedPath);
+        throw new WorkspaceTransactionConflictError(`Workspace target changed while rolling back generation; moved bytes are preserved at ${discardedPath}`);
+    }
+    throw new WorkspaceTransactionConflictError(`Workspace target changed while rolling back generation: ${change.relativePath}`);
+}
+function cleanupPreparedChanges(preparedChanges, createdDirectories) {
+    for (const change of preparedChanges){
+        removeIfPresent(change.publishPath);
+        if (!change.preserveRollback) removeIfPresent(change.rollbackPath);
+    }
+    for (const directory of [
+        ...createdDirectories
+    ].reverse())try {
+        external_node_fs_default().rmdirSync(directory);
+    } catch (error) {
+        if (![
+            'ENOENT',
+            'ENOTEMPTY'
+        ].includes(error.code ?? '')) throw error;
+    }
+}
+function cleanPreparedChanges(preparedChanges, createdDirectories) {
+    try {
+        cleanupPreparedChanges(preparedChanges, createdDirectories);
+    } catch  {}
+}
+function restoreQuarantinedPath(quarantinePath, targetPath) {
+    try {
+        const moved = external_node_fs_default().lstatSync(quarantinePath);
+        if (moved.isFile()) external_node_fs_default().linkSync(quarantinePath, targetPath);
+        else {
+            if (!moved.isSymbolicLink()) return false;
+            external_node_fs_default().symlinkSync(external_node_fs_default().readlinkSync(quarantinePath), targetPath);
+        }
+        removeIfPresent(quarantinePath);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function restoreQuarantinedPreimage(change, targetPath) {
+    if (!change.rollbackPath || !restoreQuarantinedPath(change.rollbackPath, targetPath)) {
+        change.preserveRollback = true;
+        return false;
+    }
+    change.rollbackPath = void 0;
+    return true;
+}
+function publishChange(root, change) {
+    assertPreimage(root, change);
+    __transactionTestHooks.afterPreimageCheck?.({
+        workspaceRoot: root,
+        relativePath: change.relativePath
+    });
+    const targetPath = external_node_path_default().join(root, change.relativePath);
+    if (void 0 === change.before) {
+        if (!change.publishPath) throw new Error(`Missing staged output for ${change.relativePath}`);
+        publishFileExclusive(change.publishPath, targetPath);
+        removeIfPresent(change.publishPath);
+        change.publishPath = void 0;
+    } else {
+        if (!change.rollbackPath) throw new Error(`Missing rollback path for ${change.relativePath}`);
+        external_node_fs_default().renameSync(targetPath, change.rollbackPath);
+        let quarantinedFile;
+        try {
+            quarantinedFile = readFilePath(change.rollbackPath, change.relativePath);
+        } catch  {
+            const quarantinePath = change.rollbackPath;
+            const restored = restoreQuarantinedPreimage(change, targetPath);
+            throw new WorkspaceTransactionConflictError(restored ? `Workspace target changed type during generation: ${change.relativePath}` : `Workspace target changed type during generation; moved bytes are preserved at ${quarantinePath}`);
+        }
+        if (!sameFile(quarantinedFile, change.before)) {
+            const quarantinePath = change.rollbackPath;
+            const restored = restoreQuarantinedPreimage(change, targetPath);
+            throw new WorkspaceTransactionConflictError(restored ? `Workspace target changed during generation: ${change.relativePath}` : `Workspace target changed during generation; concurrent bytes are preserved at ${quarantinePath}`);
+        }
+        if (change.after) {
+            if (!change.publishPath) throw new Error(`Missing staged output for ${change.relativePath}`);
+            try {
+                publishFileExclusive(change.publishPath, targetPath);
+            } catch (error) {
+                const quarantinePath = change.rollbackPath;
+                const restored = restoreQuarantinedPreimage(change, targetPath);
+                throw new WorkspaceTransactionConflictError(restored ? `Workspace target changed during generation: ${change.relativePath}` : `Workspace target changed during generation; prior bytes are preserved at ${quarantinePath}`, {
+                    cause: error
+                });
+            }
+            removeIfPresent(change.publishPath);
+            change.publishPath = void 0;
+        }
+    }
+    change.published = true;
+}
+function publishChangePlan(root, stagingRoot, changes) {
+    __transactionTestHooks.beforePublish?.({
+        workspaceRoot: root,
+        stagingRoot,
+        changedPaths: changes.map((change)=>change.relativePath)
+    });
+    for (const change of changes)assertPreimage(root, change);
+    const createdDirectories = [];
+    const preparedChanges = [];
+    try {
+        prepareChanges(root, changes, createdDirectories, preparedChanges);
+        for (const change of preparedChanges)assertPreimage(root, change);
+        preparedChanges.forEach((change, index)=>{
+            __transactionTestHooks.beforePublishPath?.({
+                workspaceRoot: root,
+                relativePath: change.relativePath,
+                index
+            });
+            publishChange(root, change);
+        });
+    } catch (error) {
+        try {
+            rollbackPublishedChanges(root, preparedChanges);
+        } catch (rollbackError) {
+            throw new WorkspaceTransactionConflictError('Workspace transaction failed and concurrent target changes prevented a safe rollback.', {
+                cause: rollbackError
+            });
+        } finally{
+            cleanPreparedChanges(preparedChanges, createdDirectories);
+        }
+        throw error;
+    }
+    cleanPreparedChanges(preparedChanges, []);
+}
+function runWorkspaceTransaction(root, mutate) {
+    const workspaceRoot = external_node_fs_default().realpathSync.native(external_node_path_default().resolve(root));
+    if (!external_node_fs_default().statSync(workspaceRoot).isDirectory()) throw new Error(`Workspace root is not a directory: ${root}`);
+    const stagingRoot = createTemporarySibling(workspaceRoot);
+    const stagingIdentity = external_node_fs_default().lstatSync(stagingRoot);
+    try {
+        copyWorkspaceToStage(workspaceRoot, stagingRoot);
+        const before = captureWorkspace(stagingRoot);
+        const result = mutate(stagingRoot);
+        relocateStagedWorkspaceReferences(stagingRoot, root);
+        const changes = buildChangePlan(before, captureWorkspace(stagingRoot));
+        publishChangePlan(workspaceRoot, stagingRoot, changes);
+        return result;
+    } finally{
+        cleanOwnedTemporaryDirectory(stagingRoot, stagingIdentity);
+    }
+}
+function sameIdentity(stat, identity) {
+    return stat.dev === identity.dev && stat.ino === identity.ino;
+}
+function currentDirectoryIs(targetDir) {
+    try {
+        return sameIdentity(external_node_fs_default().statSync('.'), external_node_fs_default().statSync(targetDir));
+    } catch  {
+        return false;
+    }
+}
+function restoreEmptyTarget(rollbackPath, targetDir) {
+    try {
+        external_node_fs_default().lstatSync(targetDir);
+        return false;
+    } catch (error) {
+        if ('ENOENT' !== error.code) return false;
+    }
+    try {
+        external_node_fs_default().renameSync(rollbackPath, targetDir);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function cleanEmptyTargetRollback(rollbackPath, expected) {
+    try {
+        const current = external_node_fs_default().lstatSync(rollbackPath);
+        if (!sameIdentity(current, expected) || !current.isDirectory() || external_node_fs_default().readdirSync(rollbackPath).length > 0) throw new WorkspaceTransactionConflictError(`Preserving changed empty-target rollback at ${rollbackPath}`);
+        external_node_fs_default().rmdirSync(rollbackPath);
+    } catch (error) {
+        process.emitWarning(`UltraModern empty-target cleanup failed for ${rollbackPath}: ${String(error)}`, {
+            code: 'ULTRAMODERN_TEMP_CLEANUP_FAILED'
+        });
+    }
+}
+function publishFreshWorkspace(stagingRoot, workspaceRoot, target) {
+    assertFreshTarget(workspaceRoot, target);
+    if ('absent' === target.kind) return void external_node_fs_default().renameSync(stagingRoot, workspaceRoot);
+    const rollbackPath = external_node_path_default().join(external_node_path_default().dirname(workspaceRoot), `.${external_node_path_default().basename(workspaceRoot)}.ultramodern-empty-${(0, external_node_crypto_namespaceObject.randomUUID)()}.tmp`);
+    const restoreCwd = currentDirectoryIs(workspaceRoot);
+    external_node_fs_default().renameSync(workspaceRoot, rollbackPath);
+    let committed = false;
+    try {
+        const moved = external_node_fs_default().lstatSync(rollbackPath);
+        if (!sameIdentity(moved, target) || !moved.isDirectory() || external_node_fs_default().readdirSync(rollbackPath).length > 0) throw new WorkspaceTransactionConflictError(`Workspace target changed during generation: ${workspaceRoot}`);
+        external_node_fs_default().renameSync(stagingRoot, workspaceRoot);
+        committed = true;
+    } catch (error) {
+        if (!committed && !restoreEmptyTarget(rollbackPath, workspaceRoot)) throw new WorkspaceTransactionConflictError(`Fresh workspace publication failed; the original empty target is preserved at ${rollbackPath}`, {
+            cause: error
+        });
+        throw error;
+    }
+    let cwdRestored = !restoreCwd;
+    if (restoreCwd) try {
+        process.chdir(workspaceRoot);
+        cwdRestored = true;
+    } catch (error) {
+        process.emitWarning(`UltraModern published ${workspaceRoot}, but could not restore the caller current directory: ${String(error)}`, {
+            code: 'ULTRAMODERN_CWD_RESTORE_FAILED'
+        });
+    }
+    if (cwdRestored) cleanEmptyTargetRollback(rollbackPath, target);
+}
+function runFreshWorkspaceTransaction(targetDir, generate) {
+    const workspaceRoot = external_node_path_default().resolve(targetDir);
+    const target = inspectFreshTarget(workspaceRoot);
+    const stagingRoot = createTemporarySibling(workspaceRoot);
+    const stagingIdentity = external_node_fs_default().lstatSync(stagingRoot);
+    external_node_fs_default().chmodSync(stagingRoot, target.mode);
+    try {
+        const result = generate(stagingRoot);
+        relocateStagedWorkspaceReferences(stagingRoot, targetDir);
+        __transactionTestHooks.beforeFreshPublish?.({
+            workspaceRoot
+        });
+        publishFreshWorkspace(stagingRoot, workspaceRoot, target);
+        return result;
+    } finally{
+        cleanOwnedTemporaryDirectory(stagingRoot, stagingIdentity);
+    }
+}
+exports.WorkspaceTransactionConflictError = __webpack_exports__.WorkspaceTransactionConflictError;
+exports.__transactionTestHooks = __webpack_exports__.__transactionTestHooks;
+exports.relocateStagedWorkspaceReferences = __webpack_exports__.relocateStagedWorkspaceReferences;
+exports.runFreshWorkspaceTransaction = __webpack_exports__.runFreshWorkspaceTransaction;
+exports.runWorkspaceTransaction = __webpack_exports__.runWorkspaceTransaction;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "WorkspaceTransactionConflictError",
+    "__transactionTestHooks",
+    "relocateStagedWorkspaceReferences",
+    "runFreshWorkspaceTransaction",
+    "runWorkspaceTransaction"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});