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

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

@@ -0,0 +1,108 @@
+import { apiTopologyMetadata } from "../api.js";
+import { createBackendFederationContract } from "../backend-federation.js";
+import { createDeliveryUnitRecord, deliveryUnitContractBlock } from "../delivery-unit.js";
+import { createModuleFederationRemoteContracts, createNeutralOwnership, shellApp } from "../descriptors.js";
+import { packageName, toEnvSegment, toPascalCase } from "../naming.js";
+import { createCloudflareDeployContract } from "../policy.js";
+import { isVerticalApiProtocol, isVerticalPreset, isWorkspaceDeliveryUnitKind } from "../types.js";
+function verticalTopologyEntry(scope, vertical, remotes = []) {
+    const backendFederation = createBackendFederationContract(scope, vertical);
+    return {
+        id: vertical.id,
+        kind: vertical.kind,
+        ...vertical.surfaceProfile ? {
+            surfaceProfile: vertical.surfaceProfile
+        } : {},
+        ...vertical.deliveryUnitKind ? {
+            deliveryUnitKind: vertical.deliveryUnitKind
+        } : {},
+        ...vertical.domain ? {
+            domain: vertical.domain
+        } : {},
+        package: packageName(scope, vertical.packageSuffix),
+        path: vertical.directory,
+        moduleFederation: {
+            role: 'remote',
+            name: vertical.mfName,
+            manifestUrl: `http://localhost:${vertical.port}/mf-manifest.json`,
+            exposes: Object.keys(vertical.exposes ?? {}),
+            ...vertical.verticalRefs?.length ? {
+                verticalRefs: vertical.verticalRefs,
+                remotes: createModuleFederationRemoteContracts(vertical, remotes)
+            } : {},
+            ssr: true,
+            sharedContractVersion: 'mf-ssr-contract-v1'
+        },
+        ...backendFederation ? {
+            backendFederation
+        } : {},
+        deliveryUnit: deliveryUnitContractBlock(createDeliveryUnitRecord(scope, vertical)),
+        ...apiTopologyMetadata(vertical) ? {
+            api: apiTopologyMetadata(vertical)
+        } : {},
+        cloudflare: createCloudflareDeployContract(scope, vertical),
+        ownership: vertical.ownership
+    };
+}
+function ownershipEntry(scope, owner) {
+    return {
+        id: owner.id,
+        package: packageName(scope, owner.packageSuffix),
+        path: owner.directory,
+        ownership: owner.ownership
+    };
+}
+function verticalsFromTopology(topology, ports) {
+    return (topology.verticals ?? []).map((vertical)=>{
+        const domain = vertical.domain ?? String(vertical.id);
+        const packageSuffix = vertical.package?.split('/').at(-1) ?? domain;
+        const apiTopology = vertical.api;
+        const apiProtocol = isVerticalApiProtocol(apiTopology?.protocol) ? apiTopology.protocol : void 0;
+        const surfaceProfile = isVerticalPreset(vertical.surfaceProfile) ? vertical.surfaceProfile : void 0;
+        const deliveryUnitKind = isWorkspaceDeliveryUnitKind(vertical.deliveryUnitKind) ? vertical.deliveryUnitKind : void 0;
+        const api = apiTopology?.runtime === 'effect' ? {
+            stem: 'string' == typeof apiTopology.stem ? apiTopology.stem : 'string' == typeof apiTopology.basePath ? apiTopology.basePath.split('/').filter(Boolean).at(-1) ?? domain : domain,
+            prefix: apiTopology.bff?.prefix ?? `/${domain}-api`,
+            consumedBy: Array.isArray(apiTopology.consumedBy) ? apiTopology.consumedBy : [
+                shellApp.id,
+                vertical.id
+            ],
+            ...void 0 === apiProtocol ? {} : {
+                protocol: apiProtocol
+            }
+        } : void 0;
+        return {
+            id: vertical.id,
+            directory: 'string' == typeof vertical.path ? vertical.path : `verticals/${domain}`,
+            packageSuffix,
+            displayName: vertical.displayName ?? `${toPascalCase(domain)} Vertical`,
+            kind: 'vertical',
+            domain,
+            portEnv: `VERTICAL_${toEnvSegment(domain)}_PORT`,
+            port: 'number' == typeof ports[vertical.id] ? ports[vertical.id] : 0,
+            mfName: vertical.moduleFederation?.name ?? `vertical${toPascalCase(domain)}`,
+            ...void 0 === surfaceProfile ? {} : {
+                surfaceProfile
+            },
+            ...void 0 === deliveryUnitKind ? {} : {
+                deliveryUnitKind
+            },
+            ...Array.isArray(vertical.moduleFederation?.exposes) ? {
+                exposes: Object.fromEntries(vertical.moduleFederation.exposes.map((expose)=>[
+                        expose,
+                        './Route' === expose ? './src/federation-entry.tsx' : './Widget' === expose ? `./src/components/${domain}-widget.tsx` : ''
+                    ]))
+            } : {},
+            ...Array.isArray(vertical.moduleFederation?.verticalRefs) ? {
+                verticalRefs: vertical.moduleFederation.verticalRefs
+            } : Array.isArray(vertical.moduleFederation?.remotes) ? {
+                verticalRefs: vertical.moduleFederation.remotes.map((entry)=>entry.id).filter((id)=>'string' == typeof id)
+            } : {},
+            ...api ? {
+                api
+            } : {},
+            ownership: vertical.ownership ?? createNeutralOwnership(vertical.id)
+        };
+    });
+}
+export { ownershipEntry, verticalTopologyEntry, verticalsFromTopology };

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

