@bleedingdev/modern-js-ultramodern-create 3.9.0-ultramodern.11 → 3.9.0-ultramodern.13

package/dist/cjs/ultramodern-tooling/config/index.cjs

@@ -6,6 +6,9 @@ var __webpack_modules__ = {
     "./load" (module) {
         module.exports = require("./load.cjs");
     },
+    "./metadata" (module) {
+        module.exports = require("./metadata.cjs");
+    },
     "./normalize" (module) {
         module.exports = require("./normalize.cjs");
     },
@@ -68,13 +71,17 @@ var __webpack_exports__ = {};
     var __rspack_reexport = {};
     for(const __rspack_import_key in _load__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_load__rspack_import_1[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _normalize__rspack_import_2 = __webpack_require__("./normalize");
+    var _metadata__rspack_import_2 = __webpack_require__("./metadata");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _metadata__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_metadata__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _normalize__rspack_import_3 = __webpack_require__("./normalize");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _normalize__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_normalize__rspack_import_2[__rspack_import_key];
+    for(const __rspack_import_key in _normalize__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_normalize__rspack_import_3[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _types__rspack_import_3 = __webpack_require__("./types");
+    var _types__rspack_import_4 = __webpack_require__("./types");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _types__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_3[__rspack_import_key];
+    for(const __rspack_import_key in _types__rspack_import_4)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_4[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
 })();
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/cjs/ultramodern-tooling/config/load.cjs

@@ -40,31 +40,18 @@ __webpack_require__.d(__webpack_exports__, {
     readUltramodernConfig: ()=>readUltramodernConfig,
     readUltramodernWorkspaceInputs: ()=>readUltramodernWorkspaceInputs
 });
-const external_node_fs_namespaceObject = require("node:fs");
-var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-const descriptors_cjs_namespaceObject = require("../../ultramodern-workspace/descriptors.cjs");
 const external_json_cjs_namespaceObject = require("./json.cjs");
 const external_normalize_cjs_namespaceObject = require("./normalize.cjs");
 function readUltramodernConfig(workspaceRoot = process.cwd()) {
-    const { sourcePath, config } = readCompactInputs(workspaceRoot);
-    return (0, external_normalize_cjs_namespaceObject.normalizeCompactConfig)(workspaceRoot, sourcePath, config);
+    return readUltramodernWorkspaceInputs(workspaceRoot).config;
 }
 function readUltramodernWorkspaceInputs(workspaceRoot = process.cwd(), inputs = {}) {
-    const { sourcePath, config } = readCompactInputs(workspaceRoot);
     return (0, external_normalize_cjs_namespaceObject.normalizeWorkspaceInputs)(workspaceRoot, {
-        ...inputs,
-        config
-    }, sourcePath);
-}
-function readCompactInputs(workspaceRoot) {
-    const compactPath = external_node_path_default().join(workspaceRoot, descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH);
-    if (external_node_fs_default().existsSync(compactPath)) return {
-        sourcePath: compactPath,
-        config: (0, external_json_cjs_namespaceObject.readJsonObject)(compactPath)
-    };
-    throw new Error(`Missing UltraModern config. Expected ${descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH}.`);
+        topology: inputs.topology ?? (0, external_json_cjs_namespaceObject.readJsonObject)(external_node_path_default().join(workspaceRoot, 'topology/reference-topology.json')),
+        overlay: inputs.overlay ?? (0, external_json_cjs_namespaceObject.readJsonObject)(external_node_path_default().join(workspaceRoot, 'topology/local-overlays/development.json'))
+    });
 }
 exports.readUltramodernConfig = __webpack_exports__.readUltramodernConfig;
 exports.readUltramodernWorkspaceInputs = __webpack_exports__.readUltramodernWorkspaceInputs;

package/dist/cjs/ultramodern-tooling/config/metadata.cjs

@@ -37,18 +37,57 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    packageScopeFromRoot: ()=>packageScopeFromRoot
+    packageScopeFromRoot: ()=>packageScopeFromRoot,
+    readWorkspacePackageSource: ()=>readWorkspacePackageSource
 });
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
 const external_json_cjs_namespaceObject = require("./json.cjs");
 function packageScopeFromRoot(workspaceRoot) {
     const rootPackage = (0, external_json_cjs_namespaceObject.readOptionalJsonObject)(external_node_path_default().join(workspaceRoot, 'package.json'));
     return 'string' == typeof rootPackage.name && rootPackage.name.length > 0 ? rootPackage.name : external_node_path_default().basename(workspaceRoot);
 }
