@bleedingdev/modern-js-create 3.5.0-ultramodern.3 → 3.5.0-ultramodern.30

package/dist/esm/ultramodern-tooling/commands.js

@@ -5,26 +5,31 @@ import node_path from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveCreatePackageRoot } from "../create-package-root.js";
 import { BLEEDINGDEV_PACKAGE_NAME_PREFIX, BLEEDINGDEV_PACKAGE_SCOPE, ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES, ULTRAMODERN_WORKSPACE_MODERN_PACKAGES, WORKSPACE_PACKAGE_VERSION, modernPackageSpecifier } from "../ultramodern-package-source.js";
+import { createAppEnvDts } from "../ultramodern-workspace/app-files.js";
+import { createBackendFederationContractFile } from "../ultramodern-workspace/backend-federation.js";
+import { runSyncDeliveryUnit } from "../ultramodern-workspace/delivery-unit-sync.js";
 import { validateModuleFederationTypes } from "../ultramodern-workspace/mf-validation.js";
-import { EFFECT_TSGO_VERSION, EFFECT_VERSION, EFFECT_VITEST_VERSION, OXFMT_VERSION, OXLINT_VERSION, TYPESCRIPT_NATIVE_PREVIEW_VERSION, WRANGLER_VERSION, ZEPHYR_AGENT_VERSION, ZEPHYR_RSPACK_PLUGIN_VERSION } from "../ultramodern-workspace/versions.js";
-import { createWorkspaceValidationScript } from "../ultramodern-workspace/workspace-scripts.js";
-import { readUltramodernConfig, workspaceAppsFromToolingConfig } from "./config.js";
+import { createAppModernConfig, createUltramodernBuildModule, createUltramodernBuildReexportModule } from "../ultramodern-workspace/module-federation.js";
+import { createAppMfTypesTsConfig, createAppTsConfig, createSharedPackageTsConfig, createTsConfigBase } from "../ultramodern-workspace/package-json.js";
+import { GENERATED_TOOLING_COMMANDS, generatedToolingCommandList, generatedToolingCommands } from "../ultramodern-workspace/tooling-command-catalog.js";
+import { DRIZZLE_ORM_VERSION, EFFECT_TSGO_VERSION, EFFECT_VERSION, EFFECT_VITEST_VERSION, MODULE_FEDERATION_VERSION, OXFMT_VERSION, OXLINT_VERSION, TYPESCRIPT_NATIVE_PREVIEW_VERSION, WRANGLER_VERSION, ZEPHYR_AGENT_VERSION, ZEPHYR_RSPACK_PLUGIN_VERSION } from "../ultramodern-workspace/versions.js";
+import { createWorkspaceAppPackageScripts, createWorkspaceRootPackageScripts } from "../ultramodern-workspace/workspace-script-plan.js";
+import { createWorkspaceValidationScript, createZeropsRuntimeMaterializationScript, migratedWorkspaceScriptArtifacts, migratedWorkspaceScriptBasenames } from "../ultramodern-workspace/workspace-scripts.js";
+import { createZeropsYaml } from "../ultramodern-workspace/zerops.js";
+import { normalizeCompactUltramodernConfig, readUltramodernConfig, synthesizeCompactUltramodernConfig, workspaceAppsFromToolingConfig } from "./config.js";
 const commands_dirname = node_path.dirname(fileURLToPath(import.meta.url));
 const createPackageRoot = resolveCreatePackageRoot(commands_dirname);
 function printHelp() {
+    const commands = [
+        ...generatedToolingCommandList().map((command)=>`  ${command}`),
+        '  skills install',
+        '  skills check'
+    ].join('\n');
     process.stdout.write(`Usage:
   modern-js-create ultramodern <command> [args]
 
 Commands:
-  validate
-  typecheck
-  mf-types
-  migrate-strict-effect
-  public-surface
-  cloudflare-proof
-  performance-readiness
-  skills install
-  skills check
+${commands}
 `);
 }
 function spawnNodeScript(relativeScriptPath, args, context, options = {}) {
@@ -43,6 +48,13 @@ function spawnNodeScript(relativeScriptPath, args, context, options = {}) {
     if (result.error) throw result.error;
     return result.status ?? 1;
 }
+function runTemplateBackedToolingCommand(command, args, context) {
+    const toolingCommand = generatedToolingCommands.find((candidate)=>candidate.command === command);
+    if (!toolingCommand?.templatePath) return;
+    return spawnNodeScript(toolingCommand.templatePath, args, context, {
+        cwd: 'invocation' === toolingCommand.cwd ? context.invocationCwd : context.workspaceRoot
+    });
+}
 function runRenderedModule(source, context) {
     const tempDir = node_fs.mkdtempSync(node_path.join(node_os.tmpdir(), 'ultramodern-tool-'));
     const tempFile = node_path.join(tempDir, 'command.mjs');
@@ -89,11 +101,45 @@ const modernPackageNames = new Set([
     ...ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES,
     ...ULTRAMODERN_WORKSPACE_MODERN_PACKAGES
 ]);
+function createMigrationIo(workspaceRoot, dryRun) {
+    const plan = [];
+    const rel = (p)=>(node_path.relative(workspaceRoot, p) || node_path.basename(p)).split(node_path.sep).join('/');
+    return {
+        workspaceRoot,
+        dryRun,
+        plan,
+        write (filePath, content) {
+            if (node_fs.existsSync(filePath) && node_fs.readFileSync(filePath, 'utf-8') === content) return false;
+            if (dryRun) {
+                plan.push(`[dry-run] would write ${rel(filePath)}`);
+                return true;
+            }
+            node_fs.mkdirSync(node_path.dirname(filePath), {
+                recursive: true
+            });
+            node_fs.writeFileSync(filePath, content, 'utf-8');
+            return true;
+        },
+        remove (filePath) {
+            if (!node_fs.existsSync(filePath)) return false;
+            if (dryRun) {
+                plan.push(`[dry-run] would delete ${rel(filePath)}`);
+                return true;
+            }
+            node_fs.rmSync(filePath);
+            return true;
+        },
+        log (message) {
+            if (dryRun) plan.push(`[dry-run] ${message}`);
+            else process.stdout.write(`[ultramodern] ${message}\n`);
+        }
+    };
+}
 function readJsonFile(filePath) {
     return JSON.parse(node_fs.readFileSync(filePath, 'utf-8'));
 }
-function writeJsonFile(filePath, value) {
-    node_fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+function writeJsonFile(io, filePath, value) {
+    return io.write(filePath, `${JSON.stringify(value, null, 2)}\n`);
 }
 function readOption(args, name) {
     const prefix = `${name}=`;
@@ -126,7 +172,7 @@ function listWorkspacePackageFiles(workspaceRoot) {
             withFileTypes: true
         })){
             if (!entry.isDirectory()) continue;
-            const packageFile = node_path.join(directory, entry.name, 'package.json');
+            const packageFile = `${directory}/${entry.name}/package.json`;
             if (node_fs.existsSync(node_path.join(workspaceRoot, packageFile))) packageFiles.push(packageFile);
         }
     }
@@ -182,6 +228,18 @@ const generatedToolingDependencyPins = new Map([
         ZEPHYR_RSPACK_PLUGIN_VERSION
     ]
 ]);