@@ -0,0 +1,529 @@
+import { randomUUID } from "node:crypto";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { ignoredSnapshotDirectories } from "../generation-result.js";
+import { normalizePath } from "../naming.js";
+class WorkspaceTransactionConflictError extends Error {
+    constructor(message, options){
+        super(message, options), this.code = 'workspace-transaction-conflict';
+        this.name = 'WorkspaceTransactionConflictError';
+    }
+}
+const __transactionTestHooks = {};
+function isIgnoredRelativePath(relativePath) {
+    return normalizePath(relativePath).split('/').some((segment)=>ignoredSnapshotDirectories.has(segment));
+}
+function walkWorkspaceFiles(root, onFile) {
+    if (!node_fs.existsSync(root)) return;
+    const collect = (currentDir)=>{
+        for (const entry of node_fs.readdirSync(currentDir, {
+            withFileTypes: true
+        }).sort((left, right)=>left.name.localeCompare(right.name))){
+            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 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 = node_fs.statSync(absolutePath);
+        files.set(relativePath, {
+            content: node_fs.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 = node_path.resolve(root);
+    const parent = node_path.dirname(absoluteRoot);
+    node_fs.mkdirSync(parent, {
+        recursive: true
+    });
+    return node_fs.mkdtempSync(node_path.join(parent, `.${node_path.basename(absoluteRoot)}.ultramodern-stage-`));
+}
+function removeOwnedTemporaryDirectory(temporaryRoot, identity) {
+    let current;
+    try {
+        current = node_fs.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}`);
+    node_fs.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 = node_fs.lstatSync(targetDir);
+        if (!stat.isDirectory() || stat.isSymbolicLink() || node_fs.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 {
+        node_fs.linkSync(sourcePath, targetPath);
+    } catch (error) {
+        if (![
+            'EPERM',
+            'EOPNOTSUPP',
+            'ENOTSUP',
+            'EXDEV'
+        ].includes(error.code ?? '')) throw error;
+        node_fs.copyFileSync(sourcePath, targetPath, node_fs.constants.COPYFILE_EXCL);
+    }
+}
+function copyWorkspaceToStage(root, stagingRoot) {
+    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();
+        }
+    });
+}
+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 = node_fs.readFileSync(absolutePath);
+        if (!content.includes(stagedPath)) return;
+        node_fs.writeFileSync(absolutePath, replaceBuffer(content, stagedPath, publishedPath));
+    });
+}
+function readWorkspaceFile(root, relativePath) {
+    return readFilePath(node_path.join(root, relativePath), relativePath);
+}
+function readFilePath(absolutePath, displayPath) {
+    let stat;
+    try {
+        stat = node_fs.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: node_fs.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 = node_path.join(currentPath, segment);
+        try {
+            const stat = node_fs.lstatSync(currentPath);
+            if (!stat.isDirectory() || stat.isSymbolicLink()) throw new WorkspaceTransactionConflictError(`Workspace parent changed type during generation: ${normalizePath(node_path.relative(root, currentPath))}`);
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+            try {
+                node_fs.mkdirSync(currentPath);
+                createdDirectories.push(currentPath);
+            } catch (mkdirError) {
+                if ('EEXIST' !== mkdirError.code) throw mkdirError;
+                const stat = node_fs.lstatSync(currentPath);
+                if (!stat.isDirectory() || stat.isSymbolicLink()) throw new WorkspaceTransactionConflictError(`Workspace parent changed type during generation: ${normalizePath(node_path.relative(root, currentPath))}`);
+            }
+        }
+    }
+}
+function temporaryFilePath(root, relativePath, role) {
+    const targetPath = node_path.join(root, relativePath);
+    return node_path.join(node_path.dirname(targetPath), `.${node_path.basename(targetPath)}.ultramodern-${role}-${randomUUID()}.tmp`);
+}
+function writeTemporaryFile(filePath, file) {
+    node_fs.writeFileSync(filePath, file.content, {
+        flag: 'wx',
+        mode: file.mode
+    });
+}
+function removeIfPresent(filePath) {
+    if (!filePath) return;
+    try {
+        node_fs.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 = node_path.join(root, change.relativePath);
+        if (void 0 === change.before) {
+            const discardedPath = quarantinePublishedFile(root, change, targetPath);
+            removeIfPresent(discardedPath);
+            if (node_fs.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');
+    node_fs.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 {
+        node_fs.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 = node_fs.lstatSync(quarantinePath);
+        if (moved.isFile()) node_fs.linkSync(quarantinePath, targetPath);
+        else {
+            if (!moved.isSymbolicLink()) return false;
+            node_fs.symlinkSync(node_fs.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 = node_path.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}`);
+        node_fs.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 = node_fs.realpathSync.native(node_path.resolve(root));
+    if (!node_fs.statSync(workspaceRoot).isDirectory()) throw new Error(`Workspace root is not a directory: ${root}`);
+    const stagingRoot = createTemporarySibling(workspaceRoot);
+    const stagingIdentity = node_fs.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(node_fs.statSync('.'), node_fs.statSync(targetDir));
+    } catch  {
+        return false;
+    }
+}
+function restoreEmptyTarget(rollbackPath, targetDir) {
+    try {
+        node_fs.lstatSync(targetDir);
+        return false;
+    } catch (error) {
+        if ('ENOENT' !== error.code) return false;
+    }
+    try {
+        node_fs.renameSync(rollbackPath, targetDir);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function cleanEmptyTargetRollback(rollbackPath, expected) {
+    try {
+        const current = node_fs.lstatSync(rollbackPath);
+        if (!sameIdentity(current, expected) || !current.isDirectory() || node_fs.readdirSync(rollbackPath).length > 0) throw new WorkspaceTransactionConflictError(`Preserving changed empty-target rollback at ${rollbackPath}`);
+        node_fs.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 node_fs.renameSync(stagingRoot, workspaceRoot);
+    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);
+    let committed = false;
+    try {
+        const moved = node_fs.lstatSync(rollbackPath);
+        if (!sameIdentity(moved, target) || !moved.isDirectory() || node_fs.readdirSync(rollbackPath).length > 0) throw new WorkspaceTransactionConflictError(`Workspace target changed during generation: ${workspaceRoot}`);
+        node_fs.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 = node_path.resolve(targetDir);
+    const target = inspectFreshTarget(workspaceRoot);
+    const stagingRoot = createTemporarySibling(workspaceRoot);
+    const stagingIdentity = node_fs.lstatSync(stagingRoot);
+    node_fs.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);
+    }
+}
+export { WorkspaceTransactionConflictError, __transactionTestHooks, relocateStagedWorkspaceReferences, runFreshWorkspaceTransaction, runWorkspaceTransaction };