@bleedingdev/modern-js-ultramodern-create 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

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

@@ -1,75 +1,46 @@
 import "node:module";
 import node_path from "node:path";
 import { readUltramodernConfig, workspaceAppsFromToolingConfig } from "../config.js";
-import { runRenderedModule } from "./context.js";
+import { spawnNodeScript } 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)=>({
+    const targets = workspaceAppsFromToolingConfig(readUltramodernConfig(context.workspaceRoot), 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:
-  ultramodern-create ultramodern routes-generate [--app <id>]
+  ultramodern-create ultramodern routes-generate [--app <id>] [--manifest-only]
+
+Regenerates src/routes/ultramodern-route-metadata.ts from the app's
+route.meta.ts files and the 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.
 
-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.
+--manifest-only writes only the route metadata manifest. It never loads the
+app config, so app dev and build scripts run it before \`modern dev\` and
+\`modern build\`, which regenerate the router artifacts themselves.
 `);
         return 0;
     }
-    const source = renderRoutesGenerateModule({
-        workspaceRoot: context.workspaceRoot,
-        targets: resolveRoutesGenerateTargets(args, context)
-    });
-    return runRenderedModule(source, context);
+    const targets = resolveRoutesGenerateTargets(args, context);
+    const mode = args.includes('--manifest-only') ? 'manifest' : 'all';
+    let failed = false;
+    for (const target of targets){
+        const status = spawnNodeScript('dist/esm-node/ultramodern-tooling/commands/routes-generate-app.js', [
+            target.appDirectory,
+            target.label,
+            mode
+        ], context, {
+            cwd: target.appDirectory
+        });
+        failed ||= 0 !== status;
+    }
+    return failed ? 1 : 0;
 }
 export { runRoutesGenerate };

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

@@ -1,16 +1,10 @@
 import "node:module";
-import { readWorkspaceReleaseCohort } from "../../ultramodern-release-cohort.js";
-import { createWorkspaceValidationScript } from "../../ultramodern-workspace/workspace-scripts.js";
-import { additionalShellsFromToolingConfig, readUltramodernConfig, workspaceAppsFromToolingConfig } from "../config.js";
-import { runRenderedModule } from "./context.js";
+import { validateWorkspace } from "../../ultramodern-workspace/validation/workspace.js";
+import { createWorkspaceValidationContract } from "../../ultramodern-workspace/workspace-validation-contract.js";
+import { readUltramodernWorkspaceInputs } from "../config.js";
 function runValidate(context) {
-    const config = readUltramodernConfig(context.workspaceRoot);
-    const apps = workspaceAppsFromToolingConfig(config);
-    const remotes = apps.filter((app)=>'shell' !== app.kind);
-    const primaryShell = apps.find((app)=>'shell' === app.kind);
-    const additionalShells = additionalShellsFromToolingConfig(config);
-    const releaseCohort = config.packageSource?.strategy === 'install' ? readWorkspaceReleaseCohort(context.workspaceRoot) : void 0;
-    const source = createWorkspaceValidationScript(config.workspace.packageScope, config.features.tailwind, remotes, releaseCohort, additionalShells, primaryShell);
-    return runRenderedModule(source, context);
+    const { config, raw, verticals, primaryShell, additionalShells } = readUltramodernWorkspaceInputs(context.workspaceRoot);
+    validateWorkspace(context.workspaceRoot, createWorkspaceValidationContract(config.workspace.packageScope, config.features.tailwind, raw.topology.sharedPackages, verticals, additionalShells, primaryShell));
+    return 0;
 }
 export { runValidate };

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

@@ -1,10 +1,10 @@
 import "node:module";