+function readWorkspacePackageSource(workspaceRoot) {
+    const manifest = (0, external_json_cjs_namespaceObject.readOptionalJsonObject)(external_node_path_default().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 = utils_namespaceObject.yaml.load(external_node_fs_default().readFileSync(external_node_path_default().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',
+        modernPackageVersion: request
+    };
+}
 exports.packageScopeFromRoot = __webpack_exports__.packageScopeFromRoot;
+exports.readWorkspacePackageSource = __webpack_exports__.readWorkspacePackageSource;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "packageScopeFromRoot"
+    "packageScopeFromRoot",
+    "readWorkspacePackageSource"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/ultramodern-tooling/config/normalize.cjs

@@ -37,224 +37,155 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    UnsupportedUltramodernConfigError: ()=>UnsupportedUltramodernConfigError,
-    additionalShellsFromToolingConfig: ()=>additionalShellsFromToolingConfig,
     allWorkspaceAppsFromToolingConfig: ()=>allWorkspaceAppsFromToolingConfig,
-    normalizeCompactConfig: ()=>normalizeCompactConfig,
-    normalizeCompactUltramodernConfig: ()=>normalizeCompactUltramodernConfig,
     normalizeWorkspaceInputs: ()=>normalizeWorkspaceInputs,
     preserveUnknownProjectionFields: ()=>preserveUnknownProjectionFields,
     reconcileGeneratedOverlayUrls: ()=>reconcileGeneratedOverlayUrls,
     workspaceAppsFromToolingConfig: ()=>workspaceAppsFromToolingConfig
 });
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const topology_cjs_namespaceObject = require("../../ultramodern-workspace/add-vertical/topology.cjs");
-const bridge_config_cjs_namespaceObject = require("../../ultramodern-workspace/bridge-config.cjs");
 const descriptors_cjs_namespaceObject = require("../../ultramodern-workspace/descriptors.cjs");
 const mf_validation_cjs_namespaceObject = require("../../ultramodern-workspace/mf-validation.cjs");
 const naming_cjs_namespaceObject = require("../../ultramodern-workspace/naming.cjs");
-const shells_cjs_namespaceObject = require("../../ultramodern-workspace/shells.cjs");
-const types_cjs_namespaceObject = require("../../ultramodern-workspace/types.cjs");
+const external_json_cjs_namespaceObject = require("./json.cjs");
 const external_metadata_cjs_namespaceObject = require("./metadata.cjs");
