@bleedingdev/modern-js-create 3.4.0-ultramodern.9 → 3.5.0-ultramodern.1

package/dist/cjs/ultramodern-tooling/commands.cjs

@@ -0,0 +1,431 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    runUltramodernToolingCli: ()=>runUltramodernToolingCli
+});
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_os_namespaceObject = require("node:os");
+var external_node_os_default = /*#__PURE__*/ __webpack_require__.n(external_node_os_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_url_namespaceObject = require("node:url");
+const external_create_package_root_cjs_namespaceObject = require("../create-package-root.cjs");
+const external_ultramodern_package_source_cjs_namespaceObject = require("../ultramodern-package-source.cjs");
+const mf_validation_cjs_namespaceObject = require("../ultramodern-workspace/mf-validation.cjs");
+const workspace_scripts_cjs_namespaceObject = require("../ultramodern-workspace/workspace-scripts.cjs");
+const external_config_cjs_namespaceObject = require("./config.cjs");
+const commands_dirname = external_node_path_default().dirname((0, external_node_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__));
+const createPackageRoot = (0, external_create_package_root_cjs_namespaceObject.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 = external_node_path_default().join(createPackageRoot, relativeScriptPath);
+    const result = (0, external_node_child_process_namespaceObject.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 = external_node_fs_default().mkdtempSync(external_node_path_default().join(external_node_os_default().tmpdir(), 'ultramodern-tool-'));
+    const tempFile = external_node_path_default().join(tempDir, 'command.mjs');
+    try {
+        external_node_fs_default().writeFileSync(tempFile, source, 'utf-8');
+        const result = (0, external_node_child_process_namespaceObject.spawnSync)(process.execPath, [
+            tempFile
+        ], {
+            cwd: context.workspaceRoot,
+            stdio: 'inherit'
+        });
+        if (result.error) throw result.error;
+        return result.status ?? 1;
+    } finally{
+        external_node_fs_default().rmSync(tempDir, {
+            force: true,
+            recursive: true
+        });
+    }
+}
+function runValidate(context) {
+    const config = (0, external_config_cjs_namespaceObject.readUltramodernConfig)(context.workspaceRoot);
+    const apps = (0, external_config_cjs_namespaceObject.workspaceAppsFromToolingConfig)(config);
+    const remotes = apps.filter((app)=>'shell' !== app.kind);
+    const source = (0, workspace_scripts_cjs_namespaceObject.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;
+    }
+    (0, mf_validation_cjs_namespaceObject.validateModuleFederationTypes)({
+        workspaceRoot: context.workspaceRoot,
+        appDirs: args.length > 0 ? args : void 0
+    });
+    return 0;
+}
+const modernPackageNames = new Set([
+    ...external_ultramodern_package_source_cjs_namespaceObject.ULTRAMODERN_SINGLE_APP_MODERN_PACKAGES,
+    ...external_ultramodern_package_source_cjs_namespaceObject.ULTRAMODERN_WORKSPACE_MODERN_PACKAGES
+]);
+function readJsonFile(filePath) {
+    return JSON.parse(external_node_fs_default().readFileSync(filePath, 'utf-8'));
+}
+function writeJsonFile(filePath, value) {
+    external_node_fs_default().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 = external_node_path_default().join(workspaceRoot, directory);
+        if (external_node_fs_default().existsSync(absoluteDirectory)) for (const entry of external_node_fs_default().readdirSync(absoluteDirectory, {
+            withFileTypes: true
+        })){
+            if (!entry.isDirectory()) continue;
+            const packageFile = external_node_path_default().join(directory, entry.name, 'package.json');
+            if (external_node_fs_default().existsSync(external_node_path_default().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 = (0, external_ultramodern_package_source_cjs_namespaceObject.modernPackageSpecifier)(packageName, packageSource);
+            if (dependencies[packageName] !== nextSpecifier) {
+                dependencies[packageName] = nextSpecifier;
+                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 = external_node_path_default().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 updateUltramodernConfig(workspaceRoot, packageSource) {
+    const configPath = external_node_path_default().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 = external_node_path_default().join(workspaceRoot, 'topology/reference-topology.json');
+    if (!external_node_fs_default().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 ?? external_ultramodern_package_source_cjs_namespaceObject.BLEEDINGDEV_PACKAGE_SCOPE : current.packageSource?.aliasScope);
+    const aliasPackageNamePrefix = readOption(args, '--alias-package-name-prefix') ?? readOption(args, '--ultramodern-package-name-prefix') ?? current.packageSource?.aliasPackageNamePrefix ?? (aliasScope ? external_ultramodern_package_source_cjs_namespaceObject.BLEEDINGDEV_PACKAGE_NAME_PREFIX : void 0);
+    if ('workspace' === strategy) return {
+        strategy,
+        modernPackageVersion: external_ultramodern_package_source_cjs_namespaceObject.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 === external_ultramodern_package_source_cjs_namespaceObject.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 = (0, external_node_child_process_namespaceObject.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,
+direct Effect API topology metadata, and the pnpm lockfile for strict Effect
+workspaces. Source code still has to pass pnpm api:check and pnpm contract:check.
+`);
+        return 0;
+    }
+    const current = (0, external_config_cjs_namespaceObject.readUltramodernConfig)(context.workspaceRoot);
+    const packageSource = createMigrationPackageSource(args, current);
+    updateUltramodernConfig(context.workspaceRoot, packageSource);
+    updateReferenceTopology(context.workspaceRoot);
+    for (const relativePackageFile of listWorkspacePackageFiles(context.workspaceRoot)){
+        const packageFile = external_node_path_default().join(context.workspaceRoot, relativePackageFile);
+        const packageJson = readJsonFile(packageFile);
+        if ('package.json' === relativePackageFile) {
+            packageJson.modernjs ??= {};
+            packageJson.modernjs.packageSource = {
+                strategy: packageSource.strategy,
+                config: './.modernjs/ultramodern.json'
+            };
+        }
+        if (updateModernDependencies(packageJson, packageSource)) writeJsonFile(packageFile, packageJson);
+        else if ('package.json' === relativePackageFile) writeJsonFile(packageFile, packageJson);
+    }
+    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>');
+}
+async function runUltramodernToolingCli(args, workspaceRoot = process.env.ULTRAMODERN_WORKSPACE_ROOT ?? process.cwd()) {
+    try {
+        const [command, ...rest] = args;
+        const context = {
+            workspaceRoot: external_node_path_default().resolve(workspaceRoot),
+            invocationCwd: process.cwd()
+        };
+        switch(command){
+            case void 0:
+            case '--help':
+            case '-h':
+                printHelp();
+                return 0;
+            case 'validate':
+                return runValidate(context);
+            case 'typecheck':
+                return spawnNodeScript("templates/workspace-scripts/ultramodern-typecheck.mjs", rest, context, {
+                    cwd: context.invocationCwd
+                });
+            case 'mf-types':
+                return runMfTypes(rest, context);
+            case 'migrate-strict-effect':
+                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 'skills':
+                return runSkills(rest, context);
+            default:
+                throw new Error(`Unknown UltraModern command: ${command}`);
+        }
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`[ultramodern] ${message}\n`);
+        return 1;
+    }
+}
+exports.runUltramodernToolingCli = __webpack_exports__.runUltramodernToolingCli;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runUltramodernToolingCli"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,172 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    readUltramodernConfig: ()=>readUltramodernConfig,
+    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 bridge_config_cjs_namespaceObject = require("../ultramodern-workspace/bridge-config.cjs");
+const descriptors_cjs_namespaceObject = require("../ultramodern-workspace/descriptors.cjs");
+const naming_cjs_namespaceObject = require("../ultramodern-workspace/naming.cjs");
+function readJsonObject(filePath) {
+    const value = JSON.parse(external_node_fs_default().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 external_node_fs_default().existsSync(filePath) ? readJsonObject(filePath) : {};
+}
+function packageScopeFromRoot(workspaceRoot1) {
+    const rootPackage = readOptionalJsonObject(external_node_path_default().join(workspaceRoot1, 'package.json'));
+    return 'string' == typeof rootPackage.name && rootPackage.name.length > 0 ? rootPackage.name : external_node_path_default().basename(workspaceRoot1);
+}
+function normalizeCompactConfig(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: 'number' == typeof config.schemaVersion ? config.schemaVersion : 1,
+        profile: 'string' == typeof config.profile ? config.profile : void 0,
+        source: 'compact',
+        sourcePath,
+        workspace: {
+            packageScope: 'string' == typeof config.workspace?.packageScope ? config.workspace.packageScope : packageScopeFromRoot(workspaceRoot)
+        },
+        packageSource,
+        features: {
+            tailwind: config.features?.tailwind !== false
+        },
+        bridge: (0, bridge_config_cjs_namespaceObject.normalizeUltramodernBridgeConfig)(config.bridge),
+        topology: {
+            apps: Array.isArray(config.topology?.apps) ? config.topology.apps.map((app)=>({
+                    id: String(app.id),
+                    kind: 'vertical' === app.kind ? 'vertical' : 'shell',
+                    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,
+                    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)
+                        ]
+                    } : void 0
+                })) : []
+        }
+    };
+}
+function readUltramodernConfig(workspaceRoot1 = process.cwd()) {
+    const compactPath = external_node_path_default().join(workspaceRoot1, descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH);
+    if (external_node_fs_default().existsSync(compactPath)) return normalizeCompactConfig(compactPath, readJsonObject(compactPath));
+    throw new Error(`Missing UltraModern config. Expected ${descriptors_cjs_namespaceObject.ULTRAMODERN_CONFIG_PATH}.`);
+}
+function workspaceAppsFromToolingConfig(config) {
+    return config.topology.apps.map((app)=>{
+        if ('shell' === app.kind) return {
+            ...descriptors_cjs_namespaceObject.shellApp,
+            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 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/${(0, naming_cjs_namespaceObject.toKebabCase)(expose.replace(/^\.\//u, ''))}.tsx`;
+            return [
+                expose,
+                configuredPath ?? inferredPath
+            ];
+        }));
+        return {
+            id: app.id,
+            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,
+            mfName: app.moduleFederation?.name ?? app.id,
+            exposes,
+            ...app.moduleFederation?.verticalRefs ? {
+                verticalRefs: app.moduleFederation.verticalRefs
+            } : {},
+            ...app.api ? {
+                api: app.api
+            } : {},
+            ownership: (0, descriptors_cjs_namespaceObject.createNeutralOwnership)(app.id)
+        };
+    });
+}
+exports.readUltramodernConfig = __webpack_exports__.readUltramodernConfig;
+exports.workspaceAppsFromToolingConfig = __webpack_exports__.workspaceAppsFromToolingConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "readUltramodernConfig",
+    "workspaceAppsFromToolingConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});