@bleedingdev/modern-js-ultramodern-create 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

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

@@ -39,6 +39,8 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     WorkspaceTransactionConflictError: ()=>WorkspaceTransactionConflictError,
     __transactionTestHooks: ()=>__transactionTestHooks,
+    recoverFreshWorkspaceTransactions: ()=>recoverFreshWorkspaceTransactions,
+    recoverWorkspaceTransactions: ()=>recoverWorkspaceTransactions,
     relocateStagedWorkspaceReferences: ()=>relocateStagedWorkspaceReferences,
     runFreshWorkspaceTransaction: ()=>runFreshWorkspaceTransaction,
     runWorkspaceTransaction: ()=>runWorkspaceTransaction
@@ -58,7 +60,18 @@ class WorkspaceTransactionConflictError extends Error {
 }
 const __transactionTestHooks = {};
 function isIgnoredRelativePath(relativePath) {
-    return (0, external_naming_cjs_namespaceObject.normalizePath)(relativePath).split('/').some((segment)=>external_generation_result_cjs_namespaceObject.ignoredSnapshotDirectories.has(segment));
+    const segments = (0, external_naming_cjs_namespaceObject.normalizePath)(relativePath).split('/');
+    return segments.some((segment, index)=>{
+        if (1 === index && [
+            'apps',
+            'verticals',
+            'packages'
+        ].includes(segments[0]) && [
+            'dist',
+            'coverage'
+        ].includes(segment)) return false;
+        return external_generation_result_cjs_namespaceObject.ignoredSnapshotDirectories.has(segment);
+    });
 }
 function walkWorkspaceFiles(root, onFile) {
     if (!external_node_fs_default().existsSync(root)) return;
@@ -69,26 +82,30 @@ function walkWorkspaceFiles(root, onFile) {
             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 if (entry.isFile() || entry.isSymbolicLink()) onFile(relativePath, entryPath);
             else throw new WorkspaceTransactionConflictError(`Staged workspace contains an unsupported link or special file: ${relativePath}`);
         }
     };
     collect(root);
 }