-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'
+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 = external_node_fs_default().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 || external_node_path_default().isAbsolute(entry.path)) throw new Error(`Topology ${entry.id} requires a relative path.`);
+        const appRoot = external_node_fs_default().realpathSync(external_node_path_default().resolve(root, entry.path));
+        const relative = external_node_path_default().relative(root, appRoot);
+        if (!relative || '..' === relative || relative.startsWith(`..${external_node_path_default().sep}`) || external_node_path_default().isAbsolute(relative) || paths.has(appRoot)) throw new Error(`Topology ${entry.id} has an unsafe or duplicate path: ${entry.path}.`);
+        paths.add(appRoot);
+        const manifest = (0, external_json_cjs_namespaceObject.readJsonObject)(external_node_path_default().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 {
+            ...descriptors_cjs_namespaceObject.shellApp,
+            id: entry.id,
+            directory: entry.path,
+            packageSuffix,
+            displayName: entry.displayName ?? entry.id,
+            port,
+            portEnv: entry.portEnv ?? (entry.id === descriptors_cjs_namespaceObject.shellApp.id ? descriptors_cjs_namespaceObject.shellApp.portEnv : `SHELL_${(0, naming_cjs_namespaceObject.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 ?? (0, descriptors_cjs_namespaceObject.createNeutralOwnership)(entry.id, 'tier-0-shell')
+        };
+        const [app] = (0, topology_cjs_namespaceObject.verticalsFromTopology)({
+            verticals: [
+                entry
+            ]
+        }, overlay.ports);
+        const actualExposes = (0, mf_validation_cjs_namespaceObject.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 : (0, external_metadata_cjs_namespaceObject.packageScopeFromRoot)(workspaceRoot)
+            packageScope: (0, external_metadata_cjs_namespaceObject.packageScopeFromRoot)(workspaceRoot)
         },
-        packageSource,
+        packageSource: (0, external_metadata_cjs_namespaceObject.readWorkspacePackageSource)(workspaceRoot),
         features: {
-            tailwind: config.features?.tailwind !== false
+            tailwind: Boolean(primaryManifest.devDependencies?.tailwindcss ?? primaryManifest.dependencies?.tailwindcss)
         },
-        bridge: (0, bridge_config_cjs_namespaceObject.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),
-                    ...app.deliveryUnit ? {
-                        deliveryUnit: app.deliveryUnit
-                    } : {},
+            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,
-                    ...(0, types_cjs_namespaceObject.isVerticalPreset)(app.surfaceProfile) ? {
-                        surfaceProfile: app.surfaceProfile
-                    } : {},
-                    ...(0, types_cjs_namespaceObject.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) : [
-                            descriptors_cjs_namespaceObject.shellApp.id,
-                            String(app.id)
-                        ],
-                        ...(0, types_cjs_namespaceObject.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, external_node_path_default().join(workspaceRoot, descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH), compact);
-}
-function workspaceAppsFromToolingConfig(config, workspaceRoot) {
-    return config.topology.apps.map((app)=>{
-        if ('shell' === app.kind) return {
-            ...descriptors_cjs_namespaceObject.shellApp,
-            ...app.deliveryUnit ? {
-                deliveryUnit: app.deliveryUnit
-            } : {},
-            directory: app.path,
-            packageSuffix: app.packageSuffix ?? descriptors_cjs_namespaceObject.shellApp.packageSuffix,
-            displayName: app.displayName ?? descriptors_cjs_namespaceObject.shellApp.displayName,
-            port: app.port ?? descriptors_cjs_namespaceObject.shellApp.port,
-            portEnv: app.portEnv ?? descriptors_cjs_namespaceObject.shellApp.portEnv,
-            mfName: app.moduleFederation?.name ?? descriptors_cjs_namespaceObject.shellApp.mfName,
-            verticalRefs: app.moduleFederation?.verticalRefs ?? []
-        };
-        const domain = app.domain ?? app.id;
-        const packageSuffix = app.packageSuffix ?? domain;
-        const exposePaths = app.moduleFederation?.exposePaths ?? {};
-        const federatedPaths = void 0 === workspaceRoot ? void 0 : (0, mf_validation_cjs_namespaceObject.readModuleFederationExposePaths)(workspaceRoot, app.path);
-        const exposes = Object.fromEntries((app.moduleFederation?.exposes ?? []).map((expose)=>{
-            const configuredPath = federatedPaths?.[expose] ?? exposePaths[expose];
-            const inferredPath = './Route' === expose ? './src/federation-entry.tsx' : './Widget' === expose ? `./src/components/${domain}-widget.tsx` : `./src/components/${(0, naming_cjs_namespaceObject.toKebabCase)(expose.replace(/^\.\//u, ''))}.tsx`;
-            return [
-                expose,
-                configuredPath ?? inferredPath
-            ];
-        }));
-        return {
+function workspaceAppsFromToolingConfig(config, _workspaceRoot) {
+    return config.topology.apps.map((app)=>({
             id: app.id,
-            ...app.deliveryUnit ? {
-                deliveryUnit: app.deliveryUnit
-            } : {},
+            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: (0, descriptors_cjs_namespaceObject.createNeutralOwnership)(app.id)
-        };
-    });
-}
-function additionalShellsFromToolingConfig(config) {
-    return (0, shells_cjs_namespaceObject.resolveConfiguredAdditionalShells)(config);
+        }));
 }
 function allWorkspaceAppsFromToolingConfig(config, workspaceRoot) {
-    return [
-        ...workspaceAppsFromToolingConfig(config, workspaceRoot),
-        ...additionalShellsFromToolingConfig(config)
-    ];
-}
-function normalizeWorkspaceInputs(workspaceRoot, inputs, sourcePath = external_node_path_default().join(workspaceRoot, descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH)) {
-    const config = normalizeCompactConfig(workspaceRoot, sourcePath, inputs.config);
-    const ports = inputs.overlay?.ports ?? {};
-    const additionalShells = additionalShellsFromToolingConfig(config);
-    const topologyApps = inputs.topology ? [
-        (0, topology_cjs_namespaceObject.createPrimaryShellDescriptor)(inputs.topology, inputs.config),
-        ...(0, topology_cjs_namespaceObject.verticalsFromTopology)(inputs.topology, ports)
-    ] : workspaceAppsFromToolingConfig(config, workspaceRoot);
-    const apps = [
-        ...topologyApps.map((app)=>({
-                ...app,
-                port: 'number' == typeof ports[app.id] ? ports[app.id] : app.port
-            })),
-        ...additionalShells
-    ];
-    return {
-        raw: inputs,
-        config,
-        apps,
-        primaryShell: apps.find((app)=>app.id === descriptors_cjs_namespaceObject.shellApp.id),
-        verticals: apps.filter((app)=>'vertical' === app.kind),
-        additionalShells
-    };
+    return workspaceAppsFromToolingConfig(config, workspaceRoot);
 }
 function reconcileGeneratedOverlayUrls(existing, previous, projected) {
     return Object.fromEntries([
@@ -289,21 +220,13 @@ function preserveUnknownProjectionFields(current, projected) {
             ]))
     };
 }
