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

package/dist/esm/ultramodern-workspace/add-vertical/transaction.js

@@ -11,7 +11,18 @@ class WorkspaceTransactionConflictError extends Error {
 }
 const __transactionTestHooks = {};
 function isIgnoredRelativePath(relativePath) {
-    return normalizePath(relativePath).split('/').some((segment)=>ignoredSnapshotDirectories.has(segment));
+    const segments = normalizePath(relativePath).split('/');
+    return segments.some((segment, index)=>{
+        if (1 === index && [
+            'apps',
+            'verticals',
+            'packages'
+        ].includes(segments[0]) && [
+            'dist',
+            'coverage'
+        ].includes(segment)) return false;
+        return ignoredSnapshotDirectories.has(segment);
+    });
 }
 function walkWorkspaceFiles(root, onFile) {
     if (!node_fs.existsSync(root)) return;
@@ -22,26 +33,30 @@ function walkWorkspaceFiles(root, onFile) {
             const entryPath = node_path.join(currentDir, entry.name);
             const relativePath = normalizePath(node_path.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 = node_fs.statSync(absolutePath);
+        const stat = node_fs.lstatSync(absolutePath);
+        const target = stat.isSymbolicLink() ? node_fs.readlinkSync(absolutePath) : void 0;
         files.set(relativePath, {
-            content: node_fs.readFileSync(absolutePath),
-            mode: 511 & stat.mode
+            content: void 0 === target ? node_fs.readFileSync(absolutePath) : Buffer.from(node_path.isAbsolute(target) && isInside(root, target) ? node_path.join(publishedRoot, node_path.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 [
@@ -67,7 +82,7 @@ function createTemporarySibling(root) {
     node_fs.mkdirSync(parent, {
         recursive: true
     });
-    return node_fs.mkdtempSync(node_path.join(parent, `.${node_path.basename(absoluteRoot)}.ultramodern-stage-`));
+    return node_fs.realpathSync.native(node_fs.mkdtempSync(node_path.join(parent, `.${node_path.basename(absoluteRoot)}.ultramodern-stage-`)));
 }
 function removeOwnedTemporaryDirectory(temporaryRoot, identity) {
     let current;
@@ -119,6 +134,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 (node_fs.lstatSync(sourcePath).isSymbolicLink()) return void node_fs.symlinkSync(node_fs.readlinkSync(sourcePath), targetPath);
     try {
         node_fs.linkSync(sourcePath, targetPath);
     } catch (error) {
@@ -131,15 +147,36 @@ function publishFileExclusive(sourcePath, targetPath) {
         node_fs.copyFileSync(sourcePath, targetPath, node_fs.constants.COPYFILE_EXCL);
     }
 }
+function isInside(root, target) {
+    const relative = node_path.relative(root, target);
+    return '..' !== relative && !relative.startsWith(`..${node_path.sep}`) && !node_path.isAbsolute(relative);
+}
 function copyWorkspaceToStage(root, stagingRoot) {
+    walkWorkspaceFiles(root, (relativePath, absolutePath)=>{
+        if (!node_fs.lstatSync(absolutePath).isSymbolicLink()) return;
+        let target;
+        try {
+            target = node_fs.realpathSync.native(absolutePath);
+        } catch (cause) {
+            throw new WorkspaceTransactionConflictError(`Unsupported dangling or cyclic workspace link: ${relativePath}`, {
+                cause
+            });
+        }
+        if (!isInside(root, target) || isIgnoredRelativePath(node_path.relative(root, target))) throw new WorkspaceTransactionConflictError(`Workspace transaction conflict: link escapes the staged input: ${relativePath}`);
+    });
     node_fs.cpSync(root, stagingRoot, {
         mode: node_fs.constants.COPYFILE_FICLONE,
         recursive: true,
-        filter (sourcePath) {
-            const relativePath = node_path.relative(root, sourcePath);
-            if ('' === relativePath) return true;
-            if (isIgnoredRelativePath(relativePath)) return false;
-            return !node_fs.lstatSync(sourcePath).isSymbolicLink();
+        verbatimSymlinks: true,
+        filter: (sourcePath)=>!isIgnoredRelativePath(node_path.relative(root, sourcePath))
+    });
+    walkWorkspaceFiles(stagingRoot, (_relativePath, absolutePath)=>{
+        if (!node_fs.lstatSync(absolutePath).isSymbolicLink()) return;
+        const target = node_fs.readlinkSync(absolutePath);
+        if (node_path.isAbsolute(target)) {
+            const realTarget = node_fs.realpathSync.native(target);
+            node_fs.unlinkSync(absolutePath);
+            node_fs.symlinkSync(node_path.join(stagingRoot, node_path.relative(root, realTarget)), absolutePath);
         }
     });
 }
@@ -159,6 +196,7 @@ function relocateStagedWorkspaceReferences(stagingRoot, workspaceRoot) {
     const stagedPath = Buffer.from(stagingRoot);
     const publishedPath = Buffer.from(workspaceRoot);
     walkWorkspaceFiles(stagingRoot, (_relativePath, absolutePath)=>{
+        if (node_fs.lstatSync(absolutePath).isSymbolicLink()) return;
         const content = node_fs.readFileSync(absolutePath);
         if (!content.includes(stagedPath)) return;
         node_fs.writeFileSync(absolutePath, replaceBuffer(content, stagedPath, publishedPath));
@@ -175,10 +213,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: node_fs.readFileSync(absolutePath),
-        mode: 511 & stat.mode
+        content: stat.isSymbolicLink() ? Buffer.from(node_fs.readlinkSync(absolutePath)) : node_fs.readFileSync(absolutePath),
+        mode: 4095 & stat.mode,
+        ...stat.isSymbolicLink() ? {
+            symlink: true
+        } : {}
     };
 }
 function assertPreimage(root, change) {
@@ -210,6 +251,7 @@ function temporaryFilePath(root, relativePath, role) {
     return node_path.join(node_path.dirname(targetPath), `.${node_path.basename(targetPath)}.ultramodern-${role}-${randomUUID()}.tmp`);
 }
 function writeTemporaryFile(filePath, file) {
+    if (file.symlink) return void node_fs.symlinkSync(file.content.toString(), filePath);
     node_fs.writeFileSync(filePath, file.content, {
         flag: 'wx',
         mode: file.mode
@@ -225,19 +267,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) {
@@ -393,17 +426,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 = node_fs.openSync(temporary, 'wx', 384);
+    try {
+        node_fs.writeFileSync(fd, JSON.stringify(receipt));
+        node_fs.fsyncSync(fd);
+    } finally{
+        node_fs.closeSync(fd);
+    }
+    node_fs.renameSync(temporary, receiptPath);
+    if ('win32' === process.platform) return;
+    const directory = node_fs.openSync(node_path.dirname(receiptPath), 'r');
+    try {
+        node_fs.fsyncSync(directory);
+    } finally{
+        node_fs.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 } = node_fs.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 = node_fs.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(node_fs.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(node_fs.lstatSync(root), receipt.rootIdentity) || !sameIdentity(node_fs.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 || node_path.isAbsolute(relative) || normalizePath(node_path.normalize(relative)) !== relative || !isInside(root, node_path.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 || node_path.dirname(temporary) !== node_path.dirname(node_path.join(root, relative)) || !node_path.basename(temporary).startsWith(`.${node_path.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 || node_path.dirname(directory.temporaryPath) !== stagingRoot || !/^\.ultramodern-directory-[\da-f-]+\.tmp$/u.test(node_path.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 = node_path.join(stagingRoot, `.ultramodern-directory-${randomUUID()}.tmp`);
+        node_fs.mkdirSync(temporaryPath, {
+            mode: 511 & node_fs.statSync(node_path.join(stagingRoot, relativePath)).mode
+        });
+        const { dev, ino } = node_fs.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 = node_path.join(root, relative);
+        const stat = node_fs.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 = node_path.join(root, directory.relativePath);
+    assertFreshDirectoryAncestors(root, receipt, directory.relativePath);
+    const staged = node_fs.lstatSync(directory.temporaryPath);
+    const stagingRoot = node_path.dirname(directory.temporaryPath);
+    if (!staged.isDirectory() || staged.isSymbolicLink() || !sameIdentity(staged, directory) || !sameIdentity(node_fs.lstatSync(stagingRoot), receipt.stagingIdentity)) throw new WorkspaceTransactionConflictError(`Fresh transaction staged directory changed: ${directory.temporaryPath}`);
+    if (node_fs.existsSync(target)) throw new WorkspaceTransactionConflictError(`Fresh transaction directory appeared: ${target}`);
+    node_fs.renameSync(directory.temporaryPath, target);
+    try {
+        assertFreshDirectoryAncestors(root, receipt, directory.relativePath);
+        const published = node_fs.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)=>node_path.join(root, directory.relativePath)));
+    for (const change of changes){
+        allowed.add(node_path.join(root, change.relativePath));
+        if (change.publishPath) allowed.add(change.publishPath);
+    }
+    const liveDirectories = [
+        root
+    ];
+    for (const directory of directories)for (const candidate of [
+        node_path.join(root, directory.relativePath),
+        directory.temporaryPath
+    ]){
+        let stat;
+        try {
+            stat = node_fs.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 node_fs.readdirSync(directory))if (!allowed.has(node_path.join(directory, entry))) throw new WorkspaceTransactionConflictError(`Fresh transaction conflicts with newer consumer path: ${node_path.join(directory, entry)}`);
+}
+function removeFreshDirectories(root, directories) {
+    for (const directory of [
+        ...directories
+    ].reverse()){
+        const target = node_path.join(root, directory.relativePath);
+        let stat;
+        try {
+            stat = node_fs.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}`);
+        node_fs.rmdirSync(target);
+    }
+}
+function recoverFreshWorkspaceTransactions(root) {
+    try {
+        const stat = node_fs.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 = node_fs.realpathSync.native(root);
+    const parent = node_path.dirname(workspaceRoot);
+    const prefix = `.${node_path.basename(workspaceRoot)}.ultramodern-stage-`;
+    for (const entry of node_fs.readdirSync(parent).sort()){
+        if (!entry.startsWith(prefix) || !entry.endsWith(receiptSuffix)) continue;
+        const receiptPath = node_path.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 && node_fs.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 && !node_fs.existsSync(change.rollbackPath)) writeTemporaryFile(change.rollbackPath, change.before);
+                } else if (void 0 === current && change.before && change.rollbackPath && node_fs.existsSync(change.rollbackPath)) {
+                    if (!restoreQuarantinedPreimage(change, node_path.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?.({
@@ -412,36 +706,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 = node_fs.realpathSync.native(node_path.resolve(root));
     if (!node_fs.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 = node_fs.lstatSync(stagingRoot);
+    const cleanup = ()=>{
+        if (!node_fs.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) {
@@ -482,6 +807,7 @@ function cleanEmptyTargetRollback(rollbackPath, expected) {
 function publishFreshWorkspace(stagingRoot, workspaceRoot, target) {
     assertFreshTarget(workspaceRoot, target);
     if ('absent' === target.kind) return void node_fs.renameSync(stagingRoot, workspaceRoot);
+    if ('win32' === process.platform && currentDirectoryIs(workspaceRoot)) return void publishChangePlan(node_fs.realpathSync.native(workspaceRoot), stagingRoot, buildChangePlan(new Map(), captureWorkspace(stagingRoot, workspaceRoot)), target);
     const rollbackPath = node_path.join(node_path.dirname(workspaceRoot), `.${node_path.basename(workspaceRoot)}.ultramodern-empty-${randomUUID()}.tmp`);
     const restoreCwd = currentDirectoryIs(workspaceRoot);
     node_fs.renameSync(workspaceRoot, rollbackPath);
@@ -510,6 +836,7 @@ function publishFreshWorkspace(stagingRoot, workspaceRoot, target) {
 }
 function runFreshWorkspaceTransaction(targetDir, generate) {
     const workspaceRoot = node_path.resolve(targetDir);
+    recoverFreshWorkspaceTransactions(workspaceRoot);
     const target = inspectFreshTarget(workspaceRoot);
     const stagingRoot = createTemporarySibling(workspaceRoot);
     const stagingIdentity = node_fs.lstatSync(stagingRoot);
@@ -523,7 +850,7 @@ function runFreshWorkspaceTransaction(targetDir, generate) {
         publishFreshWorkspace(stagingRoot, workspaceRoot, target);
         return result;
     } finally{
-        cleanOwnedTemporaryDirectory(stagingRoot, stagingIdentity);
+        if (!node_fs.existsSync(`${stagingRoot}${receiptSuffix}`)) cleanOwnedTemporaryDirectory(stagingRoot, stagingIdentity);
     }
 }
-export { WorkspaceTransactionConflictError, __transactionTestHooks, relocateStagedWorkspaceReferences, runFreshWorkspaceTransaction, runWorkspaceTransaction };
+export { WorkspaceTransactionConflictError, __transactionTestHooks, recoverFreshWorkspaceTransactions, recoverWorkspaceTransactions, relocateStagedWorkspaceReferences, runFreshWorkspaceTransaction, runWorkspaceTransaction };

package/dist/esm/ultramodern-workspace/add-vertical/workspace-state.js

@@ -1,47 +1,35 @@
 import node_fs from "node:fs";
 import node_path from "node:path";
-import { readUltramodernConfig } from "../../ultramodern-tooling/config.js";
-import { ULTRAMODERN_CONFIG_PATH } from "../descriptors.js";
 import { toKebabCase } from "../naming.js";
 import { resolvePackageSource } from "../package-source.js";
 import { FIRST_VERTICAL_PORT } from "./constants.js";
-function existingPackageSource(workspaceRoot, modernVersion, packageSource) {
-    if (packageSource) return resolvePackageSource({
-        targetDir: workspaceRoot,
-        packageName: node_path.basename(workspaceRoot),
-        modernVersion,
-        packageSource
-    });
-    const compactPath = node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH);
-    if (node_fs.existsSync(compactPath)) {
-        const compactConfig = readUltramodernConfig(workspaceRoot);
-        if (compactConfig.packageSource) return compactConfig.packageSource;
-    }
-    throw new Error(`Missing UltraModern workspace file: ${compactPath}`);
-}
-function existingTailwindEnabled(workspaceRoot) {
-    const compactPath = node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH);
-    if (node_fs.existsSync(compactPath)) return readUltramodernConfig(workspaceRoot).features.tailwind;
-    throw new Error(`Missing UltraModern workspace file: ${compactPath}`);
-}
-function existingBridgeConfig(workspaceRoot) {
-    const compactPath = node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH);
-    return node_fs.existsSync(compactPath) ? readUltramodernConfig(workspaceRoot).bridge : void 0;
+function workspaceOperationSettings(options, config) {
+    const packageSource = options.packageSource ? resolvePackageSource({
+        targetDir: options.workspaceRoot,
+        packageName: node_path.basename(options.workspaceRoot),
+        modernVersion: options.modernVersion,
+        packageSource: options.packageSource
+    }) : config.packageSource;
+    if (!packageSource) throw new Error(`Missing UltraModern package source in workspace manifests: ${options.workspaceRoot}`);
+    return {
+        packageSource,
+        enableTailwind: options.enableTailwind ?? config.features.tailwind,
+        bridge: void 0
+    };
 }
 function assertValidVerticalName(name) {
     const normalized = toKebabCase(name);
     if (!normalized || normalized !== name) throw new Error(`Invalid Vertical name "${name}". Use lowercase kebab-case.`);
     return normalized;
 }
-function configuredDevelopmentPorts(ports, additionalShells = []) {
+function configuredDevelopmentPorts(ports, _additionalShells = []) {
     return [
         ...new Set([
-            ...Object.values(ports),
-            ...additionalShells.map((shell)=>shell.port)
+            ...Object.values(ports)
         ].filter((value)=>'number' == typeof value && Number.isFinite(value)))
     ];
 }
-function assertGlobalPortUniqueness(ports, additionalShells = []) {
+function assertGlobalPortUniqueness(ports, _additionalShells = []) {
     const owners = new Map();
     for (const [id, value] of Object.entries(ports)){
         if ('number' != typeof value || !Number.isFinite(value)) continue;
@@ -49,11 +37,6 @@ function assertGlobalPortUniqueness(ports, additionalShells = []) {
         if (previous) throw new Error(`Duplicate development port "${value}" for ${previous} and ${id}.`);
         owners.set(value, id);
     }
-    for (const shell of additionalShells){
-        const previous = owners.get(shell.port);
-        if (previous) throw new Error(`Duplicate development port "${shell.port}" for ${previous} and ${shell.id}.`);
-        owners.set(shell.port, shell.id);
-    }
 }
 function nextAvailablePort(ports, additionalShells = [], minimumPort = FIRST_VERTICAL_PORT) {
     const used = new Set(configuredDevelopmentPorts(ports, additionalShells));
@@ -64,4 +47,4 @@ function nextAvailablePort(ports, additionalShells = [], minimumPort = FIRST_VER
 function assertCanCreate(workspaceRoot, relativePath) {
     if (node_fs.existsSync(node_path.join(workspaceRoot, relativePath))) throw new Error(`Refusing to overwrite existing path: ${relativePath}`);
 }
-export { assertCanCreate, assertGlobalPortUniqueness, assertValidVerticalName, configuredDevelopmentPorts, existingBridgeConfig, existingPackageSource, existingTailwindEnabled, nextAvailablePort };
+export { assertCanCreate, assertGlobalPortUniqueness, assertValidVerticalName, configuredDevelopmentPorts, nextAvailablePort, workspaceOperationSettings };

package/dist/esm/ultramodern-workspace/add-vertical.js

@@ -3,4 +3,4 @@ export { planUltramodernVertical } from "./add-vertical/plan.js";
 export { prepareAddUltramodernVertical } from "./add-vertical/preflight.js";
 export { rewriteShellAppFiles, updateRootWorkspaceScripts } from "./add-vertical/shell-files.js";
 export { ownershipEntry, verticalTopologyEntry, verticalsFromTopology } from "./add-vertical/topology.js";
-export { assertCanCreate, assertValidVerticalName, existingBridgeConfig, existingPackageSource, existingTailwindEnabled, nextAvailablePort } from "./add-vertical/workspace-state.js";
+export { assertCanCreate, assertValidVerticalName, nextAvailablePort } from "./add-vertical/workspace-state.js";