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

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

@@ -0,0 +1,175 @@
+import { ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES, ULTRAMODERN_WORKSPACE_MODERN_PACKAGES, modernPackageSpecifier } from "../../../ultramodern-package-source.js";
+import { EFFECT_TSGO_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 { migratedWorkspaceScriptBasenames } from "../../../ultramodern-workspace/workspace-scripts.js";
+const modernPackageNames = new Set([
+    ...ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES,
+    ...ULTRAMODERN_WORKSPACE_MODERN_PACKAGES
+]);
+function updateModernDependencies(packageJson, packageSource) {
+    let changed = false;
+    for (const section of [
+        'dependencies',
+        'devDependencies',
+        'peerDependencies',
+        'optionalDependencies'
+    ]){
+        const dependencies = packageJson[section];
+        if (!(!dependencies || 'object' != typeof dependencies || Array.isArray(dependencies))) for (const packageName of Object.keys(dependencies)){
+            if (!modernPackageNames.has(packageName)) continue;
+            const nextSpecifier = modernPackageSpecifier(packageName, packageSource);
+            if (dependencies[packageName] !== nextSpecifier) {
+                dependencies[packageName] = nextSpecifier;
+                changed = true;
+            }
+        }
+    }
+    return changed;
+}
+const generatedToolingDependencyPins = new Map([
+    [
+        '@effect/tsgo',
+        EFFECT_TSGO_VERSION
+    ],
+    [
+        "@typescript/native-preview",
+        TYPESCRIPT_NATIVE_PREVIEW_VERSION
+    ],
+    [
+        'oxfmt',
+        OXFMT_VERSION
+    ],
+    [
+        'oxlint',
+        OXLINT_VERSION
+    ],
+    [
+        'wrangler',
+        WRANGLER_VERSION
+    ],
+    [
+        'zephyr-agent',
+        ZEPHYR_AGENT_VERSION
+    ],
+    [
+        'zephyr-rspack-plugin',
+        ZEPHYR_RSPACK_PLUGIN_VERSION
+    ]
+]);
+function updateGeneratedToolingDependencies(packageJson) {
+    let changed = false;
+    for (const section of [
+        'dependencies',
+        'devDependencies',
+        'peerDependencies',
+        'optionalDependencies'
+    ]){
+        const dependencies = packageJson[section];
+        if (!(!dependencies || 'object' != typeof dependencies || Array.isArray(dependencies))) {
+            for (const [packageName, version] of generatedToolingDependencyPins)if (Object.prototype.hasOwnProperty.call(dependencies, packageName) && dependencies[packageName] !== version) {
+                dependencies[packageName] = version;
+                changed = true;
+            }
+        }
+    }
+    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;
+}
+export { updateGeneratedPackageScripts, updateGeneratedToolingDependencies, updateModernDependencies };

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

@@ -0,0 +1,38 @@
+import { BLEEDINGDEV_PACKAGE_NAME_PREFIX, BLEEDINGDEV_PACKAGE_SCOPE, WORKSPACE_PACKAGE_VERSION } from "../../../ultramodern-package-source.js";
+import { hasFlag, readOption } from "../options.js";
+function createMigrationPackageSource(args, current) {
+    const strategy = hasFlag(args, '--workspace') ? 'workspace' : 'install';
+    const registry = readOption(args, '--registry') ?? readOption(args, '--ultramodern-package-registry');
+    const explicitAliasScope = readOption(args, '--alias-scope') ?? readOption(args, '--ultramodern-package-scope');
+    const aliasScope = explicitAliasScope ?? ('install' === strategy && void 0 === registry ? current.packageSource?.aliasScope ?? BLEEDINGDEV_PACKAGE_SCOPE : current.packageSource?.aliasScope);
+    const aliasPackageNamePrefix = readOption(args, '--alias-package-name-prefix') ?? readOption(args, '--ultramodern-package-name-prefix') ?? current.packageSource?.aliasPackageNamePrefix ?? (aliasScope ? BLEEDINGDEV_PACKAGE_NAME_PREFIX : void 0);
+    if ('workspace' === strategy) return {
+        strategy,
+        modernPackageVersion: WORKSPACE_PACKAGE_VERSION,
+        ...registry ? {
+            registry
+        } : {},
+        ...aliasScope ? {
+            aliasScope
+        } : {},
+        ...aliasPackageNamePrefix ? {
+            aliasPackageNamePrefix
+        } : {}
+    };
+    const version = readOption(args, '--version') ?? readOption(args, '--ultramodern-package-version') ?? current.packageSource?.modernPackageVersion;
+    if (!version || version === WORKSPACE_PACKAGE_VERSION) throw new Error('migrate-strict-effect needs --version <published-ultramodern-version> for install package source.');
+    return {
+        strategy,
+        modernPackageVersion: version,
+        ...registry ? {
+            registry
+        } : {},
+        ...aliasScope ? {
+            aliasScope
+        } : {},
+        ...aliasPackageNamePrefix ? {
+            aliasPackageNamePrefix
+        } : {}
+    };
+}
+export { createMigrationPackageSource };

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

@@ -0,0 +1,76 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { DRIZZLE_ORM_VERSION, EFFECT_VERSION, EFFECT_VITEST_VERSION, MODULE_FEDERATION_VERSION } from "../../../ultramodern-workspace/versions.js";
+import { workspaceUsesDependency } from "./dependency-usage.js";
+import { ensureYamlListItem, ensureYamlMapEntry, ensureYamlScalarMapEntry, removeYamlMapEntry, replaceYamlLine } from "./pnpm-yaml.js";
+import { drizzleOrmDeclarationPatchPath, effectDeclarationPatchPath, moduleFederationBridgeReactPatchPath, moduleFederationModernJsPatchPath, strictEffectPackageVersionPolicyExclusions } from "./policy-constants.js";
+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 [
+        [
+            "'@effect/opentelemetry'",
+            EFFECT_VERSION
+        ],
+        [
+            "'@effect/vitest'",
+            EFFECT_VITEST_VERSION
+        ],
+        [
+            'effect',
+            EFFECT_VERSION
+        ]
+    ]){
+        const result = ensureYamlScalarMapEntry(source, 'overrides', entryKey, version);
+        source = result.source;
+        changed = result.changed || changed;
+    }
+    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;
+}
+export { ensureGeneratedDeclarationPatches } from "./declaration-patches.js";
+export { updateGeneratedPnpmWorkspacePolicy, workspaceUsesDependency };

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