-exports.UnsupportedUltramodernConfigError = __webpack_exports__.UnsupportedUltramodernConfigError;
-exports.additionalShellsFromToolingConfig = __webpack_exports__.additionalShellsFromToolingConfig;
 exports.allWorkspaceAppsFromToolingConfig = __webpack_exports__.allWorkspaceAppsFromToolingConfig;
-exports.normalizeCompactConfig = __webpack_exports__.normalizeCompactConfig;
-exports.normalizeCompactUltramodernConfig = __webpack_exports__.normalizeCompactUltramodernConfig;
 exports.normalizeWorkspaceInputs = __webpack_exports__.normalizeWorkspaceInputs;
 exports.preserveUnknownProjectionFields = __webpack_exports__.preserveUnknownProjectionFields;
 exports.reconcileGeneratedOverlayUrls = __webpack_exports__.reconcileGeneratedOverlayUrls;
 exports.workspaceAppsFromToolingConfig = __webpack_exports__.workspaceAppsFromToolingConfig;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "UnsupportedUltramodernConfigError",
-    "additionalShellsFromToolingConfig",
     "allWorkspaceAppsFromToolingConfig",
-    "normalizeCompactConfig",
-    "normalizeCompactUltramodernConfig",
     "normalizeWorkspaceInputs",
     "preserveUnknownProjectionFields",
     "reconcileGeneratedOverlayUrls",