+const strictEffectPackageVersionPolicyExclusions = [
+    `effect@${EFFECT_VERSION}`,
+    `@effect/opentelemetry@${EFFECT_VERSION}`
+];
+const moduleFederationModernJsPatchPath = `patches/@module-federation__modern-js-v3@${MODULE_FEDERATION_VERSION}.patch`;
+const moduleFederationModernJsPatchSourcePath = node_path.join(createPackageRoot, 'template-workspace', moduleFederationModernJsPatchPath);
+const moduleFederationBridgeReactPatchPath = `patches/@module-federation__bridge-react@${MODULE_FEDERATION_VERSION}.patch`;
+const moduleFederationBridgeReactPatchSourcePath = node_path.join(createPackageRoot, 'template-workspace', moduleFederationBridgeReactPatchPath);
+const effectDeclarationPatchPath = 'patches/effect-schema-error-type-id.patch';
+const effectDeclarationPatchSourcePath = node_path.join(createPackageRoot, 'template-workspace', effectDeclarationPatchPath);
+const drizzleOrmDeclarationPatchPath = 'patches/drizzle-orm-ts7-strict-declarations.patch';
+const drizzleOrmDeclarationPatchSourcePath = node_path.join(createPackageRoot, 'template-workspace', drizzleOrmDeclarationPatchPath);
 function updateGeneratedToolingDependencies(packageJson) {
     let changed = false;
     for (const section of [
@@ -200,10 +258,117 @@ function updateGeneratedToolingDependencies(packageJson) {
     }
     return changed;
 }
+const cloudflareModernDeployCommand = 'ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern deploy';
+const cloudflareModernDeploySkipBuildCommand = `${cloudflareModernDeployCommand} --skip-build`;
+const cloudflareWranglerDeployCommand = 'wrangler deploy --config .output/wrangler.json';
+const cloudflareWranglerDeployInvalidSkipBuildCommand = `${cloudflareWranglerDeployCommand} --skip-build`;
+function removeStaleBackendFederationCommandSegments(command) {
+    return command.replace(/\s+&&\s+node\s+\S*scripts\/generate-node-backend-federation\.m[ct]s(?:\s+--app\s+\S+)?(?:\s+--target\s+\S+)?(?=\s+&&|$)/gu, '');
+}
+const SHELL_ONLY_OMITTED_ROOT_SCRIPTS = [
+    'node:backend-federation:generate',
+    'node:proof',
+    'zerops:materialize'
+];
+const splitScriptSegments = (command)=>command.split('&&').map((segment)=>segment.trim()).filter((segment)=>segment.length > 0);
+const scriptSegmentTarget = (segment)=>segment.replace(/^pnpm\s+/u, '').split(/\s+/u)[0] ?? segment;
+const FRAMEWORK_CHECK_TARGETS = new Set([
+    'format:check',
+    'lint',
+    'typecheck',
+    'skills:check',
+    'i18n:boundaries',
+    'api:check',
+    'contract:check',
+    'node:backend-federation:generate',
+    'node:proof',
+    'performance:readiness',
+    'bridge:check'
+]);
+function mergeAggregateCheckScript(consumer, framework) {
+    const frameworkSegments = splitScriptSegments(framework);
+    const consumerExtras = splitScriptSegments(consumer).filter((segment)=>!FRAMEWORK_CHECK_TARGETS.has(scriptSegmentTarget(segment)));
+    return [
+        ...consumerExtras,
+        ...frameworkSegments
+    ].join(' && ');
+}
+function rewriteMigratedScriptReferences(scripts) {
+    let changed = false;
+    const pattern = new RegExp(`(scripts/(?:${migratedWorkspaceScriptBasenames.join('|')}))\\.mjs`, 'gu');
+    for (const [name, value] of Object.entries(scripts)){
+        if ('string' != typeof value) continue;
+        const next = value.replace(pattern, '$1.mts');
+        if (next !== value) {
+            scripts[name] = next;
+            changed = true;
+        }
+    }
+    return changed;
+}
+function updateGeneratedPackageScripts(packageJson, options = {}) {
+    const scripts = packageJson.scripts;
+    if (!scripts || 'object' != typeof scripts || Array.isArray(scripts)) return false;
+    let changed = false;
+    const apps = options.apps ?? [];
+    const shellOnly = options.shellOnly ?? false;
+    const app = apps.find((candidate)=>`${candidate.directory}/package.json` === options.relativePackageFile);
+    const isRootPackage = 'package.json' === options.relativePackageFile;
+    const expectedScripts = isRootPackage ? createWorkspaceRootPackageScripts(apps.filter((candidate)=>'shell' !== candidate.kind)) : app ? createWorkspaceAppPackageScripts(app) : void 0;
+    if (expectedScripts) for (const [name, value] of Object.entries(expectedScripts)){
+        if (isRootPackage && shellOnly && SHELL_ONLY_OMITTED_ROOT_SCRIPTS.includes(name)) {
+            if (name in scripts) {
+                delete scripts[name];
+                changed = true;
+            }
+            continue;
+        }
+        const nextValue = 'check' === name && 'string' == typeof scripts[name] ? mergeAggregateCheckScript(scripts[name], value) : value;
+        if (scripts[name] !== nextValue) {
+            scripts[name] = nextValue;
+            changed = true;
+        }
+    }
+    if (rewriteMigratedScriptReferences(scripts)) changed = true;
+    const build = scripts.build;
+    if ('string' == typeof build) {
+        const nextBuild = removeStaleBackendFederationCommandSegments(build);
+        if (nextBuild !== build) {
+            scripts.build = nextBuild;
+            changed = true;
+        }
+    }
+    const cloudflareBuild = scripts['cloudflare:build'];
+    if ('string' == typeof cloudflareBuild) {
+        let nextCloudflareBuild = removeStaleBackendFederationCommandSegments(cloudflareBuild);
+        if (nextCloudflareBuild.includes(cloudflareModernDeployCommand) && !nextCloudflareBuild.includes(cloudflareModernDeploySkipBuildCommand)) nextCloudflareBuild = nextCloudflareBuild.replace(cloudflareModernDeployCommand, cloudflareModernDeploySkipBuildCommand);
+        nextCloudflareBuild = nextCloudflareBuild.replace(/ && node \S*scripts\/generate-public-surface-assets\.m[ct]s --app [^&]+ --target dist(?= && ULTRAMODERN_ZEPHYR=false MODERNJS_DEPLOY=cloudflare modern deploy --skip-build)/u, '');
+        nextCloudflareBuild = nextCloudflareBuild.replace(/ && node \S*scripts\/verify-cloudflare-output\.m[ct]s(?: --app [^&]+)?/u, '');
+        if (nextCloudflareBuild !== cloudflareBuild) {
+            scripts['cloudflare:build'] = nextCloudflareBuild;
+            changed = true;
+        }
+    }
+    const cloudflareDeploy = scripts['cloudflare:deploy'];
+    if ('string' == typeof cloudflareDeploy && cloudflareDeploy.includes(cloudflareWranglerDeployInvalidSkipBuildCommand)) {
+        scripts['cloudflare:deploy'] = cloudflareDeploy.replace(cloudflareWranglerDeployInvalidSkipBuildCommand, cloudflareWranglerDeployCommand);
+        changed = true;
+    }
+    return changed;
+}
 function normalizeStrictEffectApiMetadata(value) {
-    const api = value.api;
-    if (!api || 'object' != typeof api || Array.isArray(api)) return false;
     let changed = false;
+    const backendFederation = value.backendFederation;
+    if (backendFederation && 'object' == typeof backendFederation && !Array.isArray(backendFederation) && Object.hasOwn(backendFederation, 'entry')) {
+        delete backendFederation.entry;
+        changed = true;
+    }
+    const api = value.api;
+    if (!api || 'object' != typeof api || Array.isArray(api)) return changed;
+    if (void 0 !== api.backendFederation) {
+        delete api.backendFederation;
+        changed = true;
+    }
     const oldEffect = api.effect;
     if (oldEffect && 'object' == typeof oldEffect && !Array.isArray(oldEffect)) {
         if (void 0 === api.stem && 'string' == typeof oldEffect.stem) {
@@ -265,6 +430,38 @@ function normalizeStrictEffectApiMetadata(value) {
     }
     return changed;
 }
+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 workspaceAppsFromToolingConfig(config))changed = removeGeneratedFileIfExists(io, node_path.join(app.directory, 'api/backend-federation.ts')) || changed;
+    return changed;
+}
+function updateGeneratedZeropsArtifacts(io, config) {
+    const apps = workspaceAppsFromToolingConfig(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;
+}
+function updateGeneratedBuildIdentityModules(io, config) {
+    let changed = false;
+    for (const app of workspaceAppsFromToolingConfig(config)){
+        changed = writeTextIfChanged(io, node_path.join(io.workspaceRoot, app.directory, 'src/ultramodern-build.ts'), createUltramodernBuildReexportModule()) || changed;
+        changed = writeTextIfChanged(io, node_path.join(io.workspaceRoot, app.directory, 'shared/ultramodern-build.ts'), createUltramodernBuildModule(config.workspace.packageScope, app)) || changed;
+    }
+    return changed;
+}
+function updateGeneratedBackendFederationContractFiles(io, config) {
+    let changed = false;
+    for (const app of workspaceAppsFromToolingConfig(config))if (app.api) changed = writeTextIfChanged(io, node_path.join(io.workspaceRoot, app.directory, 'api/backend-federation.ts'), createBackendFederationContractFile(app)) || changed;
+    return changed;
+}
 function replaceYamlLine(source, pattern, replacement) {
     const updated = source.replace(pattern, replacement);
     return {
@@ -275,16 +472,17 @@ function replaceYamlLine(source, pattern, replacement) {
 function ensureYamlListItem(source, key, item) {
     const itemLine = `  - '${item}'`;
     const headerPattern = new RegExp(`^${key}:\\n(?:(?:  - .+\\n)*)`, 'mu');
-    const existingItemPattern = new RegExp(`^  - '${item.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&')}'$`, 'mu');
-    if (existingItemPattern.test(source)) return {
-        source,
-        changed: false
-    };
     const header = source.match(headerPattern);
-    if (header) return {
-        source: source.replace(headerPattern, `${header[0]}${itemLine}\n`),
-        changed: true
-    };
+    if (header) {
+        if (header[0].split('\n').includes(itemLine)) return {
+            source,
+            changed: false
+        };
+        return {
+            source: source.replace(headerPattern, `${header[0]}${itemLine}\n`),
+            changed: true
+        };
+    }
     const block = `${key}:\n${itemLine}\n`;
     const afterTrustPolicyIgnore = source.replace(/^(trustPolicyIgnoreAfter: .+\n)/mu, `$1${block}`);
     if (afterTrustPolicyIgnore !== source) return {
@@ -296,43 +494,203 @@ function ensureYamlListItem(source, key, item) {
         changed: true
     };
 }
-function updateGeneratedPnpmWorkspacePolicy(workspaceRoot) {
-    const workspaceFile = node_path.join(workspaceRoot, 'pnpm-workspace.yaml');
+function yamlEntryPattern(entryKey, scalar = false) {
+    const bareKey = entryKey.replace(/^['"]|['"]$/gu, '');
+    if (scalar) {
+        const esc = bareKey.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+        return new RegExp(`^ {2}(?:'${esc}'|"${esc}"|${esc}): .+$`, 'gmu');
+    }
+    const packageName = bareKey.includes('@') ? bareKey.slice(0, bareKey.lastIndexOf('@')) : bareKey;
+    const esc = packageName.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+    return new RegExp(`^ {2}(?:'${esc}@[^']+'|"${esc}@[^"]+"|${esc}@[^:'"\\s]+): .+$`, 'gmu');
+}
+function upsertYamlEntry(source, key, entryLine, pattern) {
+    const linePattern = new RegExp(pattern.source, 'u');
+    const lines = source.split('\n');
+    let seen = false;
+    let changed = false;
+    const out = [];
+    for (const line of lines)if (linePattern.test(line)) {
+        if (seen) {
+            changed = true;
+            continue;
+        }
+        seen = true;
+        if (line !== entryLine) changed = true;
+        out.push(entryLine);
+    } else out.push(line);
+    if (seen) return {
+        source: out.join('\n'),
+        changed
+    };
+    const headerPattern = new RegExp(`^${key}:\\n(?:(?:  .+\\n)*)`, 'mu');
+    const header = source.match(headerPattern);
+    if (header) {
+        if (header[0].split('\n').includes(entryLine)) return {
+            source,
+            changed: false
+        };
+        return {
+            source: source.replace(headerPattern, `${header[0]}${entryLine}\n`),
+            changed: true
+        };
+    }
+    return {
+        source: `${source.trimEnd()}\n${key}:\n${entryLine}\n`,
+        changed: true
+    };
+}
+function ensureYamlMapEntry(source, key, entryKey, value) {
+    return upsertYamlEntry(source, key, `  '${entryKey}': ${value}`, yamlEntryPattern(entryKey));
+}
+function ensureYamlScalarMapEntry(source, key, entryKey, value) {
+    return upsertYamlEntry(source, key, `  ${entryKey}: ${value}`, yamlEntryPattern(entryKey, true));
+}
+function removeYamlMapEntry(source, entryKey) {
+    const linePattern = new RegExp(yamlEntryPattern(entryKey).source, 'u');
+    const lines = source.split('\n');
+    let changed = false;
+    const out = [];
+    for (const line of lines){
+        if (linePattern.test(line)) {
+            changed = true;
+            continue;
+        }
+        out.push(line);
+    }
+    return changed ? {
+        source: out.join('\n'),
+        changed
+    } : {
+        source,
+        changed
+    };
+}
+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);
+}
+function workspaceUsesDependency(workspaceRoot, packageName) {
+    const packageJsonPaths = [
+        node_path.join(workspaceRoot, 'package.json')
+    ];
+    for (const workspaceDir of [
+        'apps',
+        'verticals',
+        'packages'
+    ]){
+        const absoluteWorkspaceDir = node_path.join(workspaceRoot, workspaceDir);
+        if (node_fs.existsSync(absoluteWorkspaceDir)) for (const entry of node_fs.readdirSync(absoluteWorkspaceDir, {
+            withFileTypes: true
+        })){
+            if (!entry.isDirectory()) continue;
+            const packageJsonPath = node_path.join(absoluteWorkspaceDir, entry.name, 'package.json');
+            if (node_fs.existsSync(packageJsonPath)) packageJsonPaths.push(packageJsonPath);
+        }
+    }
+    for (const packageJsonPath of packageJsonPaths){
+        const packageJson = JSON.parse(node_fs.readFileSync(packageJsonPath, 'utf-8'));
+        for (const field of [
+            'dependencies',
+            'devDependencies',
+            'peerDependencies',
+            'optionalDependencies'
+        ]){
+            const dependencies = packageJson[field];
+            if (dependencies && 'object' == typeof dependencies) {
+                if (Object.prototype.hasOwnProperty.call(dependencies, packageName)) return true;
+                for (const specifier of Object.values(dependencies))if ('string' == typeof specifier && specifier.startsWith(`npm:${packageName}@`)) return true;
+            }
+        }
+    }
+    return false;
+}
+function ensureGeneratedDeclarationPatches(io, options) {
+    let changed = false;
+    changed = ensureGeneratedPatchFile(io, moduleFederationModernJsPatchPath, moduleFederationModernJsPatchSourcePath) || changed;
+    changed = ensureGeneratedPatchFile(io, moduleFederationBridgeReactPatchPath, moduleFederationBridgeReactPatchSourcePath) || changed;
+    changed = ensureGeneratedPatchFile(io, effectDeclarationPatchPath, effectDeclarationPatchSourcePath) || changed;
+    changed = options.includeDrizzleOrmPatch ? ensureGeneratedPatchFile(io, drizzleOrmDeclarationPatchPath, drizzleOrmDeclarationPatchSourcePath) || changed : removeGeneratedPatchFileIfUnchanged(io, drizzleOrmDeclarationPatchPath, drizzleOrmDeclarationPatchSourcePath) || changed;
+    return changed;
+}
+function updateGeneratedPnpmWorkspacePolicy(io) {
+    const workspaceFile = node_path.join(io.workspaceRoot, 'pnpm-workspace.yaml');
     if (!node_fs.existsSync(workspaceFile)) return false;
     let source = node_fs.readFileSync(workspaceFile, 'utf-8');
     let changed = false;
+    const usesDrizzleOrm = workspaceUsesDependency(io.workspaceRoot, 'drizzle-orm');
     const replacements = [
         [
             /^ {4}'@effect\/vitest>effect': .+$/mu,
             `    '@effect/vitest>effect': '${EFFECT_VERSION}'`
-        ],
+        ]
+    ];
+    for (const [pattern, replacement] of replacements){
+        const result = replaceYamlLine(source, pattern, replacement);
+        source = result.source;
+        changed = result.changed || changed;
+    }
+    for (const [entryKey, version] of [
         [
-            /^ {2}'@effect\/vitest': .+$/mu,
-            `  '@effect/vitest': ${EFFECT_VITEST_VERSION}`
+            "'@effect/opentelemetry'",
+            EFFECT_VERSION
         ],
         [
-            /^ {2}effect: .+$/mu,
-            `  effect: ${EFFECT_VERSION}`
+            "'@effect/vitest'",
+            EFFECT_VITEST_VERSION
         ],
         [
-            /^ {2}- '@effect\/opentelemetry@[^']+'$/mu,
-            `  - '@effect/opentelemetry@${EFFECT_VERSION}'`
+            'effect',
+            EFFECT_VERSION
         ]
-    ];
-    for (const [pattern, replacement] of replacements){
-        const result = replaceYamlLine(source, pattern, replacement);
+    ]){
+        const result = ensureYamlScalarMapEntry(source, 'overrides', entryKey, version);
         source = result.source;
         changed = result.changed || changed;
     }
-    const trustPolicyExclude = ensureYamlListItem(source, 'trustPolicyExclude', `@effect/opentelemetry@${EFFECT_VERSION}`);
-    source = trustPolicyExclude.source;
-    changed = trustPolicyExclude.changed || changed;
-    if (changed) node_fs.writeFileSync(workspaceFile, source, 'utf-8');
+    const parcelWatcherBuildPolicy = ensureYamlScalarMapEntry(source, 'allowBuilds', "'@parcel/watcher'", 'true');
+    source = parcelWatcherBuildPolicy.source;
+    changed = parcelWatcherBuildPolicy.changed || changed;
+    for (const item of strictEffectPackageVersionPolicyExclusions){
+        const packageName = item.slice(0, item.lastIndexOf('@'));
+        const escapedPackageName = packageName.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+        const currentVersion = replaceYamlLine(source, new RegExp(`^ {2}- '${escapedPackageName}@[^']+'$`, 'gmu'), `  - '${item}'`);
+        source = currentVersion.source;
+        changed = currentVersion.changed || changed;
+        for (const policyKey of [
+            'minimumReleaseAgeExclude',
+            'trustPolicyExclude'
+        ]){
+            const policyExclude = ensureYamlListItem(source, policyKey, item);
+            source = policyExclude.source;
+            changed = policyExclude.changed || changed;
+        }
+    }
+    const effectPatch = ensureYamlMapEntry(source, 'patchedDependencies', `effect@${EFFECT_VERSION}`, effectDeclarationPatchPath);
+    source = effectPatch.source;
+    changed = effectPatch.changed || changed;
+    const moduleFederationModernJsPatch = ensureYamlMapEntry(source, 'patchedDependencies', `@module-federation/modern-js-v3@${MODULE_FEDERATION_VERSION}`, moduleFederationModernJsPatchPath);
+    source = moduleFederationModernJsPatch.source;
+    changed = moduleFederationModernJsPatch.changed || changed;
+    const moduleFederationBridgeReactPatch = ensureYamlMapEntry(source, 'patchedDependencies', `@module-federation/bridge-react@${MODULE_FEDERATION_VERSION}`, moduleFederationBridgeReactPatchPath);
+    source = moduleFederationBridgeReactPatch.source;
+    changed = moduleFederationBridgeReactPatch.changed || changed;
+    const drizzleOrmPatch = usesDrizzleOrm ? ensureYamlMapEntry(source, 'patchedDependencies', `drizzle-orm@${DRIZZLE_ORM_VERSION}`, drizzleOrmDeclarationPatchPath) : removeYamlMapEntry(source, `drizzle-orm@${DRIZZLE_ORM_VERSION}`);
+    source = drizzleOrmPatch.source;
+    changed = drizzleOrmPatch.changed || changed;
+    if (changed) io.write(workspaceFile, source);
     return changed;
 }
-function updateUltramodernConfig(workspaceRoot, packageSource) {
-    const configPath = node_path.join(workspaceRoot, '.modernjs/ultramodern.json');
-    const config = readJsonFile(configPath);
+function updateUltramodernConfig(io, config, packageSource) {
+    const configPath = node_path.join(io.workspaceRoot, '.modernjs/ultramodern.json');
     config.packageSource = {
         strategy: packageSource.strategy,
         modernPackageVersion: packageSource.modernPackageVersion,
@@ -346,16 +704,147 @@ function updateUltramodernConfig(workspaceRoot, packageSource) {
             aliasPackageNamePrefix: packageSource.aliasPackageNamePrefix
         } : {}
     };
+    if (config.generator && 'object' == typeof config.generator && !Array.isArray(config.generator) && 'string' == typeof config.generator.version) config.generator.version = packageSource.modernPackageVersion;
     for (const app of config.topology?.apps ?? [])if (app && 'object' == typeof app && !Array.isArray(app)) normalizeStrictEffectApiMetadata(app);
-    writeJsonFile(configPath, config);
+    writeJsonFile(io, configPath, config);
+}
+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 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/'
+    ])if (!lines.includes(rule)) {
+        lines.push(rule);
+        changed = true;
+    }
+    if (!changed) return false;
+    return io.write(gitignorePath, `${lines.join('\n')}\n`);
+}
+function updateGeneratedTypeScriptSurfaces(io, config) {
+    let changed = false;
+    const apps = workspaceAppsFromToolingConfig(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)) || changed;
+    }
+    return changed;
+}
+function updateGeneratedModernConfigs(io, config) {
+    let changed = false;
+    const apps = workspaceAppsFromToolingConfig(config);
+    const remotes = apps.filter((app)=>'shell' !== app.kind);
+    for (const app of apps)changed = writeTextIfChanged(io, node_path.join(io.workspaceRoot, app.directory, 'modern.config.ts'), createAppModernConfig(config.workspace.packageScope, app, remotes)) || changed;
+    return changed;
+}
+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);
 }
