@bleedingdev/modern-js-create 3.2.0-ultramodern.120 → 3.2.0-ultramodern.122

package/dist/esm/ultramodern-workspace/fs-io.js

@@ -0,0 +1,90 @@
+import node_crypto from "node:crypto";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveCreatePackageRoot } from "../create-package-root.js";
+import { normalizePath } from "./naming.js";
+const fs_io_dirname = node_path.dirname(fileURLToPath(import.meta.url));
+const createPackageRoot = resolveCreatePackageRoot(fs_io_dirname);
+const workspaceTemplateDir = node_path.join(createPackageRoot, 'template-workspace');
+const fileTemplatesDir = node_path.join(createPackageRoot, 'templates');
+function readFileTemplate(relativePath) {
+    return node_fs.readFileSync(node_path.join(fileTemplatesDir, relativePath), 'utf-8');
+}
+function renderFileTemplate(relativePath, data) {
+    return renderTemplate(readFileTemplate(`${relativePath}.handlebars`), data);
+}
+function assertSafeRelativePath(relativePath) {
+    if (0 === relativePath.length || node_path.isAbsolute(relativePath) || relativePath.split(/[\\/]+/).includes('..')) throw new Error(`Unsafe workspace template path: ${relativePath}`);
+}
+function ensureInsideRoot(root, targetPath) {
+    const relativePath = node_path.relative(root, targetPath);
+    if (relativePath.startsWith('..') || node_path.isAbsolute(relativePath)) throw new Error(`Refusing to write outside workspace root: ${targetPath}`);
+}
+function writeFile(targetDir, relativePath, content) {
+    assertSafeRelativePath(relativePath);
+    const filePath = node_path.join(targetDir, relativePath);
+    ensureInsideRoot(targetDir, filePath);
+    if (node_fs.existsSync(filePath)) throw new Error(`Refusing to overwrite generated workspace file: ${relativePath}`);
+    node_fs.mkdirSync(node_path.dirname(filePath), {
+        recursive: true
+    });
+    node_fs.writeFileSync(filePath, content, 'utf-8');
+}
+function writeFileReplacing(targetDir, relativePath, content) {
+    assertSafeRelativePath(relativePath);
+    const filePath = node_path.join(targetDir, relativePath);
+    ensureInsideRoot(targetDir, filePath);
+    node_fs.mkdirSync(node_path.dirname(filePath), {
+        recursive: true
+    });
+    node_fs.writeFileSync(filePath, content, 'utf-8');
+}
+function writeJson(targetDir, relativePath, value) {
+    writeFile(targetDir, relativePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function renderTemplate(template, data) {
+    return template.replace(/\{\{(\w+)\}\}/g, (match, key)=>data[key] ?? match);
+}
+function collectTemplateFiles(dir) {
+    const files = [];
+    function collect(currentDir) {
+        for (const entry of node_fs.readdirSync(currentDir, {
+            withFileTypes: true
+        }).sort((a, b)=>a.name.localeCompare(b.name))){
+            const entryPath = node_path.join(currentDir, entry.name);
+            if (entry.isDirectory()) collect(entryPath);
+            else if (entry.isFile()) files.push(normalizePath(node_path.relative(dir, entryPath)));
+        }
+    }
+    collect(dir);
+    return files;
+}
+function hashFile(filePath) {
+    return node_crypto.createHash('sha256').update(node_fs.readFileSync(filePath)).digest('hex');
+}
+function hashTemplateTree(dir) {
+    const hash = node_crypto.createHash('sha256');
+    for (const relativePath of collectTemplateFiles(dir)){
+        hash.update(relativePath);
+        hash.update('\0');
+        hash.update(hashFile(node_path.join(dir, relativePath)));
+        hash.update('\0');
+    }
+    return hash.digest('hex');
+}
+function copyRootTemplate(targetDir, data) {
+    for (const relativePath of collectTemplateFiles(workspaceTemplateDir)){
+        const sourcePath = node_path.join(workspaceTemplateDir, relativePath);
+        const outputPath = relativePath.replace(/\.handlebars$/, '');
+        const content = relativePath.endsWith('.handlebars') ? renderTemplate(node_fs.readFileSync(sourcePath, 'utf-8'), data) : node_fs.readFileSync(sourcePath, 'utf-8');
+        writeFile(targetDir, outputPath, content);
+    }
+}
+function readJsonFile(filePath) {
+    return JSON.parse(node_fs.readFileSync(filePath, 'utf-8'));
+}
+function writeJsonFile(filePath, value) {
+    node_fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+}
+export { assertSafeRelativePath, collectTemplateFiles, copyRootTemplate, createPackageRoot, ensureInsideRoot, fileTemplatesDir, hashFile, hashTemplateTree, readFileTemplate, readJsonFile, renderFileTemplate, renderTemplate, workspaceTemplateDir, writeFile, writeFileReplacing, writeJson, writeJsonFile };

package/dist/esm/ultramodern-workspace/index.js

@@ -0,0 +1,3 @@
+export { addUltramodernVertical } from "./add-vertical.js";
+export { ultramodernWorkspaceVersions } from "./versions.js";
+export { generateUltramodernWorkspace } from "./write-workspace.js";

package/dist/esm/ultramodern-workspace/locales.js

@@ -0,0 +1,122 @@
+const commonLocaleMessages = {
+    cs: {
+        language: {
+            cs: 'Čeština',
+            en: 'Angličtina',
+            switcher: 'Jazyk'
+        },
+        routes: {
+            home: 'Domů'
+        },
+        seo: {
+            description: 'Route-owned UltraModern plocha s lokalizovaným SSR a frameworkem řízenými public metadata.'
+        }
+    },
+    en: {
+        language: {
+            cs: 'Czech',
+            en: 'English',
+            switcher: 'Language'
+        },
+        routes: {
+            home: 'Home'
+        },
+        seo: {
+            description: 'Route-owned UltraModern surface with localized SSR and framework-owned public metadata.'
+        }
+    }
+};
+const generatedLocaleResources = {
+    cs: {
+        shell: {
+            boundaries: {
+                toggle: 'zobrazit hranice týmů'
+            },
+            hero: {
+                cardOne: 'Přidejte první business vertical příkazem create <domain> --vertical, až ho opravdu potřebujete.',
+                cardOneKicker: 'Verticaly',
+                cardTwo: 'Plný markup, styly a lokalizovaný obsah se vykreslí před hydratací.',
+                cardTwoKicker: 'Vykreslení',
+                empty: 'Zatím nejsou připojené žádné MicroVerticaly.',
+                eyebrow: 'Shell SuperApp starter',
+                lede: 'Začněte s produkčně připraveným shellem. MicroVerticaly přidávejte až podle skutečných business domén.',
+                primary: 'Shell je připraven',
+                secondary: 'Přidejte vertical, až bude potřeba'
+            },
+            language: commonLocaleMessages.cs.language,
+            remoteUnavailable: 'Remote vertical je nedostupný',
+            remotes: {},
+            routes: {
+                home: commonLocaleMessages.cs.routes.home
+            },
+            seo: {
+                description: 'UltraModern shell SuperApp s lokalizovaným SSR, Module Federation a frameworkem řízenými public metadata.'
+            },
+            title: 'UltraModern Workspace'
+        }
+    },
+    en: {
+        shell: {
+            boundaries: {
+                toggle: 'show team boundaries'
+            },
+            hero: {
+                cardOne: 'Add the first business vertical with create <domain> --vertical when the product needs one.',
+                cardOneKicker: 'Verticals',
+                cardTwo: 'Full page markup, styles, and localized content render before hydration.',
+                cardTwoKicker: 'Rendering',
+                empty: 'No MicroVerticals are connected yet.',
+                eyebrow: 'Shell SuperApp starter',
+                lede: 'Start with a production-ready shell. Add MicroVerticals later for real business domains.',
+                primary: 'Shell ready',
+                secondary: 'Add a vertical when needed'
+            },
+            language: commonLocaleMessages.en.language,
+            remoteUnavailable: 'Remote vertical unavailable',
+            remotes: {},
+            routes: {
+                home: commonLocaleMessages.en.routes.home
+            },
+            seo: {
+                description: 'UltraModern shell SuperApp with localized SSR, Module Federation, and framework-owned public metadata.'
+            },
+            title: 'UltraModern Workspace'
+        }
+    }
+};
+const verticalLocaleCopy = {
+    cs: {
+        federatedSurface: 'Federovaná plocha vlastněná tímto verticalem.',
+        remoteUnavailable: 'Remote vertical je nedostupný',
+        routeSurface: 'Routovaná plocha vlastněná tímto verticalem.',
+        widgetBody: 'Vlastní routovanou plochu verticalu.'
+    },
+    en: {
+        federatedSurface: 'Federated surface owned by this vertical.',
+        remoteUnavailable: 'Remote vertical unavailable',
+        routeSurface: 'Route surface owned by this vertical.',
+        widgetBody: 'Owns a vertical route surface.'
+    }
+};
+const createFallbackLocaleMessages = (app, language)=>({
+        ...commonLocaleMessages[language],
+        federatedSurface: verticalLocaleCopy[language].federatedSurface,
+        remoteUnavailable: verticalLocaleCopy[language].remoteUnavailable,
+        role: app.domain ?? app.kind,
+        routeSurface: verticalLocaleCopy[language].routeSurface,
+        title: app.displayName,
+        widgetBody: verticalLocaleCopy[language].widgetBody
+    });
+function createAppLocaleMessages(app, language) {
+    const domain = app.domain ?? app.id;
+    const messageKey = 'shell' === app.kind ? 'shell' : domain;
+    const messages = 'shell' === app.kind ? generatedLocaleResources[language].shell : createFallbackLocaleMessages(app, language);
+    return {
+        [messageKey]: messages
+    };
+}
+function createAppPublicLocaleMessages(app, language, remotes = []) {
+    if ('shell' !== app.kind) return createAppLocaleMessages(app, language);
+    return Object.assign({}, createAppLocaleMessages(app, language), ...remotes.map((remote)=>createAppLocaleMessages(remote, language)));
+}
+export { commonLocaleMessages, createAppLocaleMessages, createAppPublicLocaleMessages, createFallbackLocaleMessages, generatedLocaleResources };

package/dist/esm/ultramodern-workspace/module-federation.js

@@ -0,0 +1,415 @@
+import node_crypto from "node:crypto";
+import { appHasEffectApi, createCloudflarePublicUrlEnv, createCloudflareWorkerName, createRemoteManifestEnv, effectApiPrefix, remoteDependencyAlias, resolveRemoteRefs, shellApp } from "./descriptors.js";
+import { createRspackChunkLoadingGlobal, createRspackUniqueName, packageName } from "./naming.js";
+import { createCloudflareSecurityContract, formatTsJsonValue } from "./policy.js";
+import { sortJsonValue } from "./types.js";
+import { CLOUDFLARE_COMPATIBILITY_DATE } from "./versions.js";
+function createAppModernConfig(scope, app) {
+    const bffImport = appHasEffectApi(app) ? "import { bffPlugin } from '@modern-js/plugin-bff';\n" : '';
+    const bffConfig = appHasEffectApi(app) ? `      bff: {
+        effect: {
+          entry: './api/effect/index',
+          openapi: {
+            path: '/openapi.json',
+          },
+        },
+        prefix: '${effectApiPrefix(app)}',
+        runtimeFramework: 'effect',
+      },
+` : '';
+    const bffPluginEntry = appHasEffectApi(app) ? '        bffPlugin(),\n' : '';
+    return `// @effect-diagnostics processEnv:off
+import {
+  appTools,
+  defineConfig,
+  presetUltramodern,
+} from '@modern-js/app-tools';
+${bffImport}import { i18nPlugin } from '@modern-js/plugin-i18n';
+import { tanstackRouterPlugin } from '@modern-js/plugin-tanstack';
+import { moduleFederationPlugin } from '@module-federation/modern-js-v3';
+import { withZephyr as withZephyrRspack } from 'zephyr-rspack-plugin';
+import { ultramodernLocalisedUrls } from './src/routes/ultramodern-route-metadata';
+
+type ZephyrRspackConfig = Parameters<ReturnType<typeof withZephyrRspack>>[0];
+
+const zephyrEnabled = process.env['ULTRAMODERN_ZEPHYR'] !== 'false';
+const cloudflareDeployEnabled =
+  process.env['MODERNJS_DEPLOY'] === 'cloudflare';
+
+const zephyrRspackPlugin = () => ({
+  name: 'ultramodern-zephyr-rspack-plugin',
+  pre: ['@modern-js/plugin-module-federation-config'],
+  setup(api: {
+    modifyRspackConfig: (
+      handler: (
+        config: ZephyrRspackConfig,
+      ) => ZephyrRspackConfig | Promise<ZephyrRspackConfig>,
+    ) => void;
+  }) {
+    if (!zephyrEnabled) {
+      return;
+    }
+    api.modifyRspackConfig(config => withZephyrRspack()(config));
+  },
+});
+
+const appId = '${app.id}';
+const cloudflareWorkerName = '${createCloudflareWorkerName(scope, app)}';
+const port = Number(process.env['${app.portEnv}'] ?? ${app.port});
+const envValue = (name: string) => {
+  const value = process.env[name]?.trim();
+  return value !== undefined && value.length > 0 ? value : undefined;
+};
+const configuredSiteUrl = envValue('MODERN_PUBLIC_SITE_URL');
+const configuredCloudflareUrl = envValue('${createCloudflarePublicUrlEnv(app)}');
+const configuredUltramodernAssetPrefix = envValue('ULTRAMODERN_ASSET_PREFIX');
+const configuredModernAssetPrefix = envValue('MODERN_ASSET_PREFIX');
+const cloudflareWorkersDevSubdomain = envValue(
+  'ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN',
+);
+const inferredCloudflareUrl =
+  cloudflareDeployEnabled && cloudflareWorkersDevSubdomain !== undefined
+    ? \`https://\${cloudflareWorkerName}.\${cloudflareWorkersDevSubdomain}.workers.dev\`
+    : undefined;
+// Site origin (SEO: canonical/hreflang URLs) prefers the site-wide public URL;
+// the per-app deployment URL only fills in when no site origin is configured.
+const siteUrl =
+  configuredSiteUrl ||
+  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.
+const assetPrefix =
+  configuredModernAssetPrefix || configuredUltramodernAssetPrefix || '/';
+
+if (
+  cloudflareDeployEnabled &&
+  process.env['ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS'] === 'true' &&
+  configuredCloudflareUrl === undefined &&
+  configuredSiteUrl === undefined &&
+  inferredCloudflareUrl === undefined
+) {
+  throw new Error(
+    \`Cloudflare deploy for \${appId} needs ${createCloudflarePublicUrlEnv(app)}, MODERN_PUBLIC_SITE_URL, or ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN.\`,
+  );
+}
+
+export default defineConfig(
+  presetUltramodern(
+    {
+${bffConfig}      ...(cloudflareDeployEnabled
+        ? {
+            deploy: {
+              worker: {
+                compatibilityDate: '${CLOUDFLARE_COMPATIBILITY_DATE}',
+                name: cloudflareWorkerName,
+                security: ${formatTsJsonValue(sortJsonValue(createCloudflareSecurityContract()), 16)},
+                ssr: true,
+              },
+            },
+          }
+        : {}),
+      dev: {
+        // Keep dev assets origin-relative too; the default absolute
+        // http://localhost:<port> prefix breaks pages served through tunnels.
+        assetPrefix: '/',
+      },
+      html: {
+        outputStructure: 'flat',
+      },
+      output: {
+        assetPrefix,
+        disableTsChecker: true,
+        distPath: {
+          html: './',
+        },
+        polyfill: 'off',
+        splitRouteChunks: true,
+      },
+      performance: {
+        rsdoctor: {
+          disableClientServer: true,
+          enabled: process.env['ULTRAMODERN_RSDOCTOR'] === 'true',
+        },
+      },
+      plugins: [
+        appTools(),
+        tanstackRouterPlugin(),
+        i18nPlugin({
+          backend: {
+            enabled: true,
+            loadPath: '/locales/{{lng}}/{{ns}}.json',
+          },
+          localeDetection: {
+            fallbackLanguage: 'en',
+            ignoreRedirectRoutes: [
+              '/@mf-types',
+              '/assets',
+              '/bundles',
+              '${effectApiPrefix(app)}',
+              '/locales',
+              '/mf-manifest.json',
+              '/mf-stats.json',
+              '/remoteEntry.js',
+              '/robots.txt',
+              '/site.webmanifest',
+              '/sitemap.xml',
+              '/static',
+              '/zephyr-manifest.json',
+            ],
+            languages: ['en', 'cs'],
+            localePathRedirect: true,
+            localisedUrls: ultramodernLocalisedUrls as Record<string, Record<string, string>>,
+          },
+          reactI18next: false,
+        }),
+${bffPluginEntry}        moduleFederationPlugin(),
+        zephyrRspackPlugin(),
+      ],
+      server: {
+        port,
+        publicDir: ['./locales', './assets'],
+        ssr: {
+          mode: 'string',
+          moduleFederationAppSSR: true,
+        },
+      },
+      source: {
+        globalVars: {
+          ULTRAMODERN_SITE_URL: siteUrl,
+        },
+        mainEntryName: 'index',
+      },
+      tools: {
+        autoprefixer: {
+          overrideBrowserslist: ['defaults'],
+        },
+        bundlerChain: chain => {
+          chain.output
+            .uniqueName('${createRspackUniqueName(app)}')
+            .chunkLoadingGlobal('${createRspackChunkLoadingGlobal(app)}');
+          chain.ignoreWarnings([
+            {
+              message: /the request of a dependency is an expression/u,
+              module: /modern-js-plugin-i18n/u,
+            },
+          ]);
+        },
+      },
+    },
+    {
+      appId,
+      enableBffRequestId: true,
+      enableModuleFederationSSR: true,
+      enableTelemetryExporters: true,
+      telemetryFailLoudStartup: false,
+    },
+  ),
+);
+`;
+}
+function createSharedModuleFederationConfig() {
+    return `  shared: {
+    '@modern-js/plugin-i18n/runtime': {
+      requiredVersion: pluginI18nVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+    '@modern-js/plugin-tanstack/runtime': {
+      requiredVersion: pluginTanstackVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+    '@modern-js/runtime': {
+      requiredVersion: runtimeVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+    '@tanstack/react-router': {
+      requiredVersion: dependencies['@tanstack/react-router'],
+      singleton: true,
+      treeShaking: false,
+    },
+    react: {
+      requiredVersion: reactVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+    'react-dom': {
+      requiredVersion: reactDomVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+    'react-dom/client': {
+      requiredVersion: reactDomVersion,
+      singleton: true,
+      treeShaking: false,
+    },
+  }`;
+}
+function formatTsObjectLiteral(value) {
+    const entries = Object.entries(value).sort(([left], [right])=>left.localeCompare(right));
+    if (0 === entries.length) return '{}';
+    return `{
+${entries.map(([key, entryValue])=>`    '${key}': '${entryValue}',`).join('\n')}
+  }`;
+}
+function createModuleFederationRemoteUrlHelpers(app, remotes = []) {
+    if (0 === resolveRemoteRefs(app, remotes).length) return '';
+    return `const cloudflareDeployEnabled =
+  process.env['MODERNJS_DEPLOY'] === 'cloudflare';
+const cloudflareWorkersDevSubdomain =
+  process.env['ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN']?.trim();
+const requireCloudflarePublicUrls =
+  process.env['ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS'] === 'true';
+
+const createRemoteManifestUrl = (options: {
+  manifestEnv: string;
+  mfName: string;
+  port: number;
+  publicUrlEnv: string;
+  workerName: string;
+}) => {
+  const configuredManifest = process.env[options.manifestEnv]?.trim();
+  if (configuredManifest !== undefined && configuredManifest.length > 0) {
+    return configuredManifest;
+  }
+
+  const configuredPublicUrl = process.env[options.publicUrlEnv]?.trim();
+  if (configuredPublicUrl !== undefined && configuredPublicUrl.length > 0) {
+    return \`\${options.mfName}@\${configuredPublicUrl.replace(/\\/+$/u, '')}/mf-manifest.json\`;
+  }
+
+  if (cloudflareDeployEnabled && cloudflareWorkersDevSubdomain !== undefined) {
+    return \`\${options.mfName}@https://\${options.workerName}.\${cloudflareWorkersDevSubdomain}.workers.dev/mf-manifest.json\`;
+  }
+
+  if (cloudflareDeployEnabled && requireCloudflarePublicUrls) {
+    throw new Error(
+      \`Cloudflare deploy needs \${options.publicUrlEnv}, \${options.manifestEnv}, or ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN for remote \${options.mfName}.\`,
+    );
+  }
+
+  return \`\${options.mfName}@http://localhost:\${options.port}/mf-manifest.json\`;
+};
+
+`;
+}
+function createModuleFederationRemotesConfig(scope, app, remotes = []) {
+    const remoteEntries = resolveRemoteRefs(app, remotes).toSorted((left, right)=>remoteDependencyAlias(left).localeCompare(remoteDependencyAlias(right))).map((remote)=>{
+        const key = remoteDependencyAlias(remote);
+        return `    ${key}: createRemoteManifestUrl({
+      manifestEnv: '${createRemoteManifestEnv(remote)}',
+      mfName: '${remote.mfName}',
+      port: ${remote.port},
+      publicUrlEnv: '${createCloudflarePublicUrlEnv(remote)}',
+      workerName: '${createCloudflareWorkerName(scope, remote)}',
+    }),`;
+    }).join('\n');
+    if (!remoteEntries) return '';
+    return `  remotes: {
+${remoteEntries}
+  },
+`;
+}
+function createShellModuleFederationConfig(scope, remotes = []) {
+    const shellHost = {
+        ...shellApp,
+        verticalRefs: remotes.map((remote)=>remote.id)
+    };
+    return `// @effect-diagnostics nodeBuiltinImport:off processEnv:off
+import { createRequire } from 'node:module';
+import { createModuleFederationConfig } from '@module-federation/modern-js-v3';
+import { dependencies } from './package.json';
+
+const require = createRequire(import.meta.url);
+const pluginI18nVersion = (require('@modern-js/plugin-i18n/package.json') as { version: string }).version;
+const pluginTanstackVersion = (require('@modern-js/plugin-tanstack/package.json') as { version: string }).version;
+const runtimeVersion = (require('@modern-js/runtime/package.json') as { version: string }).version;
+const reactVersion = (require('react/package.json') as { version: string }).version;
+const reactDomVersion = (require('react-dom/package.json') as { version: string }).version;
+
+${createModuleFederationRemoteUrlHelpers(shellHost, remotes)}
+export default createModuleFederationConfig({
+  bridge: {
+    enableBridgeRouter: false,
+  },
+  dev: {
+    disableDynamicRemoteTypeHints: true,
+  },
+  dts: {
+    displayErrorInTerminal: true,
+    generateTypes: {
+      compilerInstance: 'tsgo',
+    },
+  },
+  filename: 'remoteEntry.js',
+  name: '${shellApp.mfName}',
+${createModuleFederationRemotesConfig(scope, shellHost, remotes)}${createSharedModuleFederationConfig()},
+  treeShakingSharedExcludePlugins: ['RspackModuleFederationPlugin'],
+});
+`;
+}
+function createBuildMarker(scope, app) {
+    return node_crypto.createHash('sha256').update(`${scope}:${app.packageSuffix}:${app.id}:0.1.0`).digest('hex').slice(0, 16);
+}
+function createUltramodernBuildModule(scope, app) {
+    return `export const ultramodernVerticalIdentity = {
+  appId: '${app.id}',
+  build: '${createBuildMarker(scope, app)}',
+  deployProfile: 'cloudflare-ssr-mf-effect-v1',
+  packageName: '${packageName(scope, app.packageSuffix)}',
+  version: '0.1.0',
+} as const;
+
+export const ultramodernUiMarker = {
+  ...ultramodernVerticalIdentity,
+  surface: 'ui',
+} as const;
+
+export const ultramodernApiMarker = {
+  ...ultramodernVerticalIdentity,
+  surface: 'effect-bff',
+} as const;
+`;
+}
+function createRemoteModuleFederationConfig(scope, app, remotes = []) {
+    const exposes = formatTsObjectLiteral(app.exposes ?? {});
+    return `// @effect-diagnostics nodeBuiltinImport:off
+import { createRequire } from 'node:module';
+import { createModuleFederationConfig } from '@module-federation/modern-js-v3';
+import { dependencies } from './package.json';
+
+const require = createRequire(import.meta.url);
+const pluginI18nVersion = (require('@modern-js/plugin-i18n/package.json') as { version: string }).version;
+const pluginTanstackVersion = (require('@modern-js/plugin-tanstack/package.json') as { version: string }).version;
+const runtimeVersion = (require('@modern-js/runtime/package.json') as { version: string }).version;
+const reactVersion = (require('react/package.json') as { version: string }).version;
+const reactDomVersion = (require('react-dom/package.json') as { version: string }).version;
+
+${createModuleFederationRemoteUrlHelpers(app, remotes)}
+export default createModuleFederationConfig({
+  bridge: {
+    enableBridgeRouter: false,
+  },
+  dev: {
+    disableDynamicRemoteTypeHints: true,
+  },
+  dts: {
+    displayErrorInTerminal: true,
+    generateTypes: {
+      compilerInstance: 'tsgo',
+    },
+  },
+  exposes: ${exposes},
+  filename: 'remoteEntry.js',
+  name: '${app.mfName}',
+${createModuleFederationRemotesConfig(scope, app, remotes)}${createSharedModuleFederationConfig()},
+  treeShakingSharedExcludePlugins: ['RspackModuleFederationPlugin'],
+});
+`;
+}
+export { createAppModernConfig, createBuildMarker, createModuleFederationRemoteUrlHelpers, createModuleFederationRemotesConfig, createRemoteModuleFederationConfig, createSharedModuleFederationConfig, createShellModuleFederationConfig, createUltramodernBuildModule, formatTsObjectLiteral };