@bleedingdev/modern-js-create 3.5.0-ultramodern.6 → 3.5.0-ultramodern.76

package/dist/esm/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts-oxfmt.js

@@ -0,0 +1,83 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+function ensureGeneratedOxfmtIgnorePatterns(io) {
+    const configPath = node_path.join(io.workspaceRoot, 'oxfmt.config.ts');
+    if (!node_fs.existsSync(configPath)) return false;
+    const source = node_fs.readFileSync(configPath, 'utf-8');
+    const requiredPatterns = [
+        '.modernjs',
+        '.output',
+        '**/modern-tanstack/**',
+        '**/routeTree.gen.*'
+    ];
+    const warnUnparseable = ()=>{
+        const message = `Could not update oxfmt.config.ts ignorePatterns automatically; add these entries manually: ${requiredPatterns.join(', ')}.`;
+        if (io.dryRun) io.log(message);
+        else process.stderr.write(`[ultramodern] ${message}\n`);
+    };
+    const anchor = source.indexOf('ignorePatterns:');
+    if (-1 === anchor) {
+        warnUnparseable();
+        return false;
+    }
+    const openBracket = source.indexOf('[', anchor);
+    if (-1 === openBracket) {
+        warnUnparseable();
+        return false;
+    }
+    let depth = 0;
+    let closeBracket = -1;
+    let stringQuote;
+    for(let index = openBracket; index < source.length; index += 1){
+        const char = source[index];
+        if (stringQuote) {
+            if ('\\' === char) index += 1;
+            else if (char === stringQuote) stringQuote = void 0;
+            continue;
+        }
+        if ("'" === char || '"' === char || '`' === char) stringQuote = char;
+        else if ('[' === char) depth += 1;
+        else if (']' === char) {
+            depth -= 1;
+            if (0 === depth) {
+                closeBracket = index;
+                break;
+            }
+        }
+    }
+    if (-1 === closeBracket) {
+        warnUnparseable();
+        return false;
+    }
+    const body = source.slice(openBracket + 1, closeBracket);
+    if (body.includes('...')) {
+        warnUnparseable();
+        return false;
+    }
+    const literalPattern = /(['"`])((?:\\.|(?!\1).)*)\1/g;
+    const existing = new Set();
+    for (const match of body.matchAll(literalPattern))existing.add(match[2]);
+    const missing = requiredPatterns.filter((pattern)=>!existing.has(pattern));
+    if (0 === missing.length) return false;
+    const bodyLines = body.split('\n');
+    let indent = '  ';
+    let quote = "'";
+    for(let index = bodyLines.length - 1; index >= 0; index -= 1){
+        const literal = bodyLines[index].match(/^(\s*)(['"`])/u);
+        if (literal) {
+            indent = literal[1];
+            quote = literal[2];
+            break;
+        }
+    }
+    const head = source.slice(0, closeBracket);
+    const rest = source.slice(closeBracket);
+    const tailMatch = head.match(/(\r?\n[ \t]*)$/u);
+    const tail = tailMatch ? tailMatch[1] : '\n';
+    let bodyContent = tailMatch ? head.slice(0, head.length - tail.length) : head;
+    if (!/[[,]\s*$/u.test(bodyContent)) bodyContent = `${bodyContent},`;
+    const insertionLines = missing.map((pattern)=>`${indent}${quote}${pattern}${quote},`).join('\n');
+    const nextSource = `${bodyContent}\n${insertionLines}${tail}${rest}`;
+    return io.write(configPath, nextSource);
+}
+export { ensureGeneratedOxfmtIgnorePatterns };

package/dist/esm/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts-removal.js

@@ -0,0 +1,16 @@
+import node_path from "node:path";
+import { allWorkspaceAppsFromToolingConfig } from "../../config.js";
+function removeGeneratedFileIfExists(io, relativePath) {
+    return io.remove(node_path.join(io.workspaceRoot, relativePath));
+}
+function removeStaleBackendFederationArtifacts(io, config) {
+    let changed = false;
+    for (const relativePath of [
+        "scripts/generate-node-backend-federation.mts",
+        "scripts/proof-node-backend-federation.mts",
+        "scripts/verify-cloudflare-output.mts"
+    ])changed = removeGeneratedFileIfExists(io, relativePath) || changed;
+    for (const app of allWorkspaceAppsFromToolingConfig(config))changed = removeGeneratedFileIfExists(io, node_path.join(app.directory, 'api/backend-federation.ts')) || changed;
+    return changed;
+}
+export { removeGeneratedFileIfExists, removeStaleBackendFederationArtifacts };

package/dist/esm/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts-typescript.js

@@ -0,0 +1,156 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { createAppEnvDts, createAppRuntimeConfig } from "../../../ultramodern-workspace/app-files.js";
+import { createRemoteExposeFragmentPage, regenerateGeneratedNavigationSurface, remoteComponentOutputPath } from "../../../ultramodern-workspace/demo-components.js";
+import { appI18nNamespace, distributedSsrExposes, distributedSsrFragmentSlug, resolveRemoteRefs } from "../../../ultramodern-workspace/descriptors.js";
+import { createAppMfTypesTsConfig, createAppTsConfig, createSharedPackageTsConfig, createTsConfigBase } from "../../../ultramodern-workspace/package-json.js";
+import { allWorkspaceAppsFromToolingConfig } from "../../config.js";
+import { writeJsonIfChanged, writeTextIfChanged } from "./io.js";
+function jsonObject(value) {
+    return null === value || 'object' != typeof value || Array.isArray(value) ? void 0 : value;
+}
+function readJsonObject(filePath) {
+    if (!node_fs.existsSync(filePath)) return;
+    return jsonObject(JSON.parse(node_fs.readFileSync(filePath, 'utf-8')));
+}
+function generatedManifest(io, config) {
+    const sourcePath = node_path.isAbsolute(config.sourcePath) ? config.sourcePath : node_path.join(io.workspaceRoot, config.sourcePath);
+    const manifest = readJsonObject(sourcePath);
+    const generator = jsonObject(manifest?.generator);
+    return generator?.package === '@modern-js/create' ? manifest : void 0;
+}
+function manifestApps(manifest) {
+    const topology = jsonObject(manifest.topology);
+    return Array.isArray(topology?.apps) ? topology.apps.map(jsonObject).filter((app)=>void 0 !== app) : [];
+}
+function packageManifest(io, appDirectory) {
+    return readJsonObject(node_path.join(io.workspaceRoot, appDirectory, 'package.json'));
+}
+function shellSurfaceIsOwned(io, app, manifestApp) {
+    const packageJson = packageManifest(io, app.directory);
+    const moduleFederation = jsonObject(manifestApp.moduleFederation);
+    return 'shell' === manifestApp.kind && manifestApp.path === app.directory && moduleFederation?.role === 'host' && 'string' == typeof manifestApp.package && packageJson?.name === manifestApp.package;
+}
+function deliveryUnitSurfaceIsOwned(io, config, app, manifestApp, expose, sourcePath) {
+    const deliveryUnit = jsonObject(manifestApp.deliveryUnit);
+    const moduleFederation = jsonObject(manifestApp.moduleFederation);
+    const packageJson = packageManifest(io, app.directory);
+    const packageExports = jsonObject(packageJson?.exports);
+    const exposedSurfaces = Array.isArray(moduleFederation?.exposes) ? moduleFederation.exposes : [];
+    const packageName = manifestApp.package;
+    return 'vertical' === manifestApp.kind && manifestApp.path === app.directory && 'string' == typeof packageName && packageJson?.name === packageName && deliveryUnit?.kind === 'microvertical-delivery-unit' && deliveryUnit.packageName === packageName && deliveryUnit.unitId === `${config.workspace.packageScope}/${app.id}` && exposedSurfaces.includes(expose) && packageExports?.[expose] === sourcePath;
+}
+function updateGeneratedNavigationSurfaces(io, config) {
+    const manifest = generatedManifest(io, config);
+    if (void 0 === manifest) return false;
+    const apps = allWorkspaceAppsFromToolingConfig(config);
+    const appsById = new Map(manifestApps(manifest).map((app)=>[
+            String(app.id ?? ''),
+            app
+        ]));
+    let changed = false;
+    for (const app of apps){
+        const manifestApp = appsById.get(app.id);
+        if (void 0 !== manifestApp) {
+            if ('shell' === app.kind && shellSurfaceIsOwned(io, app, manifestApp)) {
+                const filePath = node_path.join(io.workspaceRoot, app.directory, 'src/routes/shell-frame.tsx');
+                if (node_fs.existsSync(filePath)) {
+                    const source = node_fs.readFileSync(filePath, 'utf-8');
+                    changed = writeTextIfChanged(io, filePath, regenerateGeneratedNavigationSurface(source, 'shell-frame')) || changed;
+                }
+                continue;
+            }
+            for (const [expose, sourcePath] of Object.entries(app.exposes ?? {})){
+                const isCheckoutNavigationSurface = './AddToCart' === expose && './src/components/add-to-cart.tsx' === sourcePath || './CheckoutPage' === expose && './src/components/checkout-page.tsx' === sourcePath;
+                if ('checkout' !== app.id || !isCheckoutNavigationSurface) continue;
+                const relativePath = remoteComponentOutputPath(app, expose);
+                if (void 0 === relativePath || !deliveryUnitSurfaceIsOwned(io, config, app, manifestApp, expose, sourcePath)) continue;
+                const filePath = node_path.join(io.workspaceRoot, relativePath);
+                if (!node_fs.existsSync(filePath)) continue;
+                const source = node_fs.readFileSync(filePath, 'utf-8');
+                if (source.includes(`data-modern-boundary-id="${app.id}"`) && source.includes(`data-modern-mf-expose="${expose}"`)) changed = writeTextIfChanged(io, filePath, regenerateGeneratedNavigationSurface(source, 'demo-component')) || changed;
+            }
+        }
+    }
+    return changed;
+}
+function ensureGeneratedIgnoreRules(io) {
+    const gitignorePath = node_path.join(io.workspaceRoot, '.gitignore');
+    const existing = node_fs.existsSync(gitignorePath) ? node_fs.readFileSync(gitignorePath, 'utf-8') : '';
+    const lines = 0 === existing.trimEnd().length ? [] : existing.trimEnd().split(/\r?\n/u);
+    let changed = false;
+    for (const rule of [
+        '.mf/',
+        '**/.mf/',
+        'dist-cloudflare/',
+        '.output/',
+        '**/.output/',
+        '.modern-js/',
+        '**/.modern-js/',
+        '**/src/modern-tanstack/',
+        '**/.tsgo.*.resolved.json'
+    ])if (!lines.includes(rule)) {
+        lines.push(rule);
+        changed = true;
+    }
+    if (!changed) return false;
+    return io.write(gitignorePath, `${lines.join('\n')}\n`);
+}
+function updateGeneratedShellRuntimeSurfaces(io, config) {
+    const manifest = generatedManifest(io, config);
+    if (void 0 === manifest) return false;
+    const apps = allWorkspaceAppsFromToolingConfig(config);
+    const remotes = apps.filter((app)=>'shell' !== app.kind);
+    const appsById = new Map(manifestApps(manifest).map((app)=>[
+            String(app.id ?? ''),
+            app
+        ]));
+    let changed = false;
+    for (const app of apps.filter((app)=>'shell' === app.kind)){
+        const manifestApp = appsById.get(app.id);
+        if (void 0 === manifestApp || !shellSurfaceIsOwned(io, app, manifestApp)) continue;
+        const runtimePath = node_path.join(io.workspaceRoot, app.directory, 'src/modern.runtime.ts');
+        if (!node_fs.existsSync(runtimePath)) continue;
+        const runtimeSource = node_fs.readFileSync(runtimePath, 'utf-8');
+        if (!runtimeSource.includes('/verticals/') || !runtimeSource.includes('/locales/')) continue;
+        const shellRemotes = resolveRemoteRefs(app, remotes);
+        for (const language of [
+            'en',
+            'cs'
+        ]){
+            const shellLocaleDirectory = node_path.join(io.workspaceRoot, app.directory, 'locales', language);
+            const shellLocale = readJsonObject(node_path.join(shellLocaleDirectory, `${appI18nNamespace(app)}.json`)) ?? {};
+            const mergedLocale = Object.assign({}, shellLocale, ...shellRemotes.map((remote)=>readJsonObject(node_path.join(io.workspaceRoot, remote.directory, 'locales', language, `${appI18nNamespace(remote)}.json`))));
+            changed = writeJsonIfChanged(io, node_path.join(shellLocaleDirectory, `${appI18nNamespace(app)}.json`), mergedLocale) || changed;
+            changed = writeJsonIfChanged(io, node_path.join(shellLocaleDirectory, 'translation.json'), mergedLocale) || changed;
+        }
+        changed = writeTextIfChanged(io, runtimePath, createAppRuntimeConfig(app, config.workspace.packageScope, remotes)) || changed;
+    }
+    return changed;
+}
+function updateGeneratedTypeScriptSurfaces(io, config) {
+    let changed = false;
+    const apps = allWorkspaceAppsFromToolingConfig(config);
+    const remotes = apps.filter((app)=>'shell' !== app.kind);
+    changed = writeJsonIfChanged(io, node_path.join(io.workspaceRoot, 'tsconfig.base.json'), createTsConfigBase()) || changed;
+    changed = ensureGeneratedIgnoreRules(io) || changed;
+    for (const sharedPackage of [
+        'packages/shared-contracts',
+        'packages/shared-design-tokens'
+    ])changed = writeJsonIfChanged(io, node_path.join(io.workspaceRoot, sharedPackage, 'tsconfig.json'), createSharedPackageTsConfig(sharedPackage)) || changed;
+    for (const app of apps){
+        changed = writeJsonIfChanged(io, node_path.join(io.workspaceRoot, app.directory, 'tsconfig.json'), createAppTsConfig(app, remotes)) || changed;
+        changed = writeJsonIfChanged(io, node_path.join(io.workspaceRoot, app.directory, 'tsconfig.mf-types.json'), createAppMfTypesTsConfig(app)) || changed;
+        changed = writeTextIfChanged(io, node_path.join(io.workspaceRoot, app.directory, 'src/modern-app-env.d.ts'), createAppEnvDts(app, remotes, config.workspace.packageScope)) || changed;
+        if ('shell' !== app.kind) for (const expose of distributedSsrExposes(app)){
+            const fragmentPagePath = node_path.join(io.workspaceRoot, app.directory, 'src/routes/[lang]/_mf/fragment', distributedSsrFragmentSlug(expose), 'page.tsx');
+            if (!node_fs.existsSync(fragmentPagePath)) continue;
+            const fragmentPageSource = node_fs.readFileSync(fragmentPagePath, 'utf-8');
+            if (fragmentPageSource.includes("from '@modern-js/runtime/module-federation';") && fragmentPageSource.includes('data-modern-distributed-ssr-marker="start"')) changed = writeTextIfChanged(io, fragmentPagePath, createRemoteExposeFragmentPage(app, expose)) || changed;
+        }
+    }
+    changed = updateGeneratedShellRuntimeSurfaces(io, config) || changed;
+    changed = updateGeneratedNavigationSurfaces(io, config) || changed;
+    return changed;
+}
+export { updateGeneratedTypeScriptSurfaces };

package/dist/esm/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts-zerops.js

@@ -0,0 +1,12 @@
+import node_path from "node:path";
+import { createZeropsRuntimeMaterializationScript } from "../../../ultramodern-workspace/workspace-scripts.js";
+import { createZeropsYaml } from "../../../ultramodern-workspace/zerops.js";
+import { allWorkspaceAppsFromToolingConfig } from "../../config.js";
+import { writeTextIfChanged } from "./io.js";
+function updateGeneratedZeropsArtifacts(io, config) {
+    const apps = allWorkspaceAppsFromToolingConfig(config);
+    let changed = writeTextIfChanged(io, node_path.join(io.workspaceRoot, 'zerops.yaml'), `${createZeropsYaml(config.workspace.packageScope, apps)}\n`);
+    changed = writeTextIfChanged(io, node_path.join(io.workspaceRoot, "scripts/materialize-zerops-runtime.mjs"), createZeropsRuntimeMaterializationScript()) || changed;
+    return changed;
+}
+export { updateGeneratedZeropsArtifacts };

package/dist/esm/ultramodern-tooling/commands/migrate-strict-effect/generated-artifacts.js

@@ -0,0 +1,7 @@
+export { updateGeneratedBackendFederationContractFiles } from "./generated-artifacts-backend-federation.js";
+export { updateGeneratedBuildIdentityModules } from "./generated-artifacts-build-identity.js";
+export { updateGeneratedModernConfigs } from "./generated-artifacts-modern-configs.js";
+export { ensureGeneratedOxfmtIgnorePatterns } from "./generated-artifacts-oxfmt.js";
+export { removeGeneratedFileIfExists, removeStaleBackendFederationArtifacts } from "./generated-artifacts-removal.js";
+export { updateGeneratedTypeScriptSurfaces } from "./generated-artifacts-typescript.js";
+export { updateGeneratedZeropsArtifacts } from "./generated-artifacts-zerops.js";

package/dist/esm/ultramodern-tooling/commands/migrate-strict-effect/generated-patches.js

@@ -0,0 +1,15 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+function ensureGeneratedPatchFile(io, relativePatchPath, sourcePatchPath) {
+    const targetPath = node_path.join(io.workspaceRoot, relativePatchPath);
+    const patch = node_fs.readFileSync(sourcePatchPath, 'utf-8');
+    return io.write(targetPath, patch);
+}
+function removeGeneratedPatchFileIfUnchanged(io, relativePatchPath, sourcePatchPath) {
+    const targetPath = node_path.join(io.workspaceRoot, relativePatchPath);
+    if (!node_fs.existsSync(targetPath)) return false;
+    const patch = node_fs.readFileSync(sourcePatchPath, 'utf-8');
+    if (node_fs.readFileSync(targetPath, 'utf-8') !== patch) return false;
+    return io.remove(targetPath);
+}
+export { ensureGeneratedPatchFile, removeGeneratedPatchFileIfUnchanged };

package/dist/esm/ultramodern-tooling/commands/migrate-strict-effect/help.js

@@ -0,0 +1,16 @@
+const migrateStrictEffectHelp = `Usage:
+  modern-js-create ultramodern migrate-strict-effect --version <version> [--dry-run] [--skip-install]
+
+Updates generated UltraModern package-source metadata, Modern package aliases,
+framework-owned toolchain pins, direct Effect API topology metadata, strict
+Effect pnpm overrides/trust policy, framework-owned TypeScript config
+surfaces, and the pnpm lockfile. Source code still has to pass pnpm api:check
+and pnpm contract:check.
+
+When the compact config is absent but legacy UltraModern 3.2 metadata is
+present, the compact config is synthesized from it first. Shell-only
+workspaces skip the backend-federation and Zerops runtime stages. Pass
+--dry-run to print the planned filesystem changes without writing anything
+(implies --skip-install).
+`;
+export { migrateStrictEffectHelp };

package/dist/esm/ultramodern-tooling/commands/migrate-strict-effect/install.js

@@ -0,0 +1,14 @@
+import { spawnSync } from "node:child_process";
+function runPnpmLockfileRefresh(context) {
+    const result = spawnSync('pnpm', [
+        'install',
+        '--lockfile-only',
+        "--ignore-scripts"
+    ], {
+        cwd: context.workspaceRoot,
+        stdio: 'inherit'
+    });
+    if (result.error) throw result.error;
+    return result.status ?? 1;
+}
+export { runPnpmLockfileRefresh };

package/dist/esm/ultramodern-tooling/commands/migrate-strict-effect/io.js

@@ -0,0 +1,285 @@
+import node_fs from "node:fs";
+import node_os from "node:os";
+import node_path from "node:path";
+const stagingExcludedEntries = new Set([
+    '.git',
+    '.nx',
+    '.output',
+    'coverage',
+    'dist',
+    'node_modules'
+]);
+function lstatIfExists(filePath) {
+    try {
+        return node_fs.lstatSync(filePath);
+    } catch (error) {
+        if ('ENOENT' === error.code) return;
+        throw error;
+    }
+}
+function capturePath(filePath) {
+    const stat = lstatIfExists(filePath);
+    if (!stat) return;
+    const mode = 4095 & stat.mode;
+    if (stat.isFile()) return {
+        content: node_fs.readFileSync(filePath),
+        mode,
+        type: 'file'
+    };
+    if (stat.isDirectory()) {
+        const entries = new Map();
+        for (const entry of node_fs.readdirSync(filePath).sort((left, right)=>left.localeCompare(right))){
+            const snapshot = capturePath(node_path.join(filePath, entry));
+            if (snapshot) entries.set(entry, snapshot);
+        }
+        return {
+            entries,
+            mode,
+            type: 'directory'
+        };
+    }
+    if (stat.isSymbolicLink()) return {
+        mode,
+        target: node_fs.readlinkSync(filePath),
+        type: 'symlink'
+    };
+    throw new Error(`Unsupported migration transaction path: ${filePath}`);
+}
+function removePath(filePath) {
+    node_fs.rmSync(filePath, {
+        force: true,
+        recursive: true
+    });
+}
+function chmodSymlinkIfSupported(filePath, mode) {
+    if ('function' == typeof node_fs.lchmodSync) node_fs.lchmodSync(filePath, mode);
+}
+function restorePath(filePath, snapshot) {
+    if (!snapshot) return void removePath(filePath);
+    const current = lstatIfExists(filePath);
+    if ('file' === snapshot.type) {
+        if (!current?.isFile() || current.isSymbolicLink()) {
+            removePath(filePath);
+            node_fs.mkdirSync(node_path.dirname(filePath), {
+                recursive: true
+            });
+        }
+        node_fs.writeFileSync(filePath, snapshot.content);
+        node_fs.chmodSync(filePath, snapshot.mode);
+        return;
+    }
+    if ('symlink' === snapshot.type) {
+        if (!current?.isSymbolicLink() || node_fs.readlinkSync(filePath) !== snapshot.target) {
+            removePath(filePath);
+            node_fs.mkdirSync(node_path.dirname(filePath), {
+                recursive: true
+            });
+            node_fs.symlinkSync(snapshot.target, filePath);
+        }
+        chmodSymlinkIfSupported(filePath, snapshot.mode);
+        return;
+    }
+    if (!current?.isDirectory() || current.isSymbolicLink()) {
+        removePath(filePath);
+        node_fs.mkdirSync(filePath, {
+            recursive: true
+        });
+    }
+    for (const entry of node_fs.readdirSync(filePath))if (!snapshot.entries.has(entry)) removePath(node_path.join(filePath, entry));
+    for (const [entry, childSnapshot] of snapshot.entries)restorePath(node_path.join(filePath, entry), childSnapshot);
+    node_fs.chmodSync(filePath, snapshot.mode);
+}
+function copyWorkspaceEntry(sourcePath, destinationPath) {
+    const stat = node_fs.lstatSync(sourcePath);
+    if (stat.isDirectory()) {
+        node_fs.mkdirSync(destinationPath, {
+            mode: 4095 & stat.mode
+        });
+        for (const entry of node_fs.readdirSync(sourcePath))if (!stagingExcludedEntries.has(entry)) copyWorkspaceEntry(node_path.join(sourcePath, entry), node_path.join(destinationPath, entry));
+        node_fs.chmodSync(destinationPath, 4095 & stat.mode);
+        return;
+    }
+    if (stat.isFile()) {
+        node_fs.copyFileSync(sourcePath, destinationPath, node_fs.constants.COPYFILE_FICLONE);
+        node_fs.chmodSync(destinationPath, 4095 & stat.mode);
+        return;
+    }
+    if (stat.isSymbolicLink()) {
+        node_fs.symlinkSync(node_fs.readlinkSync(sourcePath), destinationPath);
+        chmodSymlinkIfSupported(destinationPath, 4095 & stat.mode);
+        return;
+    }
+    throw new Error(`Unsupported migration staging path: ${sourcePath}`);
+}
+function isPromiseLike(value) {
+    return ('object' == typeof value || 'function' == typeof value) && null !== value && 'function' == typeof value.then;
+}
+function createMigrationIo(workspaceRoot, dryRun) {
+    const absoluteWorkspaceRoot = node_path.resolve(workspaceRoot);
+    const plan = [];
+    let activeTransaction;
+    const rel = (p)=>(node_path.relative(absoluteWorkspaceRoot, p) || node_path.basename(p)).split(node_path.sep).join('/');
+    const assertWorkspacePath = (filePath)=>{
+        const absolutePath = node_path.resolve(filePath);
+        const relativePath = node_path.relative(absoluteWorkspaceRoot, absolutePath);
+        if ('' === relativePath || '..' === relativePath || relativePath.startsWith(`..${node_path.sep}`) || node_path.isAbsolute(relativePath)) throw new Error(`Refusing to mutate outside workspace: ${filePath}`);
+        return absolutePath;
+    };
+    const captureForRollback = (filePath)=>{
+        if (!activeTransaction || activeTransaction.snapshots.has(filePath)) return;
+        activeTransaction.snapshots.set(filePath, capturePath(filePath));
+        activeTransaction.order.push(filePath);
+    };
+    const captureMissingParents = (filePath)=>{
+        const missing = [];
+        let current = node_path.dirname(filePath);
+        while(current !== absoluteWorkspaceRoot && !lstatIfExists(current)){
+            missing.push(current);
+            current = node_path.dirname(current);
+        }
+        for (const missingDirectory of missing.reverse())captureForRollback(missingDirectory);
+    };
+    const rollback = (transaction)=>{
+        for (const filePath of [
+            ...transaction.order
+        ].reverse())restorePath(filePath, transaction.snapshots.get(filePath));
+    };
+    const finishWithError = (transaction, error)=>{
+        try {
+            rollback(transaction);
+        } catch (rollbackError) {
+            throw new Error(`Migration failed (${String(error)}) and rollback failed (${String(rollbackError)}).`);
+        } finally{
+            activeTransaction = void 0;
+        }
+        throw error;
+    };
+    const io = {
+        workspaceRoot: absoluteWorkspaceRoot,
+        dryRun,
+        plan,
+        write (filePath, content) {
+            const absolutePath = assertWorkspacePath(filePath);
+            if (node_fs.existsSync(absolutePath) && node_fs.readFileSync(absolutePath, 'utf-8') === content) return false;
+            if (dryRun) {
+                plan.push(`[dry-run] would write ${rel(absolutePath)}`);
+                return true;
+            }
+            captureMissingParents(absolutePath);
+            captureForRollback(absolutePath);
+            const current = lstatIfExists(absolutePath);
+            if (current?.isSymbolicLink()) {
+                const linkedPath = node_path.resolve(node_path.dirname(absolutePath), node_fs.readlinkSync(absolutePath));
+                let targetPath = linkedPath;
+                try {
+                    targetPath = node_fs.realpathSync.native(absolutePath);
+                } catch  {}
+                const absoluteTargetPath = assertWorkspacePath(targetPath);
+                captureMissingParents(absoluteTargetPath);
+                captureForRollback(absoluteTargetPath);
+            }
+            node_fs.mkdirSync(node_path.dirname(absolutePath), {
+                recursive: true
+            });
+            node_fs.writeFileSync(absolutePath, content, 'utf-8');
+            return true;
+        },
+        remove (filePath) {
+            const absolutePath = assertWorkspacePath(filePath);
+            if (!lstatIfExists(absolutePath)) return false;
+            if (dryRun) {
+                plan.push(`[dry-run] would delete ${rel(absolutePath)}`);
+                return true;
+            }
+            captureForRollback(absolutePath);
+            node_fs.rmSync(absolutePath);
+            return true;
+        },
+        log (message) {
+            if (dryRun) plan.push(`[dry-run] ${message}`);
+            else process.stdout.write(`[ultramodern] ${message}\n`);
+        },
+        transaction (operation, options) {
+            if (activeTransaction) throw new Error('Nested migration transactions are not supported.');
+            const transaction = {
+                order: [],
+                snapshots: new Map()
+            };
+            activeTransaction = transaction;
+            const finish = (result)=>{
+                try {
+                    if (options?.commitWhen && !options.commitWhen(result)) rollback(transaction);
+                    return result;
+                } finally{
+                    activeTransaction = void 0;
+                }
+            };
+            try {
+                const result = operation();
+                if (isPromiseLike(result)) return Promise.resolve(result).then((value)=>finish(value), (error)=>finishWithError(transaction, error));
+                return finish(result);
+            } catch (error) {
+                return finishWithError(transaction, error);
+            }
+        },
+        withStagedWorkspace (operation) {
+            const temporaryRoot = node_fs.mkdtempSync(node_path.join(node_os.tmpdir(), 'ultramodern-migration-'));
+            const stagedWorkspaceRoot = node_path.join(temporaryRoot, 'workspace');
+            try {
+                copyWorkspaceEntry(absoluteWorkspaceRoot, stagedWorkspaceRoot);
+                const result = operation(stagedWorkspaceRoot);
+                if (isPromiseLike(result)) return Promise.resolve(result).finally(()=>{
+                    node_fs.rmSync(temporaryRoot, {
+                        force: true,
+                        recursive: true
+                    });
+                });
+                node_fs.rmSync(temporaryRoot, {
+                    force: true,
+                    recursive: true
+                });
+                return result;
+            } catch (error) {
+                node_fs.rmSync(temporaryRoot, {
+                    force: true,
+                    recursive: true
+                });
+                throw error;
+            }
+        }
+    };
+    return io;
+}
+function readJsonFile(filePath) {
+    return JSON.parse(node_fs.readFileSync(filePath, 'utf-8'));
+}
+function writeJsonFile(io, filePath, value) {
+    return io.write(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function writeJsonIfChanged(io, filePath, value) {
+    return io.write(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function writeTextIfChanged(io, filePath, value) {
+    return io.write(filePath, value);
+}
+function listWorkspacePackageFiles(workspaceRoot) {
+    const packageFiles = [
+        'package.json'
+    ];
+    for (const directory of [
+        'apps',
+        'verticals',
+        'packages'
+    ]){
+        const absoluteDirectory = node_path.join(workspaceRoot, directory);
+        if (node_fs.existsSync(absoluteDirectory)) for (const entry of node_fs.readdirSync(absoluteDirectory, {
+            withFileTypes: true
+        })){
+            if (!entry.isDirectory()) continue;
+            const packageFile = `${directory}/${entry.name}/package.json`;
+            if (node_fs.existsSync(node_path.join(workspaceRoot, packageFile))) packageFiles.push(packageFile);
+        }
+    }
+    return packageFiles;
+}
+export { createMigrationIo, listWorkspacePackageFiles, readJsonFile, writeJsonFile, writeJsonIfChanged, writeTextIfChanged };