@bleedingdev/modern-js-create 3.4.0-ultramodern.8 → 3.5.0-ultramodern.0

package/dist/cjs/ultramodern-workspace/mf-validation.cjs

@@ -0,0 +1,571 @@
+"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__, {
+    discoverModuleFederationConfigs: ()=>discoverModuleFederationConfigs,
+    inspectModuleFederationConfigSource: ()=>inspectModuleFederationConfigSource,
+    validateModuleFederationTypes: ()=>validateModuleFederationTypes
+});
+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 moduleFederationConfigFile = 'module-federation.config.ts';
+const mfTypesArchive = 'dist/@mf-types.zip';
+const generatedMetadataPaths = [
+    '.modernjs/ultramodern.json'
+];
+const defaultAppRootDirs = [
+    'apps',
+    'verticals'
+];
+const skippedScanDirs = new Set([
+    '.git',
+    '.modernjs',
+    '.nx',
+    '.turbo',
+    'coverage',
+    'dist',
+    'node_modules'
+]);
+function isRecord(value) {
+    return null !== value && 'object' == typeof value && !Array.isArray(value);
+}
+function toPosixPath(value) {
+    return value.split(external_node_path_default().sep).join('/');
+}
+function normalizeRelativePath(value) {
+    const normalized = value.replace(/\\/g, '/').replace(/^\.\/+/u, '');
+    const trimmed = normalized.replace(/\/+$/u, '');
+    return '' === trimmed ? '.' : trimmed;
+}
+function relativePath(root, target) {
+    return normalizeRelativePath(toPosixPath(external_node_path_default().relative(root, target)));
+}
+function readJsonIfExists(filePath) {
+    if (!external_node_fs_default().existsSync(filePath)) return;
+    return JSON.parse(external_node_fs_default().readFileSync(filePath, 'utf-8'));
+}
+function addMetadataAppDir(value, appDirs, hint = '') {
+    if (!isRecord(value)) return;
+    const pathValue = 'string' == typeof value.path ? value.path : 'string' == typeof value.directory ? value.directory : void 0;
+    const hasModuleFederationDeclaration = isRecord(value.moduleFederation) || 'string' == typeof value.moduleFederationName || 'apps' === hint || 'verticals' === hint || 'remotes' === hint || 'moduleFederation' === hint;
+    if (pathValue && hasModuleFederationDeclaration && !external_node_path_default().isAbsolute(pathValue)) appDirs.add(normalizeRelativePath(pathValue));
+}
+function collectMetadataAppDirs(value, appDirs, hint = '') {
+    if (Array.isArray(value)) {
+        for (const entry of value)collectMetadataAppDirs(entry, appDirs, hint);
+        return;
+    }
+    if (!isRecord(value)) return;
+    addMetadataAppDir(value, appDirs, hint);
+    for (const [key, entry] of Object.entries(value))collectMetadataAppDirs(entry, appDirs, key);
+}
+function literalRootFromPattern(pattern) {
+    const normalized = normalizeRelativePath(pattern);
+    if ('.' === normalized || external_node_path_default().isAbsolute(normalized) || normalized.startsWith('../')) return;
+    const segments = normalized.split('/');
+    const literalSegments = [];
+    for (const segment of segments){
+        if (/[*?[\]{}]/u.test(segment)) break;
+        literalSegments.push(segment);
+    }
+    return literalSegments.length > 0 ? literalSegments.join('/') : void 0;
+}
+function collectBridgeScanRoots(value, roots) {
+    if (Array.isArray(value)) {
+        for (const entry of value)collectBridgeScanRoots(entry, roots);
+        return;
+    }
+    if (!isRecord(value)) return;
+    const workspacePackages = value.bridge;
+    if (isRecord(workspacePackages)) {
+        const entries = workspacePackages.workspacePackages;
+        if (Array.isArray(entries)) {
+            for (const entry of entries)if (isRecord(entry) && 'string' == typeof entry.pattern) {
+                const root = literalRootFromPattern(entry.pattern);
+                if (root) roots.add(root);
+            }
+        }
+    }
+    for (const entry of Object.values(value))collectBridgeScanRoots(entry, roots);
+}
+function readGeneratedMetadata(workspaceRoot) {
+    return generatedMetadataPaths.map((metadataPath)=>readJsonIfExists(external_node_path_default().join(workspaceRoot, metadataPath))).filter((metadata)=>void 0 !== metadata);
+}
+function firstSegment(appDir) {
+    if ('.' === appDir) return;
+    return appDir.split('/')[0];
+}
+function scanForModuleFederationConfigs(workspaceRoot, scanRoot, appDirs) {
+    const absoluteRoot = external_node_path_default().join(workspaceRoot, scanRoot);
+    if (!external_node_fs_default().existsSync(absoluteRoot) || !external_node_fs_default().statSync(absoluteRoot).isDirectory()) return;
+    const visit = (directory)=>{
+        for (const entry of external_node_fs_default().readdirSync(directory, {
+            withFileTypes: true
+        })){
+            if (entry.isDirectory()) {
+                if (!skippedScanDirs.has(entry.name)) visit(external_node_path_default().join(directory, entry.name));
+                continue;
+            }
+            if (entry.isFile() && entry.name === moduleFederationConfigFile) appDirs.add(relativePath(workspaceRoot, directory));
+        }
+    };
+    visit(absoluteRoot);
+}
+function discoverModuleFederationConfigs(options) {
+    const workspaceRoot = external_node_path_default().resolve(options.workspaceRoot);
+    const appDirs = new Set();
+    if (options.appDirs && options.appDirs.length > 0) for (const appDir of options.appDirs)appDirs.add(normalizeRelativePath(appDir));
+    else {
+        const metadata = readGeneratedMetadata(workspaceRoot);
+        const scanRoots = new Set(defaultAppRootDirs);
+        for (const metadataEntry of metadata){
+            collectMetadataAppDirs(metadataEntry, appDirs);
+            collectBridgeScanRoots(metadataEntry, scanRoots);
+        }
+        for (const appDir of appDirs){
+            const segment = firstSegment(appDir);
+            if (segment) scanRoots.add(segment);
+        }
+        if (external_node_fs_default().existsSync(external_node_path_default().join(workspaceRoot, moduleFederationConfigFile))) appDirs.add('.');
+        for (const scanRoot of scanRoots)scanForModuleFederationConfigs(workspaceRoot, scanRoot, appDirs);
+    }
+    return Array.from(appDirs).sort().map((appDir)=>({
+            appDir,
+            configPath: external_node_path_default().join(workspaceRoot, appDir, moduleFederationConfigFile)
+        }));
+}
+function isEscaped(source, index) {
+    let slashCount = 0;
+    for(let cursor = index - 1; cursor >= 0 && '\\' === source[cursor]; cursor -= 1)slashCount += 1;
+    return slashCount % 2 === 1;
+}
+function skipQuoted(source, start, quote) {
+    for(let index = start + 1; index < source.length; index += 1)if (source[index] === quote && !isEscaped(source, index)) return index + 1;
+    return source.length;
+}
+function skipLineComment(source, start) {
+    const newline = source.indexOf('\n', start + 2);
+    return -1 === newline ? source.length : newline + 1;
+}
+function skipBlockComment(source, start) {
+    const close = source.indexOf('*/', start + 2);
+    return -1 === close ? source.length : close + 2;
+}
+function skipTemplateExpression(source, start) {
+    let depth = 1;
+    for(let index = start + 1; index < source.length; index += 1){
+        const char = source[index];
+        const next = source[index + 1];
+        if ("'" === char) {
+            index = skipQuoted(source, index, "'") - 1;
+            continue;
+        }
+        if ('"' === char) {
+            index = skipQuoted(source, index, '"') - 1;
+            continue;
+        }
+        if ('`' === char) {
+            index = skipTemplate(source, index) - 1;
+            continue;
+        }
+        if ('/' === char && '/' === next) {
+            index = skipLineComment(source, index) - 1;
+            continue;
+        }
+        if ('/' === char && '*' === next) {
+            index = skipBlockComment(source, index) - 1;
+            continue;
+        }
+        if ('{' === char) {
+            depth += 1;
+            continue;
+        }
+        if ('}' === char) {
+            depth -= 1;
+            if (0 === depth) return index + 1;
+        }
+    }
+    return source.length;
+}
+function skipTemplate(source, start) {
+    for(let index = start + 1; index < source.length; index += 1){
+        const char = source[index];
+        const next = source[index + 1];
+        if ('`' === char && !isEscaped(source, index)) return index + 1;
+        if ('$' === char && '{' === next && !isEscaped(source, index)) index = skipTemplateExpression(source, index + 1) - 1;
+    }
+    return source.length;
+}
+function skipSyntax(source, index) {
+    const char = source[index];
+    const next = source[index + 1];
+    if ("'" === char) return skipQuoted(source, index, "'");
+    if ('"' === char) return skipQuoted(source, index, '"');
+    if ('`' === char) return skipTemplate(source, index);
+    if ('/' === char && '/' === next) return skipLineComment(source, index);
+    if ('/' === char && '*' === next) return skipBlockComment(source, index);
+    return index;
+}
+function findBalanced(source, start, open, close) {
+    let depth = 1;
+    for(let index = start + 1; index < source.length; index += 1){
+        const skipped = skipSyntax(source, index);
+        if (skipped !== index) {
+            index = skipped - 1;
+            continue;
+        }
+        if (source[index] === open) {
+            depth += 1;
+            continue;
+        }
+        if (source[index] === close) {
+            depth -= 1;
+            if (0 === depth) return index;
+        }
+    }
+}
+function skipWhitespaceAndComments(source, start) {
+    let index = start;
+    while(index < source.length){
+        const char = source[index];
+        const next = source[index + 1];
+        if (/\s/u.test(char ?? '')) {
+            index += 1;
+            continue;
+        }
+        if ('/' === char && '/' === next) {
+            index = skipLineComment(source, index);
+            continue;
+        }
+        if ('/' === char && '*' === next) {
+            index = skipBlockComment(source, index);
+            continue;
+        }
+        break;
+    }
+    return index;
+}
+function hasIdentifierBoundary(source, start, end) {
+    return !/[$\w]/u.test(source[start - 1] ?? '') && !/[$\w]/u.test(source[end] ?? '');
+}
+function findCreateModuleFederationConfigObject(source) {
+    const callee = 'createModuleFederationConfig';
+    let offset = 0;
+    while(offset < source.length){
+        const index = source.indexOf(callee, offset);
+        if (-1 === index) break;
+        offset = index + callee.length;
+        if (!hasIdentifierBoundary(source, index, offset)) continue;
+        const parenIndex = skipWhitespaceAndComments(source, offset);
+        if ('(' !== source[parenIndex]) continue;
+        const argumentIndex = skipWhitespaceAndComments(source, parenIndex + 1);
+        if ('{' !== source[argumentIndex]) throw new Error('Module Federation config must pass a static object literal to createModuleFederationConfig.');
+        const closeIndex = findBalanced(source, argumentIndex, '{', '}');
+        if (void 0 === closeIndex) throw new Error('Module Federation config object literal is not closed.');
+        return source.slice(argumentIndex, closeIndex + 1);
+    }
+}
+function findExportDefaultObject(source) {
+    const exportDefault = 'export default';
+    const index = source.indexOf(exportDefault);
+    if (-1 === index) return;
+    const objectStart = skipWhitespaceAndComments(source, index + exportDefault.length);
+    if ('{' !== source[objectStart]) return;
+    const objectEnd = findBalanced(source, objectStart, '{', '}');
+    if (void 0 === objectEnd) throw new Error('Module Federation export default object is not closed.');
+    return source.slice(objectStart, objectEnd + 1);
+}
+function getOuterBlock(source, open, close) {
+    const trimmed = source.trim();
+    if (trimmed[0] !== open) return;
+    const end = findBalanced(trimmed, 0, open, close);
+    if (void 0 === end) return;
+    const suffix = trimmed.slice(end + 1).trim();
+    if ('' !== suffix && !suffix.startsWith('as ') && !suffix.startsWith('satisfies ')) return;
+    return {
+        inner: trimmed.slice(1, end),
+        suffix
+    };
+}
+function splitTopLevelEntries(source) {
+    const entries = [];
+    let start = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let parenDepth = 0;
+    for(let index = 0; index < source.length; index += 1){
+        const skipped = skipSyntax(source, index);
+        if (skipped !== index) {
+            index = skipped - 1;
+            continue;
+        }
+        const char = source[index];
+        if ('{' === char) braceDepth += 1;
+        else if ('}' === char) braceDepth -= 1;
+        else if ('[' === char) bracketDepth += 1;
+        else if (']' === char) bracketDepth -= 1;
+        else if ('(' === char) parenDepth += 1;
+        else if (')' === char) parenDepth -= 1;
+        else if (',' === char && 0 === braceDepth && 0 === bracketDepth && 0 === parenDepth) {
+            const entry = source.slice(start, index).trim();
+            if (entry) entries.push(entry);
+            start = index + 1;
+        }
+    }
+    const finalEntry = source.slice(start).trim();
+    if (finalEntry) entries.push(finalEntry);
+    return entries;
+}
+function findTopLevelColon(source) {
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let parenDepth = 0;
+    for(let index = 0; index < source.length; index += 1){
+        const skipped = skipSyntax(source, index);
+        if (skipped !== index) {
+            index = skipped - 1;
+            continue;
+        }
+        const char = source[index];
+        if ('{' === char) braceDepth += 1;
+        else if ('}' === char) braceDepth -= 1;
+        else if ('[' === char) bracketDepth += 1;
+        else if (']' === char) bracketDepth -= 1;
+        else if ('(' === char) parenDepth += 1;
+        else if (')' === char) parenDepth -= 1;
+        else if (':' === char && 0 === braceDepth && 0 === bracketDepth && 0 === parenDepth) return index;
+    }
+    return -1;
+}
+function stripConstAssertion(source) {
+    return source.trim().replace(/\s+as\s+const\s*$/u, '').trim();
+}
+function unescapeSingleQuotedString(value) {
+    return value.replace(/\\(['"\\nrtbfv0])/gu, (_, sequence)=>{
+        switch(sequence){
+            case 'n':
+                return '\n';
+            case 'r':
+                return '\r';
+            case 't':
+                return '\t';
+            case 'b':
+                return '\b';
+            case 'f':
+                return '\f';
+            case 'v':
+                return '\v';
+            case '0':
+                return '\0';
+            default:
+                return sequence;
+        }
+    });
+}
+function parseLiteralString(source) {
+    if (void 0 === source) return;
+    const trimmed = stripConstAssertion(source);
+    const quote = trimmed[0];
+    if ("'" !== quote && '"' !== quote && '`' !== quote) return;
+    if ('`' === quote) {
+        if (trimmed.includes('${')) return;
+        const close = trimmed.lastIndexOf('`');
+        return close > 0 ? trimmed.slice(1, close).replaceAll('\\`', '`') : void 0;
+    }
+    const close = trimmed.lastIndexOf(quote);
+    if (close <= 0 || '' !== trimmed.slice(close + 1).trim()) return;
+    const content = trimmed.slice(1, close);
+    if ('"' === quote) try {
+        return JSON.parse(trimmed);
+    } catch  {
+        return;
+    }
+    return unescapeSingleQuotedString(content);
+}
+function parseObjectKey(source) {
+    const trimmed = source.trim();
+    const literal = parseLiteralString(trimmed);
+    if (void 0 !== literal) return literal;
+    return /^[$A-Z_a-z][$\w]*$/u.test(trimmed) ? trimmed : void 0;
+}
+function parseObjectLiteral(source) {
+    if (void 0 === source) return;
+    const block = getOuterBlock(source, '{', '}');
+    if (!block) return;
+    const properties = new Map();
+    let hasSpread = false;
+    for (const entry of splitTopLevelEntries(block.inner)){
+        if (entry.startsWith('...')) {
+            hasSpread = true;
+            continue;
+        }
+        const colon = findTopLevelColon(entry);
+        if (-1 === colon) {
+            hasSpread = true;
+            continue;
+        }
+        const key = parseObjectKey(entry.slice(0, colon));
+        if (void 0 === key) {
+            hasSpread = true;
+            continue;
+        }
+        properties.set(key, entry.slice(colon + 1).trim());
+    }
+    return {
+        hasSpread,
+        properties
+    };
+}
+function parseArrayLiteral(source) {
+    if (void 0 === source) return;
+    const block = getOuterBlock(source, '[', ']');
+    if (!block) return;
+    const entries = splitTopLevelEntries(block.inner);
+    const exposes = [];
+    for (const entry of entries){
+        const expose = parseLiteralString(entry);
+        if (void 0 === expose) return;
+        exposes.push(expose);
+    }
+    return exposes;
+}
+function extractExposes(configPath, value) {
+    if (void 0 === value) return [];
+    const object = parseObjectLiteral(value);
+    if (object) {
+        if (object.hasSpread) throw new Error(`Cannot statically extract Module Federation exposes from ${configPath}; use a literal exposes object without spreads.`);
+        return Array.from(object.properties.keys()).sort();
+    }
+    const array = parseArrayLiteral(value);
+    if (array) return array.sort();
+    throw new Error(`Cannot statically extract Module Federation exposes from ${configPath}; use a literal exposes object or string array.`);
+}
+function extractDtsSettings(configPath, value) {
+    if (void 0 === value) return {};
+    const dts = parseObjectLiteral(value);
+    if (!dts || dts.hasSpread) throw new Error(`Cannot statically extract Module Federation DTS settings from ${configPath}; use a literal dts object.`);
+    const generateTypes = parseObjectLiteral(dts.properties.get('generateTypes'));
+    if (generateTypes?.hasSpread) throw new Error(`Cannot statically extract Module Federation generateTypes settings from ${configPath}; use a literal generateTypes object.`);
+    return {
+        compilerInstance: parseLiteralString(generateTypes?.properties.get('compilerInstance')),
+        tsConfigPath: parseLiteralString(dts.properties.get('tsConfigPath'))
+    };
+}
+function hasHostOnlyNoExposesDeclaration(source) {
+    return /@?ultramodern-mf\s*:?\s*(?:host-only|no-exposes)\b/iu.test(source);
+}
+function inspectModuleFederationConfigSource(source, appDir, configPath) {
+    const configObject = findCreateModuleFederationConfigObject(source) ?? findExportDefaultObject(source);
+    if (!configObject) throw new Error(`Cannot statically inspect Module Federation config ${configPath}; export or pass a literal config object.`);
+    const properties = parseObjectLiteral(configObject);
+    if (!properties) throw new Error(`Cannot statically inspect Module Federation config ${configPath}; expected a literal config object.`);
+    if (properties.hasSpread) throw new Error(`Cannot statically inspect Module Federation config ${configPath}; top-level config spreads are not supported.`);
+    const exposes = extractExposes(configPath, properties.properties.get('exposes'));
+    const hostOnlyNoExposes = hasHostOnlyNoExposesDeclaration(source);
+    if (hostOnlyNoExposes && exposes.length > 0) throw new Error(`Module Federation host-only/no-exposes declaration conflicts with actual exposes in ${configPath}.`);
+    return {
+        appDir,
+        configPath,
+        dts: extractDtsSettings(configPath, properties.properties.get('dts')),
+        exposes,
+        hostOnlyNoExposes
+    };
+}
+function assertExposedAppDtsSettings(app) {
+    if ('tsgo' !== app.dts.compilerInstance) throw new Error(`Module Federation DTS compilerInstance must be "tsgo" for ${app.appDir}.`);
+    if ('./tsconfig.mf-types.json' !== app.dts.tsConfigPath) throw new Error(`Module Federation DTS tsConfigPath must be "./tsconfig.mf-types.json" for ${app.appDir}.`);
+}
+function assertTypesArchive(workspaceRoot, appDir) {
+    const typesArchivePath = external_node_path_default().join(workspaceRoot, appDir, mfTypesArchive);
+    if (!external_node_fs_default().existsSync(typesArchivePath)) throw new Error(`Missing Module Federation DTS archive: ${relativePath(workspaceRoot, typesArchivePath)}`);
+    if (0 === external_node_fs_default().statSync(typesArchivePath).size) throw new Error(`Empty Module Federation DTS archive: ${relativePath(workspaceRoot, typesArchivePath)}`);
+}
+function validateModuleFederationTypes(options) {
+    const workspaceRoot = external_node_path_default().resolve(options.workspaceRoot);
+    const discoveredConfigs = discoverModuleFederationConfigs({
+        ...options,
+        workspaceRoot
+    });
+    const apps = [];
+    const missingConfigPaths = [];
+    for (const discoveredConfig of discoveredConfigs){
+        if (!external_node_fs_default().existsSync(discoveredConfig.configPath)) {
+            missingConfigPaths.push(relativePath(workspaceRoot, discoveredConfig.configPath));
+            continue;
+        }
+        const configPath = relativePath(workspaceRoot, discoveredConfig.configPath);
+        apps.push(inspectModuleFederationConfigSource(external_node_fs_default().readFileSync(discoveredConfig.configPath, 'utf-8'), discoveredConfig.appDir, configPath));
+    }
+    if (missingConfigPaths.length > 0) throw new Error(`Missing Module Federation config: ${missingConfigPaths.join(', ')}`);
+    const noExposeApps = apps.filter((app)=>0 === app.exposes.length && !app.hostOnlyNoExposes);
+    if (noExposeApps.length > 0) {
+        const suffix = 0 === apps.filter((app)=>app.exposes.length > 0).length ? ' Validation would otherwise validate zero exposed apps.' : '';
+        throw new Error(`Module Federation configs declare no exposes without an explicit host-only/no-exposes declaration: ${noExposeApps.map((app)=>app.appDir).join(', ')}.${suffix}`);
+    }
+    let exposedAppCount = 0;
+    let hostOnlyAppCount = 0;
+    for (const app of apps){
+        if (app.hostOnlyNoExposes) {
+            hostOnlyAppCount += 1;
+            continue;
+        }
+        assertExposedAppDtsSettings(app);
+        assertTypesArchive(workspaceRoot, app.appDir);
+        exposedAppCount += 1;
+    }
+    if (apps.length > 0 && 0 === exposedAppCount && hostOnlyAppCount !== apps.length) throw new Error('Module Federation validation inspected configs but validated zero exposed apps. Declare host-only/no-exposes intent only for host apps without exposes.');
+    return {
+        apps,
+        configCount: apps.length,
+        exposedAppCount,
+        hostOnlyAppCount
+    };
+}
+exports.discoverModuleFederationConfigs = __webpack_exports__.discoverModuleFederationConfigs;
+exports.inspectModuleFederationConfigSource = __webpack_exports__.inspectModuleFederationConfigSource;
+exports.validateModuleFederationTypes = __webpack_exports__.validateModuleFederationTypes;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "discoverModuleFederationConfigs",
+    "inspectModuleFederationConfigSource",
+    "validateModuleFederationTypes"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/ultramodern-workspace/module-federation.cjs

@@ -56,19 +56,26 @@ const external_policy_cjs_namespaceObject = require("./policy.cjs");
 const external_types_cjs_namespaceObject = require("./types.cjs");
 const external_versions_cjs_namespaceObject = require("./versions.cjs");
 function createAppModernConfig(scope, app) {
-    const bffImport = (0, external_descriptors_cjs_namespaceObject.appHasEffectApi)(app) ? "import { bffPlugin } from '@modern-js/plugin-bff';\n" : '';
-    const bffConfig = (0, external_descriptors_cjs_namespaceObject.appHasEffectApi)(app) ? `      bff: {
+    const bffImport = (0, external_descriptors_cjs_namespaceObject.appHasApi)(app) ? "import { bffPlugin } from '@modern-js/plugin-bff';\n" : '';
+    const bffConfig = (0, external_descriptors_cjs_namespaceObject.appHasApi)(app) ? `      bff: {
         effect: {
-          entry: './api/effect/index',
+          entry: './api/index',
           openapi: {
             path: '/openapi.json',
           },
+          strictEffectApproach: true,
         },
-        prefix: '${(0, external_descriptors_cjs_namespaceObject.effectApiPrefix)(app)}',
+        prefix: '${(0, external_descriptors_cjs_namespaceObject.resolveApiPrefix)(app)}',
         runtimeFramework: 'effect',
       },
 ` : '';
-    const bffPluginEntry = (0, external_descriptors_cjs_namespaceObject.appHasEffectApi)(app) ? '        bffPlugin(),\n' : '';
+    const bffPluginEntry = (0, external_descriptors_cjs_namespaceObject.appHasApi)(app) ? '        bffPlugin(),\n' : '';
+    const defaultAssetPrefixSource = 'shell' === app.kind ? "const defaultAssetPrefix = '/';" : `const remoteAssetOrigin =
+  configuredCloudflareUrl ||
+  inferredCloudflareUrl ||
+  (cloudflareDeployEnabled ? '/' : \`http://localhost:\${port}\`);
+const defaultRemoteAssetPrefix = \`\${remoteAssetOrigin.replace(/\\/+$/u, '')}/\`;
+const defaultAssetPrefix = defaultRemoteAssetPrefix;`;
     return `// @effect-diagnostics processEnv:off
 import {
   appTools,
@@ -115,6 +122,8 @@ const configuredSiteUrl = envValue('MODERN_PUBLIC_SITE_URL');
 const configuredCloudflareUrl = envValue('${(0, external_descriptors_cjs_namespaceObject.createCloudflarePublicUrlEnv)(app)}');
 const configuredUltramodernAssetPrefix = envValue('ULTRAMODERN_ASSET_PREFIX');
 const configuredModernAssetPrefix = envValue('MODERN_ASSET_PREFIX');
+const moduleFederationDevServerOrigin =
+  envValue('ULTRAMODERN_MF_DEV_ORIGIN') || 'http://localhost:${external_descriptors_cjs_namespaceObject.shellApp.port}';
 const cloudflareWorkersDevSubdomain = envValue(
   'ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN',
 );
@@ -129,12 +138,12 @@ const siteUrl =
   configuredCloudflareUrl ||
   inferredCloudflareUrl ||
   \`http://localhost:\${port}\`;
-// Asset loading is intentionally independent from the canonical site URL and
-// deployment public URL. Without an explicit asset prefix, assets stay
-// origin-relative so self-hosted apps, tunnels, and reverse proxies never leak
-// localhost URLs into production HTML.
+${defaultAssetPrefixSource}
+// Asset loading is intentionally independent from the canonical site URL.
+// Module Federation remotes must publish an absolute publicPath so browsers
+// load remoteEntry.js and exposed chunks from the remote origin, not the host.
 const assetPrefix =
-  configuredModernAssetPrefix || configuredUltramodernAssetPrefix || '/';
+  configuredModernAssetPrefix || configuredUltramodernAssetPrefix || defaultAssetPrefix;
 
 if (
   cloudflareDeployEnabled &&
@@ -200,7 +209,7 @@ ${bffConfig}      ...(cloudflareDeployEnabled
               '/@mf-types',
               '/assets',
               '/bundles',
-              '${(0, external_descriptors_cjs_namespaceObject.effectApiPrefix)(app)}',
+              '${(0, external_descriptors_cjs_namespaceObject.resolveApiPrefix)(app)}',
               '/locales',
               '/mf-manifest.json',
               '/mf-stats.json',
@@ -238,6 +247,9 @@ ${bffPluginEntry}        moduleFederationPlugin(),
         },
         mainEntryName: 'index',
       },
+      splitChunks: {
+        chunks: 'async',
+      },
       tools: {
         autoprefixer: {
           overrideBrowserslist: ['defaults'],
@@ -246,12 +258,14 @@ ${bffPluginEntry}        moduleFederationPlugin(),
           chain.output
             .uniqueName('${(0, external_naming_cjs_namespaceObject.createRspackUniqueName)(app)}')
             .chunkLoadingGlobal('${(0, external_naming_cjs_namespaceObject.createRspackChunkLoadingGlobal)(app)}');
-          chain.ignoreWarnings([
-            {
-              message: /the request of a dependency is an expression/u,
-              module: /modern-js-plugin-i18n/u,
-            },
-          ]);
+        },
+        devServer: {
+          headers: {
+            'Access-Control-Allow-Headers':
+              'Accept, Authorization, Content-Type, X-Requested-With',
+            'Access-Control-Allow-Methods': 'GET, HEAD, OPTIONS',
+            'Access-Control-Allow-Origin': moduleFederationDevServerOrigin,
+          },
         },
       },
     },
@@ -376,6 +390,7 @@ function createShellModuleFederationConfig(scope, remotes = []) {
         verticalRefs: remotes.map((remote)=>remote.id)
     };
     return `// @effect-diagnostics nodeBuiltinImport:off processEnv:off
+// ultramodern-mf: host-only
 import { createRequire } from 'node:module';
 import { createModuleFederationConfig } from '@module-federation/modern-js-v3';
 import { dependencies } from './package.json';
@@ -432,7 +447,7 @@ export const ultramodernUiMarker = {
 
 export const ultramodernApiMarker = {
   ...ultramodernVerticalIdentity,
-  surface: 'effect-bff',
+  surface: 'api',
 } as const;
 `;
 }