+import node_fs from "node:fs";
 import node_path from "node:path";
 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 { AD_HOC_TOOLING_COMMANDS, 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";
@@ -12,8 +12,16 @@ import { runValidate } from "./commands/validate.js";
 async function runUltramodernToolingCli(args, workspaceRoot = process.env.ULTRAMODERN_WORKSPACE_ROOT ?? process.cwd()) {
     try {
         const [command, ...rest] = args;
+        let discoveredRoot = node_path.resolve(workspaceRoot);
+        for(let candidate = discoveredRoot;; candidate = node_path.dirname(candidate)){
+            if (node_fs.existsSync(node_path.join(candidate, 'topology/reference-topology.json'))) {
+                discoveredRoot = candidate;
+                break;
+            }
+            if (node_path.dirname(candidate) === candidate) break;
+        }
         const context = {
-            workspaceRoot: node_path.resolve(workspaceRoot),
+            workspaceRoot: discoveredRoot,
             invocationCwd: process.cwd()
         };
         switch(command){
@@ -26,15 +34,13 @@ async function runUltramodernToolingCli(args, workspaceRoot = process.env.ULTRAM
                 return runValidate(context);
             case GENERATED_TOOLING_COMMANDS.mfTypes.command:
                 return runMfTypes(rest, context);
-            case GENERATED_TOOLING_COMMANDS.migrateStrictEffect.command:
-                return await runMigrateStrictEffect(rest, context);
             case GENERATED_TOOLING_COMMANDS.cloudflareOutputVerify.command:
-                return runCloudflareOutputVerify(rest, context);
+                return await runCloudflareOutputVerify(rest, context);
             case GENERATED_TOOLING_COMMANDS.routesGenerate.command:
-                return runRoutesGenerate(rest, context);
-            case 'sync-delivery-unit':
+                return await runRoutesGenerate(rest, context);
+            case AD_HOC_TOOLING_COMMANDS.syncDeliveryUnit:
                 return runSyncDeliveryUnit(rest, context);
-            case 'skills':
+            case AD_HOC_TOOLING_COMMANDS.skills:
                 return runSkills(rest, context);
             default:
                 {

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

@@ -1,8 +1,6 @@
 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/load.js

@@ -1,14 +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";
+import { normalizeWorkspaceInputs } 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 \`ultramodern-create ultramodern migrate-strict-effect\` to synthesize it.`);
-    throw new Error(`Missing UltraModern config. Expected ${ULTRAMODERN_CONFIG_PATH}. Run \`ultramodern-create ultramodern migrate-strict-effect\` if you have legacy UltraModern metadata to migrate.`);
+    return readUltramodernWorkspaceInputs(workspaceRoot).config;
 }
-export { readUltramodernConfig };
+function readUltramodernWorkspaceInputs(workspaceRoot = process.cwd(), inputs = {}) {
+    return normalizeWorkspaceInputs(workspaceRoot, {
+        topology: inputs.topology ?? readJsonObject(node_path.join(workspaceRoot, 'topology/reference-topology.json')),
+        overlay: inputs.overlay ?? readJsonObject(node_path.join(workspaceRoot, 'topology/local-overlays/development.json'))
+    });
+}
+export { readUltramodernConfig, readUltramodernWorkspaceInputs };

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

@@ -1,38 +1,43 @@
 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";
+import { yaml } from "@modern-js/utils";
+import { 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;
+function readWorkspacePackageSource(workspaceRoot) {
+    const manifest = readOptionalJsonObject(node_path.join(workspaceRoot, 'package.json'));
+    const name = '@modern-js/ultramodern-create';
+    let request = manifest.devDependencies?.[name] ?? manifest.dependencies?.[name];
+    if ('string' != typeof request) throw new Error(`Missing ${name} dependency in package.json.`);
+    if (request.startsWith('catalog:')) {
+        const config = yaml.load(node_fs.readFileSync(node_path.join(workspaceRoot, 'pnpm-workspace.yaml'), 'utf8'));
+        const catalog = request.slice(8);
+        request = (catalog ? config.catalogs?.[catalog] : config.catalog)?.[name];
+        if ('string' != typeof request) throw new Error(`Missing ${name} in pnpm catalog ${catalog || 'default'}.`);
+    }
+    if (request.startsWith('workspace:')) return {
+        strategy: 'workspace',
+        modernPackageVersion: 'workspace:*'
+    };
+    const alias = /^npm:@([^/]+)\/([^@]+)@([^@]+)$/u.exec(request);
+    if (alias) {
+        const [, aliasScope, target, modernPackageVersion] = alias;
+        const suffix = 'ultramodern-create';
+        if (!target.endsWith(suffix)) throw new Error(`Unsupported framework package alias: ${request}.`);
+        return {
+            strategy: 'install',
+            modernPackageVersion,
+            aliasScope,
+            aliasPackageNamePrefix: target.slice(0, -suffix.length)
+        };
+    }
+    if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u.test(request)) throw new Error(`Framework dependency must use an exact version or workspace source: ${request}.`);
     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
+        strategy: 'install',
+        modernPackageVersion: request
     };
 }
-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 };
+export { packageScopeFromRoot, readWorkspacePackageSource };

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

@@ -1,174 +1,177 @@
 import "node:module";
+import node_fs from "node:fs";
 import node_path from "node:path";
-import { normalizeUltramodernBridgeConfig } from "../../ultramodern-workspace/bridge-config.js";
-import { ULTRAMODERN_CONFIG_PATH, createNeutralOwnership, shellApp } from "../../ultramodern-workspace/descriptors.js";
-import { toKebabCase } from "../../ultramodern-workspace/naming.js";
-import { resolveConfiguredAdditionalShells } from "../../ultramodern-workspace/shells.js";
-import { isVerticalApiProtocol, isVerticalPreset, isWorkspaceDeliveryUnitKind } from "../../ultramodern-workspace/types.js";
-import { packageScopeFromRoot } from "./metadata.js";
-class UnsupportedUltramodernConfigError extends Error {
-    constructor(sourcePath, issue){
-        const value = formatUnsupportedConfigValue(issue.value);
-        const message = 'schemaVersion' === issue.field ? formatSchemaVersionError(sourcePath, issue.reason, value) : `Unsupported UltraModern config app kind ${value} at ${sourcePath} topology.apps[${issue.index}].kind. Supported kinds: shell, vertical.`;
-        super(message), this.sourcePath = sourcePath, this.issue = issue;
-        this.name = 'UnsupportedUltramodernConfigError';
-    }
-}
-function normalizeCompactConfig(workspaceRoot, sourcePath, config) {
-    const schemaVersion = config.schemaVersion;
-    if (1 !== schemaVersion) throw new UnsupportedUltramodernConfigError(sourcePath, {
-        field: 'schemaVersion',
-        value: schemaVersion,
-        reason: void 0 === schemaVersion ? 'missing' : Number.isInteger(schemaVersion) ? 'unsupported' : 'non-integer'
+import { verticalsFromTopology } from "../../ultramodern-workspace/add-vertical/topology.js";
+import { createNeutralOwnership, shellApp } from "../../ultramodern-workspace/descriptors.js";
+import { readModuleFederationExposePaths } from "../../ultramodern-workspace/mf-validation.js";
+import { toEnvSegment } from "../../ultramodern-workspace/naming.js";
+import { readJsonObject } from "./json.js";
+import { packageScopeFromRoot, readWorkspacePackageSource } from "./metadata.js";
+function normalizeWorkspaceInputs(workspaceRoot, inputs) {
+    const { topology, overlay } = inputs;
+    if (1 !== topology.schemaVersion || !topology.shell || !Array.isArray(topology.verticals) || void 0 !== topology.shells && !Array.isArray(topology.shells)) throw new Error('Invalid topology/reference-topology.json: expected schemaVersion 1, shell, verticals and optional shells.');
+    if (1 !== overlay.schemaVersion || !overlay.ports || 'object' != typeof overlay.ports) throw new Error('Invalid development overlay: expected schemaVersion 1 and ports.');
+    const records = [
+        topology.shell,
+        ...topology.verticals,
+        ...topology.shells ?? []
+    ];
+    const ids = new Set();
+    const paths = new Set();
+    const ports = new Map();
+    const root = node_fs.realpathSync(workspaceRoot);
+    const manifests = new Map();
+    const apps = records.map((entry, index)=>{
+        if ('string' != typeof entry.id || !entry.id || ids.has(entry.id)) throw new Error(`Missing or duplicate topology app id: ${entry.id}.`);
+        ids.add(entry.id);
+        if ('string' != typeof entry.path || !entry.path || node_path.isAbsolute(entry.path)) throw new Error(`Topology ${entry.id} requires a relative path.`);
+        const appRoot = node_fs.realpathSync(node_path.resolve(root, entry.path));
+        const relative = node_path.relative(root, appRoot);
+        if (!relative || '..' === relative || relative.startsWith(`..${node_path.sep}`) || node_path.isAbsolute(relative) || paths.has(appRoot)) throw new Error(`Topology ${entry.id} has an unsafe or duplicate path: ${entry.path}.`);
+        paths.add(appRoot);
+        const manifest = readJsonObject(node_path.join(appRoot, 'package.json'));
+        if ('string' != typeof manifest.name || !manifest.name || void 0 !== entry.package && manifest.name !== entry.package) throw new Error(`Topology ${entry.id} package identity disagrees with ${entry.path}/package.json.`);
+        manifests.set(entry.id, manifest);
+        const port = overlay.ports[entry.id];
+        if (!Number.isInteger(port) || port < 1 || port > 65535 || ports.has(port)) throw new Error(`Invalid or duplicate development port for ${entry.id}: ${port}.`);
+        ports.set(port, entry.id);
+        const isShell = 0 === index || index > topology.verticals.length;
+        if (entry.kind !== (isShell ? 'shell' : 'vertical')) throw new Error(`Invalid topology app kind for ${entry.id}.`);
+        const packageSuffix = manifest.name.split('/').at(-1);
+        if (isShell) return {
+            ...shellApp,
+            id: entry.id,
+            directory: entry.path,
+            packageSuffix,
+            displayName: entry.displayName ?? entry.id,
+            port,
+            portEnv: entry.portEnv ?? (entry.id === shellApp.id ? shellApp.portEnv : `SHELL_${toEnvSegment(entry.id.replace(/^shell-/u, ''))}_PORT`),
+            mfName: entry.moduleFederation?.name ?? entry.id,
+            verticalRefs: entry.verticalRefs ?? entry.moduleFederation?.verticalRefs ?? [],
+            ...entry.deliveryUnit ? {
+                deliveryUnit: entry.deliveryUnit
+            } : {},
+            ownership: entry.ownership ?? createNeutralOwnership(entry.id, 'tier-0-shell')
+        };
+        const [app] = verticalsFromTopology({
+            verticals: [
+                entry
+            ]
+        }, overlay.ports);
+        const actualExposes = readModuleFederationExposePaths(workspaceRoot, entry.path);
+        return {
+            ...app,
+            packageSuffix,
+            ...actualExposes ? {
+                exposes: actualExposes
+            } : {}
+        };
     });
-    return normalizeCompactConfigV1(workspaceRoot, sourcePath, config);
-}
-function normalizeCompactConfigV1(workspaceRoot, sourcePath, config) {
-    const packageSource = config.packageSource && 'object' == typeof config.packageSource ? {
-        strategy: 'install' === config.packageSource.strategy ? 'install' : 'workspace',
-        modernPackageVersion: 'string' == typeof config.packageSource.modernPackageVersion ? config.packageSource.modernPackageVersion : 'workspace:*',
-        registry: 'string' == typeof config.packageSource.registry ? config.packageSource.registry : void 0,
-        aliasScope: 'string' == typeof config.packageSource.aliasScope ? config.packageSource.aliasScope : void 0,
-        aliasPackageNamePrefix: 'string' == typeof config.packageSource.aliasPackageNamePrefix ? config.packageSource.aliasPackageNamePrefix : void 0
-    } : void 0;
-    return {
-        schemaVersion: 1,
-        profile: 'string' == typeof config.profile ? config.profile : void 0,
-        source: 'compact',
-        sourcePath,
+    const knownPackages = new Set([
+        ...[
+            ...manifests.values()
+        ].map((manifest)=>manifest.name),
+        ...(topology.sharedPackages ?? []).map((entry)=>entry.package)
+    ]);
+    const primaryManifest = manifests.get(apps[0].id);
+    const inheritedWorkspaceDependencies = Object.fromEntries(Object.entries(primaryManifest.dependencies ?? {}).filter(([name, value])=>'string' == typeof value && value.startsWith('workspace:') && !name.startsWith('@modern-js/') && !knownPackages.has(name)));
+    const config = {
         workspace: {
-            packageScope: 'string' == typeof config.workspace?.packageScope ? config.workspace.packageScope : packageScopeFromRoot(workspaceRoot)
+            packageScope: packageScopeFromRoot(workspaceRoot)
         },
-        packageSource,
+        packageSource: readWorkspacePackageSource(workspaceRoot),
         features: {
-            tailwind: config.features?.tailwind !== false
+            tailwind: Boolean(primaryManifest.devDependencies?.tailwindcss ?? primaryManifest.dependencies?.tailwindcss)
         },
-        bridge: normalizeUltramodernBridgeConfig(config.bridge),
+        inheritedWorkspaceDependencies,
         topology: {
-            apps: Array.isArray(config.topology?.apps) ? config.topology.apps.map((app, index)=>{
-                if ('shell' !== app.kind && 'vertical' !== app.kind) throw new UnsupportedUltramodernConfigError(sourcePath, {
-                    field: 'topology.apps.kind',
-                    index,
-                    value: app.kind
-                });
-                return {
-                    id: String(app.id),
+            apps: apps.map((app)=>({
+                    id: app.id,
                     kind: app.kind,
-                    path: 'string' == typeof app.path ? app.path : '.',
-                    package: 'string' == typeof app.package ? app.package : void 0,
-                    packageSuffix: 'string' == typeof app.packageSuffix ? app.packageSuffix : void 0,
-                    displayName: 'string' == typeof app.displayName ? app.displayName : void 0,
-                    domain: 'string' == typeof app.domain ? app.domain : void 0,
-                    ...isVerticalPreset(app.surfaceProfile) ? {
-                        surfaceProfile: app.surfaceProfile
-                    } : {},
-                    ...isWorkspaceDeliveryUnitKind(app.deliveryUnitKind) ? {
-                        deliveryUnitKind: app.deliveryUnitKind
-                    } : {},
-                    port: 'number' == typeof app.port ? app.port : void 0,
-                    portEnv: 'string' == typeof app.portEnv ? app.portEnv : void 0,
-                    moduleFederation: app.moduleFederation && 'object' == typeof app.moduleFederation ? {
-                        role: 'remote' === app.moduleFederation.role ? 'remote' : 'host',
-                        name: 'string' == typeof app.moduleFederation.name ? app.moduleFederation.name : void 0,
-                        exposes: Array.isArray(app.moduleFederation.exposes) ? app.moduleFederation.exposes.filter((expose)=>'string' == typeof expose) : void 0,
-                        exposePaths: null === app.moduleFederation.exposePaths || 'object' != typeof app.moduleFederation.exposePaths || Array.isArray(app.moduleFederation.exposePaths) ? void 0 : Object.fromEntries(Object.entries(app.moduleFederation.exposePaths).filter((entry)=>'string' == typeof entry[0] && 'string' == typeof entry[1])),
-                        verticalRefs: Array.isArray(app.moduleFederation.verticalRefs) ? app.moduleFederation.verticalRefs.filter((ref)=>'string' == typeof ref) : void 0,
-                        hostOnly: true === app.moduleFederation.hostOnly,
-                        noExposes: true === app.moduleFederation.noExposes
-                    } : void 0,
-                    api: app.api && 'object' == typeof app.api ? {
-                        stem: 'string' == typeof app.api.stem ? app.api.stem : String(app.id),
-                        prefix: 'string' == typeof app.api.prefix ? app.api.prefix : `/${String(app.id)}-api`,
-                        consumedBy: Array.isArray(app.api.consumedBy) ? app.api.consumedBy.filter((consumer)=>'string' == typeof consumer) : [
-                            shellApp.id,
-                            String(app.id)
-                        ],
-                        ...isVerticalApiProtocol(app.api.protocol) ? {
-                            protocol: app.api.protocol
-                        } : {}
-                    } : void 0
-                };
-            }) : []
-        },
-        ...Array.isArray(config.shells) && config.shells.length > 0 ? {
-            shells: config.shells.filter((shell)=>null !== shell && 'object' == typeof shell && !Array.isArray(shell))
-        } : {}
+                    path: app.directory,
+                    package: manifests.get(app.id).name,
+                    packageSuffix: app.packageSuffix,
+                    displayName: app.displayName,
+                    domain: app.domain,
+                    port: app.port,
+                    portEnv: app.portEnv,
+                    surfaceProfile: app.surfaceProfile,
+                    deliveryUnitKind: app.deliveryUnitKind,
+                    deliveryUnit: app.deliveryUnit,
+                    moduleFederation: {
+                        role: 'shell' === app.kind ? 'host' : 'remote',
+                        name: app.mfName,
+                        exposes: Object.keys(app.exposes ?? {}),
+                        exposePaths: app.exposes,
+                        verticalRefs: app.verticalRefs
+                    },
+                    api: app.api
+                }))
+        }
+    };
+    return {
+        raw: inputs,
+        config,
+        apps,
+        primaryShell: apps[0],
+        verticals: apps.filter((app)=>'vertical' === app.kind),
+        additionalShells: apps.filter((app, index)=>index > 0 && 'shell' === app.kind)
     };
 }
-function formatUnsupportedConfigValue(value) {
-    if (void 0 === value) return 'missing';
-    return JSON.stringify(value) ?? String(value);
-}
-function formatSchemaVersionError(sourcePath, reason, value) {
-    switch(reason){
-        case 'missing':
-            return `UltraModern config schemaVersion is required in ${sourcePath}. Versionless v1 configs are not supported; set schemaVersion to the integer 1.`;
-        case 'non-integer':
-            return `Invalid UltraModern config schemaVersion ${value} in ${sourcePath}. schemaVersion must be the integer 1; versionless v1 configs are not supported.`;
-        case 'unsupported':
-            return `Unsupported UltraModern config schemaVersion ${value} in ${sourcePath}. Supported schema versions: 1. Versionless v1 configs are not supported.`;
-    }
-}
-function normalizeCompactUltramodernConfig(workspaceRoot, compact) {
-    return normalizeCompactConfig(workspaceRoot, node_path.join(workspaceRoot, ULTRAMODERN_CONFIG_PATH), compact);
-}
-function workspaceAppsFromToolingConfig(config) {
-    return config.topology.apps.map((app)=>{
-        if ('shell' === app.kind) return {
-            ...shellApp,
-            directory: app.path,
-            packageSuffix: app.packageSuffix ?? shellApp.packageSuffix,
-            displayName: app.displayName ?? shellApp.displayName,
-            port: app.port ?? shellApp.port,
-            portEnv: app.portEnv ?? shellApp.portEnv,
-            mfName: app.moduleFederation?.name ?? shellApp.mfName,
-            verticalRefs: app.moduleFederation?.verticalRefs ?? []
-        };
-        const domain = app.domain ?? app.id;
-        const packageSuffix = app.packageSuffix ?? domain;
-        const exposePaths = app.moduleFederation?.exposePaths ?? {};
-        const exposes = Object.fromEntries((app.moduleFederation?.exposes ?? []).map((expose)=>{
-            const configuredPath = exposePaths[expose];
-            const inferredPath = './Route' === expose ? './src/federation-entry.tsx' : './Widget' === expose ? `./src/components/${domain}-widget.tsx` : `./src/components/${toKebabCase(expose.replace(/^\.\//u, ''))}.tsx`;
-            return [
-                expose,
-                configuredPath ?? inferredPath
-            ];
-        }));
-        return {
+function workspaceAppsFromToolingConfig(config, _workspaceRoot) {
+    return config.topology.apps.map((app)=>({
             id: app.id,
+            kind: app.kind,
             directory: app.path,
-            packageSuffix,
-            displayName: app.displayName ?? `${domain} Vertical`,
-            kind: 'vertical',
-            domain,
-            portEnv: app.portEnv ?? `VERTICAL_${domain.replace(/[^a-zA-Z0-9]+/g, '_').toUpperCase()}_PORT`,
-            port: app.port ?? 0,
+            packageSuffix: app.packageSuffix ?? app.id,
+            displayName: app.displayName ?? app.id,
+            port: app.port,
+            portEnv: app.portEnv,
             mfName: app.moduleFederation?.name ?? app.id,
-            exposes,
-            ...app.moduleFederation?.verticalRefs ? {
-                verticalRefs: app.moduleFederation.verticalRefs
-            } : {},
-            ...void 0 === app.surfaceProfile ? {} : {
-                surfaceProfile: app.surfaceProfile
-            },
-            ...void 0 === app.deliveryUnitKind ? {} : {
-                deliveryUnitKind: app.deliveryUnitKind
-            },
-            ...app.api ? {
-                api: app.api
-            } : {},
+            domain: app.domain,
+            surfaceProfile: app.surfaceProfile,
+            deliveryUnitKind: app.deliveryUnitKind,
+            deliveryUnit: app.deliveryUnit,
+            exposes: app.moduleFederation?.exposePaths,
+            verticalRefs: app.moduleFederation?.verticalRefs,
+            api: app.api,
             ownership: createNeutralOwnership(app.id)
-        };
-    });
+        }));
 }
-function additionalShellsFromToolingConfig(config) {
-    return resolveConfiguredAdditionalShells(config);
+function allWorkspaceAppsFromToolingConfig(config, workspaceRoot) {
+    return workspaceAppsFromToolingConfig(config, workspaceRoot);
 }
-function allWorkspaceAppsFromToolingConfig(config) {
-    return [
-        ...workspaceAppsFromToolingConfig(config),
-        ...additionalShellsFromToolingConfig(config)
-    ];
+function reconcileGeneratedOverlayUrls(existing, previous, projected) {
+    return Object.fromEntries([
+        'manifests',
+        'apis'
+    ].map((key)=>{
+        const authored = {
+            ...existing[key]
+        };
+        for (const [id, value] of Object.entries(authored))if (value === previous[key]?.[id]) delete authored[id];
+        return [
+            key,
+            {
+                ...projected[key],
+                ...authored
+            }
+        ];
+    }));
+}
+function preserveUnknownProjectionFields(current, projected) {
+    if (Array.isArray(projected)) return projected.map((entry)=>{
+        const previous = entry && 'object' == typeof entry && 'string' == typeof entry.id && Array.isArray(current) ? current.find((candidate)=>candidate?.id === entry.id) : void 0;
+        return preserveUnknownProjectionFields(previous, entry);
+    });
+    if (!projected || 'object' != typeof projected) return projected;
+    const previous = current && 'object' == typeof current && !Array.isArray(current) ? current : {};
+    return {
+        ...previous,
+        ...Object.fromEntries(Object.entries(projected).map(([key, value])=>[
+                key,
+                preserveUnknownProjectionFields(previous[key], value)
+            ]))
+    };
 }
-export { UnsupportedUltramodernConfigError, additionalShellsFromToolingConfig, allWorkspaceAppsFromToolingConfig, normalizeCompactConfig, normalizeCompactUltramodernConfig, workspaceAppsFromToolingConfig };
+export { allWorkspaceAppsFromToolingConfig, normalizeWorkspaceInputs, preserveUnknownProjectionFields, reconcileGeneratedOverlayUrls, workspaceAppsFromToolingConfig };