@@ -0,0 +1,105 @@
+function replaceYamlLine(source, pattern, replacement) {
+    const updated = source.replace(pattern, replacement);
+    return {
+        source: updated,
+        changed: updated !== source
+    };
+}
+function ensureYamlListItem(source, key, item) {
+    const itemLine = `  - '${item}'`;
+    const headerPattern = new RegExp(`^${key}:\\n(?:(?:  - .+\\n)*)`, 'mu');
+    const header = source.match(headerPattern);
+    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 {
+        source: afterTrustPolicyIgnore,
+        changed: true
+    };
+    return {
+        source: `${source.trimEnd()}\n${block}`,
+        changed: true
+    };
+}
+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
+    };
+}
+export { ensureYamlListItem, ensureYamlMapEntry, ensureYamlScalarMapEntry, removeYamlMapEntry, replaceYamlLine, upsertYamlEntry, yamlEntryPattern };

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

@@ -0,0 +1,16 @@
+import node_path from "node:path";
+import { EFFECT_VERSION, MODULE_FEDERATION_VERSION } from "../../../ultramodern-workspace/versions.js";
+import { createPackageRoot } from "../context.js";
+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);
+export { drizzleOrmDeclarationPatchPath, drizzleOrmDeclarationPatchSourcePath, effectDeclarationPatchPath, effectDeclarationPatchSourcePath, moduleFederationBridgeReactPatchPath, moduleFederationBridgeReactPatchSourcePath, moduleFederationModernJsPatchPath, moduleFederationModernJsPatchSourcePath, strictEffectPackageVersionPolicyExclusions };

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

