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

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

@@ -1,460 +1,14 @@
 import "node:module";
-import { spawnSync } from "node:child_process";
-import node_fs from "node:fs";
-import node_os from "node:os";
 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 { 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";
-const commands_dirname = node_path.dirname(fileURLToPath(import.meta.url));
-const createPackageRoot = resolveCreatePackageRoot(commands_dirname);
-function printHelp() {
-    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
-`);
-}
-function spawnNodeScript(relativeScriptPath, args, context, options = {}) {
-    const scriptPath = node_path.join(createPackageRoot, relativeScriptPath);
-    const result = spawnSync(process.execPath, [
-        scriptPath,
-        ...args
-    ], {
-        cwd: options.cwd ?? context.workspaceRoot,
-        env: {
-            ...process.env,
-            ULTRAMODERN_WORKSPACE_ROOT: context.workspaceRoot
-        },
-        stdio: 'inherit'
-    });
-    if (result.error) throw result.error;
-    return result.status ?? 1;
-}
-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');
-    try {
-        node_fs.writeFileSync(tempFile, source, 'utf-8');
-        const result = spawnSync(process.execPath, [
-            tempFile
-        ], {
-            cwd: context.workspaceRoot,
-            stdio: 'inherit'
-        });
-        if (result.error) throw result.error;
-        return result.status ?? 1;
-    } finally{
-        node_fs.rmSync(tempDir, {
-            force: true,
-            recursive: true
-        });
-    }
-}
-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);
-}
-function runMfTypes(args, context) {
-    if (args.includes('--help') || args.includes('-h')) {
-        process.stdout.write(`Usage:
-  modern-js-create ultramodern mf-types [app-dir...]
-
-Checks real Module Federation config files and DTS archives for exposed apps.
-`);
-        return 0;
-    }
-    validateModuleFederationTypes({
-        workspaceRoot: context.workspaceRoot,
-        appDirs: args.length > 0 ? args : void 0
-    });
-    return 0;
-}
-const modernPackageNames = new Set([
-    ...ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES,
-    ...ULTRAMODERN_WORKSPACE_MODERN_PACKAGES
-]);
-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 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);
-}
-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 = node_path.join(directory, entry.name, 'package.json');
-            if (node_fs.existsSync(node_path.join(workspaceRoot, packageFile))) packageFiles.push(packageFile);
-        }
-    }
-    return packageFiles;
-}
-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;
-}
-function normalizeStrictEffectApiMetadata(value) {
-    const api = value.api;
-    if (!api || 'object' != typeof api || Array.isArray(api)) return false;
-    let changed = false;
-    const oldEffect = api.effect;
-    if (oldEffect && 'object' == typeof oldEffect && !Array.isArray(oldEffect)) {
-        if (void 0 === api.stem && 'string' == typeof oldEffect.stem) {
-            api.stem = oldEffect.stem;
-            changed = true;
-        }
-        if (void 0 === api.prefix && 'string' == typeof oldEffect.prefix) {
-            api.prefix = oldEffect.prefix;
-            changed = true;
-        }
-        if (void 0 === api.consumedBy && Array.isArray(oldEffect.consumedBy)) {
-            api.consumedBy = oldEffect.consumedBy;
-            changed = true;
-        }
-        delete api.effect;
-        changed = true;
-    }
-    if (void 0 !== api.runtime && 'effect' !== api.runtime) {
-        api.runtime = 'effect';
-        changed = true;
-    }
-    if (api.bff && 'object' == typeof api.bff && !Array.isArray(api.bff)) {
-        if (true !== api.bff.strictEffectApproach) {
-            api.bff.strictEffectApproach = true;
-            changed = true;
-        }
-    }
-    if ('string' == typeof value.path) {
-        const directServerEntry = `${value.path}/api/index.ts`;
-        if ('string' == typeof api.serverEntry && /\/api\/effect\/index\.[cm]?[jt]sx?$/u.test(api.serverEntry)) {
-            api.serverEntry = directServerEntry;
-            changed = true;
-        }
-        if (api.contract && 'object' == typeof api.contract && !Array.isArray(api.contract)) {
-            if ('./shared/effect/api' === api.contract.export) {
-                api.contract.export = './api';
-                changed = true;
-            }
-            if ('string' == typeof api.contract.path && /\/shared\/effect\/api\.[cm]?[jt]sx?$/u.test(api.contract.path)) {
-                api.contract.path = `${value.path}/shared/api.ts`;
-                changed = true;
-            }
-        }
-        if (api.client && 'object' == typeof api.client && !Array.isArray(api.client)) {
-            if ('./effect/client' === api.client.export) {
-                api.client.export = './api/client';
-                changed = true;
-            }
-            if ('string' == typeof api.client.path && /\/src\/effect\/[^/]+-client\.[cm]?ts$/u.test(api.client.path)) {
-                const basename = node_path.basename(api.client.path);
-                api.client.path = `${value.path}/src/api/${basename}`;
-                changed = true;
-            }
-        }
-        if (void 0 === api.serverEntry && 'effect' === api.runtime) {
-            api.serverEntry = directServerEntry;
-            changed = true;
-        }
-    }
-    return changed;
-}
-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 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
-    };
-    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 updateGeneratedPnpmWorkspacePolicy(workspaceRoot) {
-    const workspaceFile = node_path.join(workspaceRoot, 'pnpm-workspace.yaml');
-    if (!node_fs.existsSync(workspaceFile)) return false;
-    let source = node_fs.readFileSync(workspaceFile, 'utf-8');
-    let changed = false;
-    const replacements = [
-        [
-            /^ {4}'@effect\/vitest>effect': .+$/mu,
-            `    '@effect/vitest>effect': '${EFFECT_VERSION}'`
-        ],
-        [
-            /^ {2}'@effect\/vitest': .+$/mu,
-            `  '@effect/vitest': ${EFFECT_VITEST_VERSION}`
-        ],
-        [
-            /^ {2}effect: .+$/mu,
-            `  effect: ${EFFECT_VERSION}`
-        ],
-        [
-            /^ {2}- '@effect\/opentelemetry@[^']+'$/mu,
-            `  - '@effect/opentelemetry@${EFFECT_VERSION}'`
-        ]
-    ];
-    for (const [pattern, replacement] of replacements){
-        const result = replaceYamlLine(source, pattern, replacement);
-        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');
-    return changed;
-}
-function updateUltramodernConfig(workspaceRoot, packageSource) {
-    const configPath = node_path.join(workspaceRoot, '.modernjs/ultramodern.json');
-    const config = readJsonFile(configPath);
-    config.packageSource = {
-        strategy: packageSource.strategy,
-        modernPackageVersion: packageSource.modernPackageVersion,
-        ...packageSource.registry ? {
-            registry: packageSource.registry
-        } : {},
-        ...packageSource.aliasScope ? {
-            aliasScope: packageSource.aliasScope
-        } : {},
-        ...packageSource.aliasPackageNamePrefix ? {
-            aliasPackageNamePrefix: packageSource.aliasPackageNamePrefix
-        } : {}
-    };
-    for (const app of config.topology?.apps ?? [])if (app && 'object' == typeof app && !Array.isArray(app)) normalizeStrictEffectApiMetadata(app);
-    writeJsonFile(configPath, config);
-}
-function updateReferenceTopology(workspaceRoot) {
-    const topologyPath = node_path.join(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);
-    return changed;
-}
-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
-        } : {}
-    };
-}
-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;
-}
-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]
-
-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.
-`);
-        return 0;
-    }
-    const current = readUltramodernConfig(context.workspaceRoot);
-    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);
-        const packageJson = readJsonFile(packageFile);
-        if ('package.json' === relativePackageFile) {
-            packageJson.modernjs ??= {};
-            packageJson.modernjs.packageSource = {
-                strategy: packageSource.strategy,
-                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')) {
-        const status = runPnpmLockfileRefresh(context);
-        if (0 !== status) return status;
-    }
-    process.stdout.write(`UltraModern strict Effect metadata migrated to ${packageSource.modernPackageVersion}. Run pnpm api:check && pnpm contract:check next.\n`);
-    return 0;
-}
-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>');
-}
+import { GENERATED_TOOLING_COMMANDS } from "../ultramodern-workspace/tooling-command-catalog.js";
+import { runCloudflareOutputVerify } from "./commands/cloudflare-output-verify.js";
+import { printHelp, runTemplateBackedToolingCommand } from "./commands/context.js";
+import { runMfTypes } from "./commands/mf-types.js";
+import { runMigrateStrictEffect } from "./commands/migrate-strict-effect.js";
+import { runRoutesGenerate } from "./commands/routes-generate.js";
+import { runSkills } from "./commands/skills.js";
+import { runSyncDeliveryUnit } from "./commands/sync-delivery-unit.js";
+import { runValidate } from "./commands/validate.js";
 async function runUltramodernToolingCli(args, workspaceRoot = process.env.ULTRAMODERN_WORKSPACE_ROOT ?? process.cwd()) {
     try {
         const [command, ...rest] = args;
@@ -468,25 +22,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) {

package/dist/esm-node/ultramodern-tooling/config/constants.js

@@ -0,0 +1,5 @@
+import "node:module";
+const LEGACY_GENERATED_CONTRACT_PATH = '.modernjs/ultramodern-generated-contract.json';
+const LEGACY_PACKAGE_SOURCE_METADATA_PATH = '.modernjs/ultramodern-package-source.json';
+const LEGACY_DEVELOPMENT_OVERLAY_PATH = 'topology/local-overlays/development.json';
+export { LEGACY_DEVELOPMENT_OVERLAY_PATH, LEGACY_GENERATED_CONTRACT_PATH, LEGACY_PACKAGE_SOURCE_METADATA_PATH };

package/dist/esm-node/ultramodern-tooling/config/index.js

@@ -0,0 +1,8 @@
+import "node:module";
+export * from "./constants.js";
+export * from "./json.js";
+export * from "./load.js";
+export * from "./metadata.js";
+export * from "./normalize.js";
+export * from "./synthesize.js";
+export * from "./types.js";

package/dist/esm-node/ultramodern-tooling/config/json.js

@@ -0,0 +1,11 @@
+import "node:module";
+import node_fs from "node:fs";
+function readJsonObject(filePath) {
+    const value = JSON.parse(node_fs.readFileSync(filePath, 'utf-8'));
+    if (null === value || 'object' != typeof value || Array.isArray(value)) throw new Error(`UltraModern config must contain a JSON object: ${filePath}`);
+    return value;
+}
+function readOptionalJsonObject(filePath) {
+    return node_fs.existsSync(filePath) ? readJsonObject(filePath) : {};
+}
+export { readJsonObject, readOptionalJsonObject };

package/dist/esm-node/ultramodern-tooling/config/load.js

@@ -0,0 +1,14 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { ULTRAMODERN_CONFIG_PATH } from "../../ultramodern-workspace/descriptors.js";
+import { LEGACY_GENERATED_CONTRACT_PATH } from "./constants.js";
+import { readJsonObject } from "./json.js";
+import { normalizeCompactConfig } from "./normalize.js";
+function readUltramodernConfig(workspaceRoot = process.cwd()) {
+    const compactPath = node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH);
+    if (node_fs.existsSync(compactPath)) return normalizeCompactConfig(workspaceRoot, compactPath, readJsonObject(compactPath));
+    if (node_fs.existsSync(node_path.join(workspaceRoot, LEGACY_GENERATED_CONTRACT_PATH))) throw new Error(`Missing ${ULTRAMODERN_CONFIG_PATH}. Legacy UltraModern metadata detected — run \`modern-js-create ultramodern migrate-strict-effect\` to synthesize it.`);
+    throw new Error(`Missing UltraModern config. Expected ${ULTRAMODERN_CONFIG_PATH}. Run \`modern-js-create ultramodern migrate-strict-effect\` if you have legacy UltraModern metadata to migrate.`);
+}
+export { readUltramodernConfig };

package/dist/esm-node/ultramodern-tooling/config/metadata.js

@@ -0,0 +1,38 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { LEGACY_DEVELOPMENT_OVERLAY_PATH, LEGACY_PACKAGE_SOURCE_METADATA_PATH } from "./constants.js";
+import { readJsonObject, readOptionalJsonObject } from "./json.js";
+function packageScopeFromRoot(workspaceRoot) {
+    const rootPackage = readOptionalJsonObject(node_path.join(workspaceRoot, 'package.json'));
+    return 'string' == typeof rootPackage.name && rootPackage.name.length > 0 ? rootPackage.name : node_path.basename(workspaceRoot);
+}
+function packageSourceFromMetadata(workspaceRoot) {
+    const metadataPath = node_path.join(workspaceRoot, LEGACY_PACKAGE_SOURCE_METADATA_PATH);
+    if (!node_fs.existsSync(metadataPath)) return;
+    const metadata = readJsonObject(metadataPath);
+    const aliases = metadata.modernPackages?.aliases ?? {};
+    const firstAliasEntry = Object.entries(aliases).find((entry)=>'string' == typeof entry[1]);
+    const firstPackage = firstAliasEntry?.[0];
+    const firstAlias = firstAliasEntry?.[1];
+    const aliasScope = firstAlias?.match(/^@([^/]+)\//u)?.[1];
+    const unscopedName = firstPackage?.split('/').at(-1) ?? '';
+    const aliasUnscopedName = firstAlias?.split('/').at(-1) ?? '';
+    const aliasPackageNamePrefix = aliasUnscopedName && unscopedName && aliasUnscopedName.endsWith(unscopedName) ? aliasUnscopedName.slice(0, -unscopedName.length) : void 0;
+    return {
+        strategy: 'install' === metadata.strategy ? 'install' : 'workspace',
+        modernPackageVersion: 'string' == typeof metadata.modernPackages?.specifier ? metadata.modernPackages.specifier : 'workspace:*',
+        registry: 'string' == typeof metadata.modernPackages?.registry ? metadata.modernPackages.registry : void 0,
+        aliasScope,
+        aliasPackageNamePrefix
+    };
+}
+function readOverlayPorts(workspaceRoot) {
+    const overlayPath = node_path.join(workspaceRoot, LEGACY_DEVELOPMENT_OVERLAY_PATH);
+    if (!node_fs.existsSync(overlayPath)) return {};
+    const overlay = readJsonObject(overlayPath);
+    const ports = overlay.ports;
+    if (null === ports || 'object' != typeof ports || Array.isArray(ports)) return {};
+    return Object.fromEntries(Object.entries(ports).filter((entry)=>'number' == typeof entry[1]));
+}
+export { packageScopeFromRoot, packageSourceFromMetadata, readOverlayPorts };