-function captureWorkspace(root) {
+function captureWorkspace(root, publishedRoot = root) {
     const files = new Map();
     walkWorkspaceFiles(root, (relativePath, absolutePath)=>{
-        const stat = external_node_fs_default().statSync(absolutePath);
+        const stat = external_node_fs_default().lstatSync(absolutePath);
+        const target = stat.isSymbolicLink() ? external_node_fs_default().readlinkSync(absolutePath) : void 0;
         files.set(relativePath, {
-            content: external_node_fs_default().readFileSync(absolutePath),
-            mode: 511 & stat.mode
+            content: void 0 === target ? external_node_fs_default().readFileSync(absolutePath) : Buffer.from(external_node_path_default().isAbsolute(target) && isInside(root, target) ? external_node_path_default().join(publishedRoot, external_node_path_default().relative(root, target)) : target),
+            mode: 4095 & stat.mode,
+            ...void 0 === target ? {} : {
+                symlink: true
+            }
         });
     });
     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);
+    return left.symlink === right.symlink && left.mode === right.mode && left.content.equals(right.content);
 }
 function buildChangePlan(before, after) {
     return [
@@ -114,7 +131,7 @@ function createTemporarySibling(root) {
     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-`));
+    return external_node_fs_default().realpathSync.native(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;
@@ -166,6 +183,7 @@ function assertFreshTarget(targetDir, expected) {
     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) {
+    if (external_node_fs_default().lstatSync(sourcePath).isSymbolicLink()) return void external_node_fs_default().symlinkSync(external_node_fs_default().readlinkSync(sourcePath), targetPath);
     try {
         external_node_fs_default().linkSync(sourcePath, targetPath);
     } catch (error) {
@@ -178,15 +196,36 @@ function publishFileExclusive(sourcePath, targetPath) {
         external_node_fs_default().copyFileSync(sourcePath, targetPath, external_node_fs_default().constants.COPYFILE_EXCL);
     }
 }
+function isInside(root, target) {
+    const relative = external_node_path_default().relative(root, target);
+    return '..' !== relative && !relative.startsWith(`..${external_node_path_default().sep}`) && !external_node_path_default().isAbsolute(relative);
+}
 function copyWorkspaceToStage(root, stagingRoot) {
+    walkWorkspaceFiles(root, (relativePath, absolutePath)=>{
+        if (!external_node_fs_default().lstatSync(absolutePath).isSymbolicLink()) return;
+        let target;
+        try {
+            target = external_node_fs_default().realpathSync.native(absolutePath);
+        } catch (cause) {
+            throw new WorkspaceTransactionConflictError(`Unsupported dangling or cyclic workspace link: ${relativePath}`, {
+                cause
+            });
+        }
+        if (!isInside(root, target) || isIgnoredRelativePath(external_node_path_default().relative(root, target))) throw new WorkspaceTransactionConflictError(`Workspace transaction conflict: link escapes the staged input: ${relativePath}`);
+    });
     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();
+        verbatimSymlinks: true,
+        filter: (sourcePath)=>!isIgnoredRelativePath(external_node_path_default().relative(root, sourcePath))
+    });
+    walkWorkspaceFiles(stagingRoot, (_relativePath, absolutePath)=>{
+        if (!external_node_fs_default().lstatSync(absolutePath).isSymbolicLink()) return;
+        const target = external_node_fs_default().readlinkSync(absolutePath);
+        if (external_node_path_default().isAbsolute(target)) {
+            const realTarget = external_node_fs_default().realpathSync.native(target);
+            external_node_fs_default().unlinkSync(absolutePath);
+            external_node_fs_default().symlinkSync(external_node_path_default().join(stagingRoot, external_node_path_default().relative(root, realTarget)), absolutePath);
         }
     });
 }
@@ -206,6 +245,7 @@ function relocateStagedWorkspaceReferences(stagingRoot, workspaceRoot) {
     const stagedPath = Buffer.from(stagingRoot);
     const publishedPath = Buffer.from(workspaceRoot);
     walkWorkspaceFiles(stagingRoot, (_relativePath, absolutePath)=>{
+        if (external_node_fs_default().lstatSync(absolutePath).isSymbolicLink()) return;
         const content = external_node_fs_default().readFileSync(absolutePath);
         if (!content.includes(stagedPath)) return;
         external_node_fs_default().writeFileSync(absolutePath, replaceBuffer(content, stagedPath, publishedPath));
@@ -222,10 +262,13 @@ function readFilePath(absolutePath, displayPath) {
         if ('ENOENT' === error.code) return;
         throw error;
     }
-    if (!stat.isFile()) throw new WorkspaceTransactionConflictError(`Workspace target changed type during generation: ${displayPath}`);
+    if (!stat.isFile() && !stat.isSymbolicLink()) throw new WorkspaceTransactionConflictError(`Workspace target changed type during generation: ${displayPath}`);
     return {
-        content: external_node_fs_default().readFileSync(absolutePath),
-        mode: 511 & stat.mode
+        content: stat.isSymbolicLink() ? Buffer.from(external_node_fs_default().readlinkSync(absolutePath)) : external_node_fs_default().readFileSync(absolutePath),
+        mode: 4095 & stat.mode,
+        ...stat.isSymbolicLink() ? {
+            symlink: true
+        } : {}
     };
 }
 function assertPreimage(root, change) {
@@ -257,6 +300,7 @@ function temporaryFilePath(root, relativePath, role) {
     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) {
+    if (file.symlink) return void external_node_fs_default().symlinkSync(file.content.toString(), filePath);
     external_node_fs_default().writeFileSync(filePath, file.content, {
         flag: 'wx',
         mode: file.mode
@@ -272,19 +316,10 @@ function removeIfPresent(filePath) {
         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 prepareChanges(root, preparedChanges, createdDirectories) {
+    for (const prepared of preparedChanges){
+        ensureOwnedParentDirectories(root, prepared.relativePath, createdDirectories);
+        if (prepared.after && prepared.publishPath) writeTemporaryFile(prepared.publishPath, prepared.after);
     }
 }
 function assertPublishedState(root, change) {
@@ -440,17 +475,278 @@ function publishChange(root, change) {
     }
     change.published = true;
 }
-function publishChangePlan(root, stagingRoot, changes) {
+const receiptSuffix = '.receipt.json';
+function persistReceipt(receiptPath, receipt) {
+    const temporary = `${receiptPath}.next`;
+    const fd = external_node_fs_default().openSync(temporary, 'wx', 384);
+    try {
+        external_node_fs_default().writeFileSync(fd, JSON.stringify(receipt));
+        external_node_fs_default().fsyncSync(fd);
+    } finally{
+        external_node_fs_default().closeSync(fd);
+    }
+    external_node_fs_default().renameSync(temporary, receiptPath);
+    if ('win32' === process.platform) return;
+    const directory = external_node_fs_default().openSync(external_node_path_default().dirname(receiptPath), 'r');
+    try {
+        external_node_fs_default().fsyncSync(directory);
+    } finally{
+        external_node_fs_default().closeSync(directory);
+    }
+}
+function encodedReceipt(root, stagingRoot, changes, directories) {
+    const encode = (file)=>file ? {
+            ...file,
+            content: file.content.toString('base64')
+        } : void 0;
+    const identity = (filePath)=>{
+        const { dev, ino } = external_node_fs_default().lstatSync(filePath);
+        return {
+            dev,
+            ino
+        };
+    };
+    return {
+        schema: 'ultramodern-workspace-transaction-v1',
+        root,
+        rootIdentity: identity(root),
+        stagingIdentity: identity(stagingRoot),
+        pid: process.pid,
+        state: 'publishing',
+        ...directories ? {
+            purpose: 'fresh-empty',
+            directories
+        } : {},
+        changes: changes.map((change)=>({
+                ...change,
+                before: encode(change.before),
+                after: encode(change.after)
+            }))
+    };
+}
+function decodeReceipt(receiptPath, root) {
+    const stat = external_node_fs_default().lstatSync(receiptPath);
+    if (!stat.isFile() || stat.isSymbolicLink() || 'function' == typeof process.getuid && stat.uid !== process.getuid()) throw new WorkspaceTransactionConflictError(`Unsafe interrupted transaction receipt: ${receiptPath}`);
+    const receipt = JSON.parse(external_node_fs_default().readFileSync(receiptPath, 'utf8'));
+    const stagingRoot = receiptPath.slice(0, -receiptSuffix.length);
+    if ('ultramodern-workspace-transaction-v1' !== receipt.schema || receipt.root !== root || ![
+        'publishing',
+        'committed'
+    ].includes(receipt.state) || !Number.isSafeInteger(receipt.pid) || receipt.pid <= 0 || !sameIdentity(external_node_fs_default().lstatSync(root), receipt.rootIdentity) || !sameIdentity(external_node_fs_default().lstatSync(stagingRoot), receipt.stagingIdentity) || !Array.isArray(receipt.changes)) throw new WorkspaceTransactionConflictError(`Unrecognized interrupted transaction receipt: ${receiptPath}`);
+    const paths = new Set();
+    const decode = (file)=>{
+        if (void 0 === file) return;
+        if (!file || 'string' != typeof file.content || !Number.isInteger(file.mode) || file.mode < 0 || file.mode > 4095 || void 0 !== file.symlink && true !== file.symlink || Buffer.from(file.content, 'base64').toString('base64') !== file.content) throw new WorkspaceTransactionConflictError(`Malformed interrupted transaction preimage: ${receiptPath}`);
+        return {
+            ...file,
+            content: Buffer.from(file.content, 'base64')
+        };
+    };
+    const changes = receipt.changes.map((change)=>{
+        const relative = change.relativePath;
+        if ('string' != typeof relative || !relative || external_node_path_default().isAbsolute(relative) || (0, external_naming_cjs_namespaceObject.normalizePath)(external_node_path_default().normalize(relative)) !== relative || !isInside(root, external_node_path_default().resolve(root, relative)) || isIgnoredRelativePath(relative) || paths.has(relative)) throw new WorkspaceTransactionConflictError(`Unsafe interrupted transaction target: ${String(relative)}`);
+        paths.add(relative);
+        for (const temporary of [
+            change.publishPath,
+            change.rollbackPath
+        ])if (void 0 !== temporary && ('string' != typeof temporary || external_node_path_default().dirname(temporary) !== external_node_path_default().dirname(external_node_path_default().join(root, relative)) || !external_node_path_default().basename(temporary).startsWith(`.${external_node_path_default().basename(relative)}.ultramodern-`) || !temporary.endsWith('.tmp'))) throw new WorkspaceTransactionConflictError(`Unsafe interrupted transaction temporary: ${String(temporary)}`);
+        return {
+            relativePath: relative,
+            before: decode(change.before),
+            after: decode(change.after),
+            publishPath: change.publishPath,
+            rollbackPath: change.rollbackPath,
+            published: false
+        };
+    });
+    if (void 0 !== receipt.purpose && 'fresh-empty' !== receipt.purpose) throw new WorkspaceTransactionConflictError(`Unknown transaction purpose: ${receiptPath}`);
+    if ('fresh-empty' === receipt.purpose) {
+        const expected = freshParentPaths(changes);
+        if (!Array.isArray(receipt.directories) || receipt.directories.length !== expected.length || changes.some((change)=>void 0 !== change.before || void 0 === change.after) || receipt.directories.some((directory, index)=>!directory || directory.relativePath !== expected[index] || 'string' != typeof directory.temporaryPath || external_node_path_default().dirname(directory.temporaryPath) !== stagingRoot || !/^\.ultramodern-directory-[\da-f-]+\.tmp$/u.test(external_node_path_default().basename(directory.temporaryPath)) || !Number.isInteger(directory.dev) || !Number.isInteger(directory.ino)) || new Set(receipt.directories.map((directory)=>directory.temporaryPath)).size !== expected.length) throw new WorkspaceTransactionConflictError(`Unsafe fresh transaction directories: ${receiptPath}`);
+    } else if (void 0 !== receipt.directories) throw new WorkspaceTransactionConflictError(`Unexpected transaction directories: ${receiptPath}`);
+    return {
+        receipt,
+        changes
+    };
+}
+function freshParentPaths(changes) {
+    const parents = new Set();
+    for (const change of changes){
+        const segments = change.relativePath.split('/');
+        for(let length = 1; length < segments.length; length++)parents.add(segments.slice(0, length).join('/'));
+    }
+    return [
+        ...parents
+    ].sort((left, right)=>left.split('/').length - right.split('/').length || left.localeCompare(right));
+}
+function stageFreshDirectories(stagingRoot, changes) {
+    return freshParentPaths(changes).map((relativePath)=>{
+        const temporaryPath = external_node_path_default().join(stagingRoot, `.ultramodern-directory-${(0, external_node_crypto_namespaceObject.randomUUID)()}.tmp`);
+        external_node_fs_default().mkdirSync(temporaryPath, {
+            mode: 511 & external_node_fs_default().statSync(external_node_path_default().join(stagingRoot, relativePath)).mode
+        });
+        const { dev, ino } = external_node_fs_default().lstatSync(temporaryPath);
+        return {
+            relativePath,
+            temporaryPath,
+            dev,
+            ino
+        };
+    });
+}
+function assertFreshDirectoryAncestors(root, receipt, relativePath) {
+    const ancestors = relativePath.split('/').slice(0, -1);
+    for(let length = 0; length <= ancestors.length; length++){
+        const relative = ancestors.slice(0, length).join('/');
+        const expected = 0 === length ? receipt.rootIdentity : receipt.directories.find((directory)=>directory.relativePath === relative);
+        const candidate = external_node_path_default().join(root, relative);
+        const stat = external_node_fs_default().lstatSync(candidate);
+        if (!stat.isDirectory() || stat.isSymbolicLink() || !sameIdentity(stat, expected)) throw new WorkspaceTransactionConflictError(`Fresh transaction parent changed; preserved at ${candidate}`);
+    }
+}
+function publishFreshDirectory(root, receipt, directory) {
+    const target = external_node_path_default().join(root, directory.relativePath);
+    assertFreshDirectoryAncestors(root, receipt, directory.relativePath);
+    const staged = external_node_fs_default().lstatSync(directory.temporaryPath);
+    const stagingRoot = external_node_path_default().dirname(directory.temporaryPath);
+    if (!staged.isDirectory() || staged.isSymbolicLink() || !sameIdentity(staged, directory) || !sameIdentity(external_node_fs_default().lstatSync(stagingRoot), receipt.stagingIdentity)) throw new WorkspaceTransactionConflictError(`Fresh transaction staged directory changed: ${directory.temporaryPath}`);
+    if (external_node_fs_default().existsSync(target)) throw new WorkspaceTransactionConflictError(`Fresh transaction directory appeared: ${target}`);
+    external_node_fs_default().renameSync(directory.temporaryPath, target);
+    try {
+        assertFreshDirectoryAncestors(root, receipt, directory.relativePath);
+        const published = external_node_fs_default().lstatSync(target);
+        if (!published.isDirectory() || published.isSymbolicLink() || !sameIdentity(published, directory)) throw new WorkspaceTransactionConflictError(`Fresh transaction directory changed; preserved at ${target}`);
+    } catch (error) {
+        throw new WorkspaceTransactionConflictError(`Fresh directory publication could not validate ownership at ${target}; no cleanup attempted through this path`, {
+            cause: error
+        });
+    }
+}
+function validateFreshDirectories(root, receipt, changes) {
+    const directories = receipt.directories;
+    const allowed = new Set(directories.map((directory)=>external_node_path_default().join(root, directory.relativePath)));
+    for (const change of changes){
+        allowed.add(external_node_path_default().join(root, change.relativePath));
+        if (change.publishPath) allowed.add(change.publishPath);
+    }
+    const liveDirectories = [
+        root
+    ];
+    for (const directory of directories)for (const candidate of [
+        external_node_path_default().join(root, directory.relativePath),
+        directory.temporaryPath
+    ]){
+        let stat;
+        try {
+            stat = external_node_fs_default().lstatSync(candidate);
+        } catch (error) {
+            if ('ENOENT' === error.code) continue;
+            throw error;
+        }
+        if (!stat.isDirectory() || stat.isSymbolicLink() || !sameIdentity(stat, directory)) throw new WorkspaceTransactionConflictError(`Fresh transaction directory changed; preserved at ${candidate}`);
+        if (candidate !== directory.temporaryPath) liveDirectories.push(candidate);
+    }
+    if ('committed' === receipt.state) return;
+    for (const directory of liveDirectories)for (const entry of external_node_fs_default().readdirSync(directory))if (!allowed.has(external_node_path_default().join(directory, entry))) throw new WorkspaceTransactionConflictError(`Fresh transaction conflicts with newer consumer path: ${external_node_path_default().join(directory, entry)}`);
+}
+function removeFreshDirectories(root, directories) {
+    for (const directory of [
+        ...directories
+    ].reverse()){
+        const target = external_node_path_default().join(root, directory.relativePath);
+        let stat;
+        try {
+            stat = external_node_fs_default().lstatSync(target);
+        } catch (error) {
+            if ('ENOENT' === error.code) continue;
+            throw error;
+        }
+        if (!stat.isDirectory() || stat.isSymbolicLink() || !sameIdentity(stat, directory)) throw new WorkspaceTransactionConflictError(`Fresh transaction directory changed; preserved at ${target}`);
+        external_node_fs_default().rmdirSync(target);
+    }
+}
+function recoverFreshWorkspaceTransactions(root) {
+    try {
+        const stat = external_node_fs_default().lstatSync(root);
+        if (!stat.isDirectory() || stat.isSymbolicLink()) return;
+    } catch (error) {
+        if ('ENOENT' === error.code) return;
+        throw error;
+    }
+    recoverWorkspaceTransactions(root, 'fresh-empty');
+}
+function recoverWorkspaceTransactions(root, purpose = 'update') {
+    const workspaceRoot = external_node_fs_default().realpathSync.native(root);
+    const parent = external_node_path_default().dirname(workspaceRoot);
+    const prefix = `.${external_node_path_default().basename(workspaceRoot)}.ultramodern-stage-`;
+    for (const entry of external_node_fs_default().readdirSync(parent).sort()){
+        if (!entry.startsWith(prefix) || !entry.endsWith(receiptSuffix)) continue;
+        const receiptPath = external_node_path_default().join(parent, entry);
+        const { receipt, changes } = decodeReceipt(receiptPath, workspaceRoot);
+        if ((receipt.purpose ?? 'update') === purpose) {
+            try {
+                process.kill(receipt.pid, 0);
+                throw new WorkspaceTransactionConflictError(`Workspace publication is still owned by process ${receipt.pid}: ${receiptPath}`);
+            } catch (error) {
+                if ('ESRCH' !== error.code) throw error;
+            }
+            if ('fresh-empty' === receipt.purpose) validateFreshDirectories(workspaceRoot, receipt, changes);
+            for (const change of changes){
+                if ('fresh-empty' !== receipt.purpose) ensureOwnedParentDirectories(workspaceRoot, change.relativePath, []);
+                for (const [temporary, expected] of [
+                    [
+                        change.publishPath,
+                        change.after
+                    ],
+                    [
+                        change.rollbackPath,
+                        change.before
+                    ]
+                ])if (temporary && external_node_fs_default().existsSync(temporary) && !sameFile(readFilePath(temporary, temporary), expected)) throw new WorkspaceTransactionConflictError(`Interrupted transaction temporary changed; preserved at ${temporary}`);
+                if ('committed' === receipt.state) continue;
+                const current = readWorkspaceFile(workspaceRoot, change.relativePath);
+                if (!sameFile(current, change.before)) if (sameFile(current, change.after)) {
+                    change.published = true;
+                    if (change.before && change.rollbackPath && !external_node_fs_default().existsSync(change.rollbackPath)) writeTemporaryFile(change.rollbackPath, change.before);
+                } else if (void 0 === current && change.before && change.rollbackPath && external_node_fs_default().existsSync(change.rollbackPath)) {
+                    if (!restoreQuarantinedPreimage(change, external_node_path_default().join(workspaceRoot, change.relativePath))) throw new WorkspaceTransactionConflictError(`Interrupted preimage cannot be restored: ${change.relativePath}`);
+                } else throw new WorkspaceTransactionConflictError(`Interrupted transaction conflicts with newer consumer bytes: ${change.relativePath}; receipt ${receiptPath}`);
+            }
+            if ('publishing' === receipt.state) rollbackPublishedChanges(workspaceRoot, changes);
+            cleanupPreparedChanges(changes, []);
+            if ('fresh-empty' === receipt.purpose && 'publishing' === receipt.state) removeFreshDirectories(workspaceRoot, receipt.directories);
+            removeOwnedTemporaryDirectory(receiptPath.slice(0, -receiptSuffix.length), receipt.stagingIdentity);
+            removeIfPresent(receiptPath);
+        }
+    }
+}
+function publishChangePlan(root, stagingRoot, changes, emptyTarget) {
     __transactionTestHooks.beforePublish?.({
         workspaceRoot: root,
         stagingRoot,
         changedPaths: changes.map((change)=>change.relativePath)
     });
+    if (emptyTarget) assertFreshTarget(root, emptyTarget);
     for (const change of changes)assertPreimage(root, change);
+    if (0 === changes.length) return;
     const createdDirectories = [];
-    const preparedChanges = [];
+    const preparedChanges = changes.map((change)=>({
+            ...change,
+            published: false,
+            ...change.after ? {
+                publishPath: temporaryFilePath(root, change.relativePath, 'publish')
+            } : {},
+            ...change.before ? {
+                rollbackPath: temporaryFilePath(root, change.relativePath, 'rollback')
+            } : {}
+        }));
+    const receiptPath = `${stagingRoot}${receiptSuffix}`;
+    const directories = emptyTarget ? stageFreshDirectories(stagingRoot, changes) : void 0;
+    const receipt = encodedReceipt(root, stagingRoot, preparedChanges, directories);
+    persistReceipt(receiptPath, receipt);
     try {
-        prepareChanges(root, changes, createdDirectories, preparedChanges);
+        for (const directory of directories ?? [])publishFreshDirectory(root, receipt, directory);
+        prepareChanges(root, preparedChanges, createdDirectories);
         for (const change of preparedChanges)assertPreimage(root, change);
         preparedChanges.forEach((change, index)=>{
             __transactionTestHooks.beforePublishPath?.({
@@ -459,36 +755,67 @@ function publishChangePlan(root, stagingRoot, changes) {
                 index
             });
             publishChange(root, change);
+            __transactionTestHooks.afterPublishPath?.({
+                workspaceRoot: root,
+                relativePath: change.relativePath,
+                index
+            });
+        });
+        persistReceipt(receiptPath, {
+            ...receipt,
+            state: 'committed'
         });
     } catch (error) {
         try {
+            if (directories) validateFreshDirectories(root, receipt, preparedChanges);
             rollbackPublishedChanges(root, preparedChanges);
+            if (directories) {
+                cleanupPreparedChanges(preparedChanges, []);
+                removeFreshDirectories(root, directories);
+            }
         } catch (rollbackError) {
-            throw new WorkspaceTransactionConflictError('Workspace transaction failed and concurrent target changes prevented a safe rollback.', {
-                cause: rollbackError
+            throw new WorkspaceTransactionConflictError(`Workspace transaction failed and concurrent target changes prevented a safe rollback; recovery receipt ${receiptPath}.`, {
+                cause: directories ? new AggregateError([
+                    error,
+                    rollbackError
+                ], 'Fresh publication and rollback conflicts') : rollbackError
             });
-        } finally{
-            cleanPreparedChanges(preparedChanges, createdDirectories);
         }
+        cleanPreparedChanges(preparedChanges, createdDirectories);
+        if (!preparedChanges.some((change)=>change.preserveRollback || change.preservedPaths?.length)) removeIfPresent(receiptPath);
         throw error;
     }
     cleanPreparedChanges(preparedChanges, []);
+    removeIfPresent(receiptPath);
 }
-function runWorkspaceTransaction(root, mutate) {
+function runWorkspaceTransaction(root, mutate, options = {}) {
     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}`);
+    if ('preview' !== options.mode) recoverWorkspaceTransactions(workspaceRoot);
     const stagingRoot = createTemporarySibling(workspaceRoot);
     const stagingIdentity = external_node_fs_default().lstatSync(stagingRoot);
+    const cleanup = ()=>{
+        if (!external_node_fs_default().existsSync(`${stagingRoot}${receiptSuffix}`)) cleanOwnedTemporaryDirectory(stagingRoot, stagingIdentity);
+    };
     try {
         copyWorkspaceToStage(workspaceRoot, stagingRoot);
-        const before = captureWorkspace(stagingRoot);
+        const before = captureWorkspace(stagingRoot, workspaceRoot);
+        const finish = (result)=>{
+            if (options.commitWhen && !options.commitWhen(result)) return result;
+            relocateStagedWorkspaceReferences(stagingRoot, root);
+            const changes = buildChangePlan(before, captureWorkspace(stagingRoot, workspaceRoot));
+            options.inspectChanges?.(changes);
+            if ('preview' !== options.mode) publishChangePlan(workspaceRoot, stagingRoot, changes);
+            return result;
+        };
         const result = mutate(stagingRoot);
-        relocateStagedWorkspaceReferences(stagingRoot, root);
-        const changes = buildChangePlan(before, captureWorkspace(stagingRoot));
-        publishChangePlan(workspaceRoot, stagingRoot, changes);
-        return result;
-    } finally{
-        cleanOwnedTemporaryDirectory(stagingRoot, stagingIdentity);
+        if (null !== result && ('object' == typeof result || 'function' == typeof result) && 'function' == typeof result.then) return Promise.resolve(result).then(finish).finally(cleanup);
+        const completed = finish(result);
+        cleanup();
+        return completed;
+    } catch (error) {
+        cleanup();
+        throw error;
     }
 }
 function sameIdentity(stat, identity) {
@@ -529,6 +856,7 @@ function cleanEmptyTargetRollback(rollbackPath, expected) {
 function publishFreshWorkspace(stagingRoot, workspaceRoot, target) {
     assertFreshTarget(workspaceRoot, target);
     if ('absent' === target.kind) return void external_node_fs_default().renameSync(stagingRoot, workspaceRoot);
+    if ('win32' === process.platform && currentDirectoryIs(workspaceRoot)) return void publishChangePlan(external_node_fs_default().realpathSync.native(workspaceRoot), stagingRoot, buildChangePlan(new Map(), captureWorkspace(stagingRoot, workspaceRoot)), target);
     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);
@@ -557,6 +885,7 @@ function publishFreshWorkspace(stagingRoot, workspaceRoot, target) {
 }
 function runFreshWorkspaceTransaction(targetDir, generate) {
     const workspaceRoot = external_node_path_default().resolve(targetDir);
+    recoverFreshWorkspaceTransactions(workspaceRoot);
     const target = inspectFreshTarget(workspaceRoot);
     const stagingRoot = createTemporarySibling(workspaceRoot);
     const stagingIdentity = external_node_fs_default().lstatSync(stagingRoot);
@@ -570,17 +899,21 @@ function runFreshWorkspaceTransaction(targetDir, generate) {
         publishFreshWorkspace(stagingRoot, workspaceRoot, target);
         return result;
     } finally{
-        cleanOwnedTemporaryDirectory(stagingRoot, stagingIdentity);
+        if (!external_node_fs_default().existsSync(`${stagingRoot}${receiptSuffix}`)) cleanOwnedTemporaryDirectory(stagingRoot, stagingIdentity);
     }
 }
 exports.WorkspaceTransactionConflictError = __webpack_exports__.WorkspaceTransactionConflictError;
 exports.__transactionTestHooks = __webpack_exports__.__transactionTestHooks;
+exports.recoverFreshWorkspaceTransactions = __webpack_exports__.recoverFreshWorkspaceTransactions;
+exports.recoverWorkspaceTransactions = __webpack_exports__.recoverWorkspaceTransactions;
 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",
+    "recoverFreshWorkspaceTransactions",
+    "recoverWorkspaceTransactions",
     "relocateStagedWorkspaceReferences",
     "runFreshWorkspaceTransaction",
     "runWorkspaceTransaction"