@@ -0,0 +1,100 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { migratedWorkspaceScriptArtifacts } from "../../ultramodern-workspace/workspace-scripts.js";
+import { normalizeCompactUltramodernConfig, synthesizeCompactUltramodernConfig, workspaceAppsFromToolingConfig } from "../config.js";
+import { updateReferenceTopology, updateUltramodernConfig } from "./migrate-strict-effect/api-metadata.js";
+import { ensureGeneratedOxfmtIgnorePatterns, removeGeneratedFileIfExists, removeStaleBackendFederationArtifacts, updateGeneratedBackendFederationContractFiles, updateGeneratedBuildIdentityModules, updateGeneratedModernConfigs, updateGeneratedTypeScriptSurfaces, updateGeneratedZeropsArtifacts } from "./migrate-strict-effect/generated-artifacts.js";
+import { migrateStrictEffectHelp } from "./migrate-strict-effect/help.js";
+import { runPnpmLockfileRefresh } from "./migrate-strict-effect/install.js";
+import { createMigrationIo, listWorkspacePackageFiles, readJsonFile, writeJsonFile } from "./migrate-strict-effect/io.js";
+import { updateGeneratedPackageScripts, updateGeneratedToolingDependencies, updateModernDependencies } from "./migrate-strict-effect/package-cohort.js";
+import { createMigrationPackageSource } from "./migrate-strict-effect/package-source.js";
+import { ensureGeneratedDeclarationPatches, updateGeneratedPnpmWorkspacePolicy, workspaceUsesDependency } from "./migrate-strict-effect/pnpm-policy.js";
+import { hasFlag } from "./options.js";
+function runMigrateStrictEffect(args, context) {
+    if (args.includes('--help') || args.includes('-h')) {
+        process.stdout.write(migrateStrictEffectHelp);
+        return 0;
+    }
+    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(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 ??= {};
+            packageJson.modernjs.packageSource = {
+                strategy: packageSource.strategy,
+                config: './.modernjs/ultramodern.json'
+            };
+        }
+        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;
+}
+export { runMigrateStrictEffect };

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

@@ -0,0 +1,18 @@
+function readOption(args, name) {
+    const prefix = `${name}=`;
+    const inline = args.find((arg)=>arg.startsWith(prefix));
+    if (inline) {
+        const value = inline.slice(prefix.length);
+        if (!value) throw new Error(`${name} needs a value.`);
+        return value;
+    }
+    const index = args.indexOf(name);
+    if (-1 === index) return;
+    const value = args[index + 1];
+    if (!value || value.startsWith('--')) throw new Error(`${name} needs a value.`);
+    return value;
+}
+function hasFlag(args, name) {
+    return args.includes(name);
+}
+export { hasFlag, readOption };

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

@@ -0,0 +1,74 @@
+import node_path from "node:path";
+import { readUltramodernConfig, workspaceAppsFromToolingConfig } from "../config.js";
+import { runRenderedModule } from "./context.js";
+import { readOption } from "./options.js";
+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);
+}
+export { runRoutesGenerate };

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

@@ -0,0 +1,11 @@
+import { spawnNodeScript } from "./context.js";
+function runSkills(args, context) {
+    const [subcommand, ...rest] = args;
+    if ('install' === subcommand) return spawnNodeScript("template-workspace/scripts/bootstrap-agent-skills.mjs", rest, context);
+    if ('check' === subcommand) return spawnNodeScript("template-workspace/scripts/bootstrap-agent-skills.mjs", [
+        '--check',
+        ...rest
+    ], context);
+    throw new Error('Usage: modern-js-create ultramodern skills <install|check>');
+}
+export { runSkills };

package/dist/esm/ultramodern-tooling/commands/sync-delivery-unit.js

@@ -0,0 +1 @@
+export { runSyncDeliveryUnit } from "../../ultramodern-workspace/delivery-unit-sync.js";

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

@@ -0,0 +1,11 @@
+import { createWorkspaceValidationScript } from "../../ultramodern-workspace/workspace-scripts.js";
+import { readUltramodernConfig, workspaceAppsFromToolingConfig } from "../config.js";
+import { runRenderedModule } from "./context.js";
+function runValidate(context) {
+    const config = readUltramodernConfig(context.workspaceRoot);
+    const apps = workspaceAppsFromToolingConfig(config);
+    const remotes = apps.filter((app)=>'shell' !== app.kind);
+    const source = createWorkspaceValidationScript(config.workspace.packageScope, config.features.tailwind, remotes);
+    return runRenderedModule(source, context);
+}
+export { runValidate };