-function updateReferenceTopology(workspaceRoot) {
-    const topologyPath = node_path.join(workspaceRoot, 'topology/reference-topology.json');
+function updateReferenceTopology(io) {
+    const topologyPath = node_path.join(io.workspaceRoot, 'topology/reference-topology.json');
     if (!node_fs.existsSync(topologyPath)) return false;
     const topology = readJsonFile(topologyPath);
     let changed = false;
     for (const vertical of topology.verticals ?? [])if (vertical && 'object' == typeof vertical && !Array.isArray(vertical)) changed = normalizeStrictEffectApiMetadata(vertical) || changed;
-    if (changed) writeJsonFile(topologyPath, topology);
+    if (changed) writeJsonFile(io, topologyPath, topology);
     return changed;
 }
 function createMigrationPackageSource(args, current) {
@@ -408,21 +897,69 @@ function runPnpmLockfileRefresh(context) {
 function runMigrateStrictEffect(args, context) {
     if (args.includes('--help') || args.includes('-h')) {
         process.stdout.write(`Usage:
-  modern-js-create ultramodern migrate-strict-effect --version <version> [--skip-install]
+  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, and the pnpm lockfile. Source code still
-has to pass pnpm api:check and pnpm contract:check.
+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).
 `);
         return 0;
     }
-    const current = readUltramodernConfig(context.workspaceRoot);
+    const dryRun = hasFlag(args, '--dry-run');
+    const skipInstall = dryRun || hasFlag(args, '--skip-install');
+    const io = createMigrationIo(context.workspaceRoot, dryRun);
+    const compactPath = node_path.join(io.workspaceRoot, '.modernjs/ultramodern.json');
+    let raw;
+    if (node_fs.existsSync(compactPath)) raw = readJsonFile(compactPath);
+    else {
+        const synthesized = synthesizeCompactUltramodernConfig(io.workspaceRoot);
+        if (!synthesized) throw new Error("Missing .modernjs/ultramodern.json and no legacy UltraModern metadata (.modernjs/ultramodern-generated-contract.json) was found to synthesize it from.");
+        raw = synthesized.compact;
+        io.write(compactPath, `${JSON.stringify(raw, null, 2)}\n`);
+        io.log(`Synthesized .modernjs/ultramodern.json from legacy metadata: ${synthesized.sources.join(', ')}.`);
+        if (synthesized.missing.length > 0) io.log(`Legacy metadata not found (using defaults): ${synthesized.missing.join(', ')}.`);
+    }
+    const current = normalizeCompactUltramodernConfig(io.workspaceRoot, raw);
     const packageSource = createMigrationPackageSource(args, current);
-    updateUltramodernConfig(context.workspaceRoot, packageSource);
-    updateReferenceTopology(context.workspaceRoot);
-    for (const relativePackageFile of listWorkspacePackageFiles(context.workspaceRoot)){
-        const packageFile = node_path.join(context.workspaceRoot, relativePackageFile);
+    updateUltramodernConfig(io, raw, packageSource);
+    updateReferenceTopology(io);
+    const migrated = normalizeCompactUltramodernConfig(io.workspaceRoot, raw);
+    const migratedApps = workspaceAppsFromToolingConfig(migrated);
+    const shellOnly = !migrated.topology.apps.some((app)=>app.api);
+    if (shellOnly) {
+        io.log('Shell-only workspace: skipping backend-federation and Zerops runtime stages.');
+        for (const relativePath of [
+            "scripts/generate-node-backend-federation.mts",
+            "scripts/generate-node-backend-federation.mjs",
+            "scripts/proof-node-backend-federation.mts",
+            "scripts/proof-node-backend-federation.mjs",
+            "scripts/materialize-zerops-runtime.mjs",
+            'zerops.yaml'
+        ])removeGeneratedFileIfExists(io, relativePath);
+    } else {
+        removeStaleBackendFederationArtifacts(io, migrated);
+        updateGeneratedZeropsArtifacts(io, migrated);
+        updateGeneratedBackendFederationContractFiles(io, migrated);
+    }
+    for (const artifact of migratedWorkspaceScriptArtifacts({
+        shellOnly
+    })){
+        if (artifact.legacyPath) io.remove(node_path.join(io.workspaceRoot, artifact.legacyPath));
+        io.write(node_path.join(io.workspaceRoot, artifact.relativePath), artifact.content);
+    }
+    updateGeneratedBuildIdentityModules(io, migrated);
+    updateGeneratedTypeScriptSurfaces(io, migrated);
+    updateGeneratedModernConfigs(io, migrated);
+    for (const relativePackageFile of listWorkspacePackageFiles(io.workspaceRoot)){
+        const packageFile = node_path.join(io.workspaceRoot, relativePackageFile);
         const packageJson = readJsonFile(packageFile);
         if ('package.json' === relativePackageFile) {
             packageJson.modernjs ??= {};
@@ -431,17 +968,29 @@ has to pass pnpm api:check and pnpm contract:check.
                 config: './.modernjs/ultramodern.json'
             };
         }
-        const modernDependenciesChanged = updateModernDependencies(packageJson, packageSource);
-        const toolingDependenciesChanged = updateGeneratedToolingDependencies(packageJson);
-        const changed = modernDependenciesChanged || toolingDependenciesChanged;
-        if (changed) writeJsonFile(packageFile, packageJson);
-        else if ('package.json' === relativePackageFile) writeJsonFile(packageFile, packageJson);
-    }
-    updateGeneratedPnpmWorkspacePolicy(context.workspaceRoot);
-    if (!hasFlag(args, '--skip-install')) {
+        updateModernDependencies(packageJson, packageSource);
+        updateGeneratedToolingDependencies(packageJson);
+        updateGeneratedPackageScripts(packageJson, {
+            relativePackageFile,
+            apps: migratedApps,
+            shellOnly
+        });
+        writeJsonFile(io, packageFile, packageJson);
+    }
+    updateGeneratedPnpmWorkspacePolicy(io);
+    ensureGeneratedDeclarationPatches(io, {
+        includeDrizzleOrmPatch: workspaceUsesDependency(io.workspaceRoot, 'drizzle-orm')
+    });
+    ensureGeneratedOxfmtIgnorePatterns(io);
+    if (!skipInstall) {
         const status = runPnpmLockfileRefresh(context);
         if (0 !== status) return status;
     }
+    if (dryRun) {
+        for (const line of io.plan)process.stdout.write(`${line}\n`);
+        process.stdout.write(`[dry-run] migrate-strict-effect would migrate UltraModern strict Effect metadata to ${packageSource.modernPackageVersion}.\n`);
+        return 0;
+    }
     process.stdout.write(`UltraModern strict Effect metadata migrated to ${packageSource.modernPackageVersion}. Run pnpm api:check && pnpm contract:check next.\n`);
     return 0;
 }
@@ -454,6 +1003,154 @@ function runSkills(args, context) {
     ], context);
     throw new Error('Usage: modern-js-create ultramodern skills <install|check>');
 }
+const resolveCloudflareOutputVerifyTargets = (args, context)=>{
+    const outputDirectory = readOption(args, '--output');
+    const appId = readOption(args, '--app');
+    if (outputDirectory && appId) throw new Error('Use either --app or --output, not both.');
+    const targets = outputDirectory ? [
+        {
+            label: outputDirectory,
+            outputDirectory: node_path.resolve(context.invocationCwd, outputDirectory)
+        }
+    ] : workspaceAppsFromToolingConfig(readUltramodernConfig(context.workspaceRoot)).filter((app)=>!appId || app.id === appId).map((app)=>({
+            label: app.id,
+            outputDirectory: node_path.join(context.workspaceRoot, app.directory, '.output')
+        }));
+    if (0 === targets.length) throw new Error(`No generated UltraModern app matched ${appId}.`);
+    return targets;
+};
+const renderCloudflareOutputVerifyModule = ({ workspaceRoot, targets, scanRoots, importWorker })=>`
+import { createRequire } from 'node:module';
+import path from 'node:path';
+
+const workspaceRoot = ${JSON.stringify(workspaceRoot)};
+const targets = ${JSON.stringify(targets, null, 2)};
+const scanRoots = ${JSON.stringify(scanRoots)};
+const verifierRequire = createRequire(path.join(workspaceRoot, 'package.json'));
+const {
+  verifyCloudflareOutput,
+  verifyCloudflareOutputMutationPolicy,
+} = verifierRequire('@modern-js/app-tools/cloudflare-output-verifier');
+
+let failed = false;
+for (const target of targets) {
+  const result = await verifyCloudflareOutput({
+    outputDirectory: target.outputDirectory,
+    importWorker: ${JSON.stringify(importWorker)},
+  });
+  if (result.ok) {
+    console.log(\`[ultramodern] Cloudflare output verified: \${target.label}\`);
+  } else {
+    failed = true;
+    console.error(\`[ultramodern] Cloudflare output failed: \${target.label}\`);
+    for (const issue of result.issues) {
+      console.error(\`- \${issue.code}: \${issue.message}\${issue.path ? \` (\${issue.path})\` : ''}\`);
+    }
+  }
+}
+
+if (scanRoots.length > 0) {
+  const policyResult = await verifyCloudflareOutputMutationPolicy({ scanRoots });
+  if (!policyResult.ok) {
+    failed = true;
+    console.error('[ultramodern] generated-output mutation policy failed');
+    for (const issue of policyResult.issues) {
+      console.error(\`- \${issue.code}: \${issue.message}\${issue.path ? \` (\${issue.path})\` : ''}\`);
+    }
+  }
+}
+
+process.exit(failed ? 1 : 0);
+`;
+function runCloudflareOutputVerify(args, context) {
+    if (args.includes('--help') || args.includes('-h')) {
+        process.stdout.write(`Usage:
+  modern-js-create ultramodern cloudflare-output-verify [--app <id> | --output <dir>] [--no-import-worker] [--no-source-scan]
+
+Verifies generated Cloudflare output against the UltraModern worker contract.
+Without --app or --output, every generated workspace app is verified.
+`);
+        return 0;
+    }
+    const source = renderCloudflareOutputVerifyModule({
+        workspaceRoot: context.workspaceRoot,
+        targets: resolveCloudflareOutputVerifyTargets(args, context),
+        scanRoots: hasFlag(args, '--no-source-scan') ? [] : [
+            context.workspaceRoot
+        ],
+        importWorker: !hasFlag(args, '--no-import-worker')
+    });
+    return runRenderedModule(source, context);
+}
+const resolveRoutesGenerateTargets = (args, context)=>{
+    const appId = readOption(args, '--app');
+    const targets = workspaceAppsFromToolingConfig(readUltramodernConfig(context.workspaceRoot)).filter((app)=>!appId || app.id === appId).map((app)=>({
+            label: app.id,
+            appDirectory: node_path.join(context.workspaceRoot, app.directory)
+        }));
+    if (0 === targets.length) throw new Error(`No generated UltraModern app matched ${appId ?? '<any>'}.`);
+    return targets;
+};
+const renderRoutesGenerateModule = ({ workspaceRoot, targets })=>`
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const workspaceRoot = ${JSON.stringify(workspaceRoot)};
+const targets = ${JSON.stringify(targets, null, 2)};
+const appRequire = createRequire(path.join(workspaceRoot, 'package.json'));
+const pluginUrl = pathToFileURL(
+  appRequire.resolve('@modern-js/plugin-tanstack'),
+).href;
+const { generateTanstackRouteArtifacts } = await import(pluginUrl);
+
+let failed = false;
+// Sequential — the app-tools cli singleton is not re-entrant.
+for (const target of targets) {
+  try {
+    await generateTanstackRouteArtifacts({ appDirectory: target.appDirectory });
+    console.log(\`[ultramodern] TanStack route artifacts generated: \${target.label}\`);
+  } catch (error) {
+    failed = true;
+    console.error(\`[ultramodern] TanStack route generation failed: \${target.label}\`);
+    // Print the full underlying failure, including the cause chain. The
+    // route-generate crash is often an opaque node error thrown deep inside
+    // app-tools/plugin (e.g. a path TypeError), so surfacing only
+    // \`error.message\` swallows the stack that points at the real culprit.
+    let current = error;
+    let depth = 0;
+    while (current) {
+      const label = depth === 0 ? '-' : '  caused by:';
+      const detail =
+        current instanceof Error
+          ? current.stack ?? \`\${current.name}: \${current.message}\`
+          : String(current);
+      console.error(\`\${label} \${detail}\`);
+      current = current instanceof Error ? current.cause : undefined;
+      depth += 1;
+    }
+  }
+}
+
+process.exit(failed ? 1 : 0);
+`;
+function runRoutesGenerate(args, context) {
+    if (args.includes('--help') || args.includes('-h')) {
+        process.stdout.write(`Usage:
+  modern-js-create ultramodern routes-generate [--app <id>]
+
+Regenerates TanStack route artifacts (router.gen.ts, register.gen.d.ts) for
+generated UltraModern apps without running dev or build. Without --app, every
+generated workspace app is regenerated.
+`);
+        return 0;
+    }
+    const source = renderRoutesGenerateModule({
+        workspaceRoot: context.workspaceRoot,
+        targets: resolveRoutesGenerateTargets(args, context)
+    });
+    return runRenderedModule(source, context);
+}
 async function runUltramodernToolingCli(args, workspaceRoot = process.env.ULTRAMODERN_WORKSPACE_ROOT ?? process.cwd()) {
     try {
         const [command, ...rest] = args;
@@ -467,25 +1164,25 @@ async function runUltramodernToolingCli(args, workspaceRoot = process.env.ULTRAM
             case '-h':
                 printHelp();
                 return 0;
-            case 'validate':
+            case GENERATED_TOOLING_COMMANDS.validate.command:
                 return runValidate(context);
-            case 'typecheck':
-                return spawnNodeScript("templates/workspace-scripts/ultramodern-typecheck.mjs", rest, context, {
-                    cwd: context.invocationCwd
-                });
-            case 'mf-types':
+            case GENERATED_TOOLING_COMMANDS.mfTypes.command:
                 return runMfTypes(rest, context);
-            case 'migrate-strict-effect':
+            case GENERATED_TOOLING_COMMANDS.migrateStrictEffect.command:
                 return runMigrateStrictEffect(rest, context);
-            case 'public-surface':
-                return spawnNodeScript("templates/workspace-scripts/generate-public-surface-assets.mjs", rest, context);
-            case 'cloudflare-proof':
-                return spawnNodeScript("templates/workspace-scripts/proof-cloudflare-version.mjs", rest, context);
-            case 'performance-readiness':
-                return spawnNodeScript("templates/workspace-scripts/ultramodern-performance-readiness.mjs", rest, context);
+            case GENERATED_TOOLING_COMMANDS.cloudflareOutputVerify.command:
+                return runCloudflareOutputVerify(rest, context);
+            case GENERATED_TOOLING_COMMANDS.routesGenerate.command:
+                return runRoutesGenerate(rest, context);
+            case 'sync-delivery-unit':
+                return runSyncDeliveryUnit(rest, context);
             case 'skills':
                 return runSkills(rest, context);
             default:
+                {
+                    const templateBackedStatus = runTemplateBackedToolingCommand(command ?? '', rest, context);
+                    if (void 0 !== templateBackedStatus) return templateBackedStatus;
+                }
                 throw new Error(`Unknown UltraModern command: ${command}`);
         }
     } catch (error) {