@bleedingdev/modern-js-create 3.2.0-ultramodern.31 → 3.2.0-ultramodern.33

package/dist/index.js

@@ -607,6 +607,9 @@ const modernPackageNames = [
     '@modern-js/runtime'
 ];
 const ULTRAMODERN_WORKSPACE_FLAG = '--ultramodern-workspace';
+function isRecord(value) {
+    return null !== value && 'object' == typeof value && !Array.isArray(value);
+}
 const shellApp = {
     id: 'shell-super-app',
     directory: 'apps/shell-super-app',
@@ -617,9 +620,9 @@ const shellApp = {
     port: 3020,
     mfName: 'shellSuperApp',
     remoteRefs: [
-        'remote-commerce',
-        'remote-identity',
-        'remote-design-system'
+        'remote-explore',
+        'remote-decide',
+        'remote-checkout'
     ],
     ownership: {
         team: 'super-app-platform',
@@ -638,104 +641,123 @@ const shellApp = {
 };
 const remoteApps = [
     {
-        id: 'remote-commerce',
-        directory: 'apps/remotes/remote-commerce',
-        packageSuffix: 'remote-commerce',
-        displayName: 'Commerce Remote',
+        id: 'remote-explore',
+        directory: 'apps/remotes/remote-explore',
+        packageSuffix: 'remote-explore',
+        displayName: 'Explore Remote',
         kind: 'vertical',
-        domain: 'commerce',
-        portEnv: 'REMOTE_COMMERCE_PORT',
+        domain: 'explore',
+        portEnv: 'REMOTE_EXPLORE_PORT',
         port: 3021,
-        mfName: 'remoteCommerce',
+        mfName: 'remoteExplore',
         exposes: {
+            './Footer': './src/components/footer.tsx',
+            './Header': './src/components/header.tsx',
+            './Recommendations': './src/components/recommendations.tsx',
             './Route': './src/remote-entry.tsx',
-            './Widget': './src/components/commerce-widget.tsx'
+            './StorePicker': './src/components/store-picker.tsx'
         },
         effectApi: {
-            stem: 'recommendations',
-            prefix: '/commerce-api',
+            stem: 'explore',
+            prefix: '/explore-api',
             consumedBy: [
                 shellApp.id,
-                'remote-commerce'
+                'remote-explore'
             ]
         },
         ownership: {
-            team: 'commerce-experience',
-            slack: '#commerce-experience',
-            pagerDuty: 'pd-commerce-experience',
-            runbookRef: 'runbooks/wave2/remote-commerce.md',
-            adrRef: 'docs/super-app-rfc-adr/wave2/reference-topology.md#remote-commerce',
+            team: 'tractor-explore',
+            slack: '#tractor-explore',
+            pagerDuty: 'pd-tractor-explore',
+            runbookRef: 'runbooks/wave2/remote-explore.md',
+            adrRef: 'docs/super-app-rfc-adr/wave2/reference-topology.md#remote-explore',
             blastRadius: {
-                tier: 'tier-1-revenue-path',
+                tier: 'tier-1-tractor-discovery',
                 references: [
-                    'docs/super-app-rfc-adr/wave2/blast-radius.md#commerce',
-                    'docs/super-app-rfc-adr/wave2/rollback.md#commerce-lkg'
+                    'docs/super-app-rfc-adr/wave2/blast-radius.md#explore',
+                    'docs/super-app-rfc-adr/wave2/rollback.md#explore-lkg'
                 ]
             }
         }
     },
     {
-        id: 'remote-identity',
-        directory: 'apps/remotes/remote-identity',
-        packageSuffix: 'remote-identity',
-        displayName: 'Identity Remote',
+        id: 'remote-decide',
+        directory: 'apps/remotes/remote-decide',
+        packageSuffix: 'remote-decide',
+        displayName: 'Decide Remote',
         kind: 'vertical',
-        domain: 'identity',
-        portEnv: 'REMOTE_IDENTITY_PORT',
+        domain: 'decide',
+        portEnv: 'REMOTE_DECIDE_PORT',
         port: 3022,
-        mfName: 'remoteIdentity',
+        mfName: 'remoteDecide',
+        remoteRefs: [
+            'remote-explore',
+            'remote-checkout'
+        ],
         exposes: {
-            './Route': './src/remote-entry.tsx',
-            './Widget': './src/components/identity-widget.tsx'
+            './ProductPage': './src/components/product-page.tsx',
+            './Route': './src/remote-entry.tsx'
         },
         effectApi: {
-            stem: 'identity',
-            prefix: '/identity-api',
+            stem: 'decide',
+            prefix: '/decide-api',
             consumedBy: [
                 shellApp.id,
-                'remote-identity'
+                'remote-decide'
             ]
         },
         ownership: {
-            team: 'identity-platform',
-            slack: '#identity-platform',
-            pagerDuty: 'pd-identity-platform',
-            runbookRef: 'runbooks/wave2/remote-identity.md',
-            adrRef: 'docs/super-app-rfc-adr/wave2/reference-topology.md#remote-identity',
+            team: 'tractor-decide',
+            slack: '#tractor-decide',
+            pagerDuty: 'pd-tractor-decide',
+            runbookRef: 'runbooks/wave2/remote-decide.md',
+            adrRef: 'docs/super-app-rfc-adr/wave2/reference-topology.md#remote-decide',
             blastRadius: {
-                tier: 'tier-0-authentication',
+                tier: 'tier-1-tractor-configuration',
                 references: [
-                    'docs/super-app-rfc-adr/wave2/blast-radius.md#identity',
-                    'docs/super-app-rfc-adr/wave2/rollback.md#identity-lkg'
+                    'docs/super-app-rfc-adr/wave2/blast-radius.md#decide',
+                    'docs/super-app-rfc-adr/wave2/rollback.md#decide-lkg'
                 ]
             }
         }
     },
     {
-        id: 'remote-design-system',
-        directory: 'apps/remotes/remote-design-system',
-        packageSuffix: 'remote-design-system',
-        displayName: 'Design System Remote',
-        kind: 'horizontal-design-system',
-        domain: 'design-system',
-        portEnv: 'REMOTE_DESIGN_SYSTEM_PORT',
+        id: 'remote-checkout',
+        directory: 'apps/remotes/remote-checkout',
+        packageSuffix: 'remote-checkout',
+        displayName: 'Checkout Remote',
+        kind: 'vertical',
+        domain: 'checkout',
+        portEnv: 'REMOTE_CHECKOUT_PORT',
         port: 3023,
-        mfName: 'remoteDesignSystem',
+        mfName: 'remoteCheckout',
         exposes: {
-            './Button': './src/components/button.tsx',
-            './tokens': './src/tokens.ts'
+            './AddToCart': './src/components/add-to-cart.tsx',
+            './CartPage': './src/components/cart-page.tsx',
+            './CheckoutPage': './src/components/checkout-page.tsx',
+            './MiniCart': './src/components/mini-cart.tsx',
+            './Route': './src/remote-entry.tsx',
+            './ThanksPage': './src/components/thanks-page.tsx'
+        },
+        effectApi: {
+            stem: 'checkout',
+            prefix: '/checkout-api',
+            consumedBy: [
+                shellApp.id,
+                'remote-checkout'
+            ]
         },
         ownership: {
-            team: 'design-platform',
-            slack: '#design-platform',
-            pagerDuty: 'pd-design-platform',
-            runbookRef: 'runbooks/wave2/remote-design-system.md',
-            adrRef: 'docs/super-app-rfc-adr/wave2/reference-topology.md#remote-design-system',
+            team: 'tractor-checkout',
+            slack: '#tractor-checkout',
+            pagerDuty: 'pd-tractor-checkout',
+            runbookRef: 'runbooks/wave2/remote-checkout.md',
+            adrRef: 'docs/super-app-rfc-adr/wave2/reference-topology.md#remote-checkout',
             blastRadius: {
-                tier: 'tier-0-shared-ui',
+                tier: 'tier-1-tractor-purchase',
                 references: [
-                    'docs/super-app-rfc-adr/wave2/blast-radius.md#design-system',
-                    'docs/super-app-rfc-adr/wave2/rollback.md#design-system-pins'
+                    'docs/super-app-rfc-adr/wave2/blast-radius.md#checkout',
+                    'docs/super-app-rfc-adr/wave2/rollback.md#checkout-lkg'
                 ]
             }
         }
@@ -1100,11 +1122,11 @@ function createRootPackageJson(scope, packageSource) {
         type: 'module',
         packageManager: `pnpm@${PNPM_VERSION}`,
         scripts: {
-            dev: `pnpm --parallel --filter ${ultramodern_workspace_packageName(scope, shellApp.packageSuffix)} --filter ${ultramodern_workspace_packageName(scope, 'remote-commerce')} --filter ${ultramodern_workspace_packageName(scope, 'remote-identity')} --filter ${ultramodern_workspace_packageName(scope, 'remote-design-system')} dev`,
+            dev: `pnpm --parallel --filter ${ultramodern_workspace_packageName(scope, shellApp.packageSuffix)} --filter ${ultramodern_workspace_packageName(scope, 'remote-explore')} --filter ${ultramodern_workspace_packageName(scope, 'remote-decide')} --filter ${ultramodern_workspace_packageName(scope, 'remote-checkout')} dev`,
             'dev:shell': `pnpm --filter ${ultramodern_workspace_packageName(scope, shellApp.packageSuffix)} dev`,
-            'dev:commerce': `pnpm --filter ${ultramodern_workspace_packageName(scope, 'remote-commerce')} dev`,
-            'dev:identity': `pnpm --filter ${ultramodern_workspace_packageName(scope, 'remote-identity')} dev`,
-            'dev:design-system': `pnpm --filter ${ultramodern_workspace_packageName(scope, 'remote-design-system')} dev`,
+            'dev:explore': `pnpm --filter ${ultramodern_workspace_packageName(scope, 'remote-explore')} dev`,
+            'dev:decide': `pnpm --filter ${ultramodern_workspace_packageName(scope, 'remote-decide')} dev`,
+            'dev:checkout': `pnpm --filter ${ultramodern_workspace_packageName(scope, 'remote-checkout')} dev`,
             build: 'pnpm -r --filter "./apps/remotes/**" run build && pnpm --filter "./apps/shell-super-app" run build && pnpm ultramodern:assert-mf-types',
             format: 'oxfmt .',
             'format:check': 'oxfmt --check .',
@@ -1112,6 +1134,8 @@ function createRootPackageJson(scope, packageSource) {
             'lint:fix': 'oxlint . --fix',
             typecheck: `pnpm -r --filter "@${scope}/*" typecheck`,
             'cloudflare:build': 'pnpm -r --filter "./apps/remotes/**" run cloudflare:build && pnpm --filter "./apps/shell-super-app" run cloudflare:build && pnpm ultramodern:assert-mf-types',
+            'cloudflare:deploy': 'pnpm -r --filter "./apps/remotes/**" run cloudflare:deploy && pnpm --filter "./apps/shell-super-app" run cloudflare:deploy',
+            'cloudflare:proof': "node ./scripts/proof-cloudflare-version.mjs --out .codex/reports/cloudflare-version-proof/public-url-proof.json",
             'skills:install': "node ./scripts/bootstrap-agent-skills.mjs",
             'skills:check': "node ./scripts/bootstrap-agent-skills.mjs --check",
             'agents:refs:install': "node ./scripts/setup-agent-reference-repos.mjs",
@@ -1158,13 +1182,61 @@ function remoteDependencyAlias(remote) {
 function zephyrRemoteDependency(scope, remote) {
     return `${ultramodern_workspace_packageName(scope, remote.packageSuffix)}@workspace:*`;
 }
+function resolveRemoteRefs(app, remotes = remoteApps) {
+    const remoteRefs = app.remoteRefs ?? [];
+    return remoteRefs.map((remoteRef)=>remotes.find((remote)=>remote.id === remoteRef)).filter((remote)=>void 0 !== remote);
+}
+function createModuleFederationRemoteContracts(app, remotes = remoteApps) {
+    return resolveRemoteRefs(app, remotes).map((remote)=>({
+            id: remote.id,
+            alias: remoteDependencyAlias(remote),
+            name: remote.mfName,
+            manifestEnv: createRemoteManifestEnv(remote),
+            manifestUrl: `http://localhost:${remote.port}/mf-manifest.json`
+        }));
+}
 function createZephyrDependencies(scope, app, remotes = remoteApps) {
-    if ('shell' !== app.kind) return {};
-    return Object.fromEntries(remotes.map((remote)=>[
+    if (!app.remoteRefs?.length) return {};
+    return Object.fromEntries(resolveRemoteRefs(app, remotes).map((remote)=>[
             remoteDependencyAlias(remote),
             zephyrRemoteDependency(scope, remote)
         ]));
 }
+function createCloudflareWorkerName(scope, app) {
+    return toKebabCase(`${scope}-${app.packageSuffix}`).slice(0, 63);
+}
+function createCloudflarePublicUrlEnv(app) {
+    return `ULTRAMODERN_PUBLIC_URL_${toEnvSegment(app.id)}`;
+}
+function createCloudflareProofRoute(app) {
+    const languageRoutes = createLocalisedUrlsMap(app);
+    const firstCanonicalPath = Object.keys(languageRoutes)[0];
+    const localizedPath = firstCanonicalPath && isRecord(languageRoutes[firstCanonicalPath]) ? languageRoutes[firstCanonicalPath].en : void 0;
+    return {
+        ssr: localizedPath ?? '/en',
+        mfManifest: '/mf-manifest.json',
+        locale: `/locales/en/${appI18nNamespace(app)}.json`,
+        ...appHasEffectApi(app) ? {
+            effectReadiness: `${effectApiPrefix(app)}/effect/${effectApiStem(app)}/readiness`
+        } : {}
+    };
+}
+function createCloudflareDeployContract(scope, app) {
+    return {
+        target: 'cloudflare',
+        workerName: createCloudflareWorkerName(scope, app),
+        publicUrlEnv: createCloudflarePublicUrlEnv(app),
+        compatibilityFlags: [
+            'nodejs_compat'
+        ],
+        assetsBinding: 'ASSETS',
+        routes: createCloudflareProofRoute(app),
+        evidence: {
+            proofScript: "scripts/proof-cloudflare-version.mjs",
+            reportDefault: '.codex/reports/cloudflare-version-proof/public-url-proof.json'
+        }
+    };
+}
 function createTsConfigBase() {
     return {
         compilerOptions: {
@@ -1234,7 +1306,9 @@ function createAppPackage(scope, app, packageSource, enableTailwind) {
             dev: 'modern dev',
             build: app.exposes ? `modern build && node ${relativeRootFor(app.directory)}/scripts/assert-mf-types.mjs` : 'modern build',
             'cloudflare:build': 'MODERNJS_DEPLOY=cloudflare modern build && MODERNJS_DEPLOY=cloudflare modern deploy',
+            'cloudflare:deploy': 'MODERNJS_DEPLOY=cloudflare modern deploy',
             'cloudflare:preview': 'MODERNJS_DEPLOY=cloudflare modern build && MODERNJS_DEPLOY=cloudflare modern deploy && wrangler dev --config .output/wrangler.json',
+            'cloudflare:proof': `node ${relativeRootFor(app.directory)}/scripts/proof-cloudflare-version.mjs --app ${app.id}`,
             serve: 'modern serve',
             typecheck: effectTsgoTypecheckCommand
         },
@@ -1255,6 +1329,9 @@ function createAppPackage(scope, app, packageSource, enableTailwind) {
         './effect/client': `./src/effect/${app.effectApi.stem}-client.ts`,
         './shared/effect/api': './shared/effect/api.ts'
     };
+    else if ('shell' === app.kind) packageJson.exports = {
+        './effect/clients': './src/effect/recommendations-client.ts'
+    };
     return packageJson;
 }
 function createServicePackage(scope, packageSource, enableTailwind, service = effectService) {
@@ -1315,12 +1392,16 @@ function createSharedPackage(scope, id, description, packageSource) {
             "@typescript/native-preview": TYPESCRIPT_NATIVE_PREVIEW_VERSION
         }
     };
+    if ('shared-design-tokens' === id) packageJson.exports = {
+        ...packageJson.exports,
+        './tokens.css': './src/tokens.css'
+    };
     if ('shared-effect-api' === id) packageJson.dependencies = {
         '@modern-js/plugin-bff': modernPackageSpecifier('@modern-js/plugin-bff', packageSource)
     };
     return packageJson;
 }
-function createAppModernConfig(app) {
+function createAppModernConfig(scope, app) {
     const bffImport = appHasEffectApi(app) ? "import { bffPlugin } from '@modern-js/plugin-bff';\n" : '';
     const bffConfig = appHasEffectApi(app) ? `      bff: {
         effect: {
@@ -1343,6 +1424,7 @@ ${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];
 
@@ -1361,22 +1443,12 @@ const zephyrRspackPlugin = () => ({
 });
 
 const appId = '${app.id}';
+const cloudflareWorkerName = '${createCloudflareWorkerName(scope, app)}';
 const port = Number(process.env['${app.portEnv}'] ?? ${app.port});
-const configuredSiteUrl = process.env['MODERN_PUBLIC_SITE_URL'];
-const hasConfiguredSiteUrl =
-  typeof configuredSiteUrl === 'string' && configuredSiteUrl.length > 0;
-const isProductionBuild =
-  process.env['NODE_ENV'] === 'production' || process.argv.includes('build');
-
-if (isProductionBuild && !hasConfiguredSiteUrl) {
-  throw new Error(
-    'MODERN_PUBLIC_SITE_URL must be set for production builds so canonical and hreflang URLs use the deployed origin.',
-  );
-}
-
-const siteUrl = hasConfiguredSiteUrl
-  ? configuredSiteUrl
-  : \`http://localhost:\${port}\`;
+const siteUrl =
+  process.env['MODERN_PUBLIC_SITE_URL'] ??
+  process.env['${createCloudflarePublicUrlEnv(app)}'] ??
+  \`http://localhost:\${port}\`;
 
 export default defineConfig(
   presetUltramodern(
@@ -1403,13 +1475,14 @@ ${bffConfig}      output: {
         tanstackRouterPlugin(),
         i18nPlugin({
           backend: {
-            enabled: false,
+            enabled: true,
           },
           reactI18next: false,
           localeDetection: {
             fallbackLanguage: 'en',
             languages: ['en', 'cs'],
             localePathRedirect: true,
+            localisedUrls: ultramodernLocalisedUrls as Record<string, Record<string, string>>,
             ignoreRedirectRoutes: [
               '/@mf-types',
               '/bundles',
@@ -1442,6 +1515,7 @@ ${bffPluginEntry}        moduleFederationPlugin(),
       deploy: {
         target: 'cloudflare',
         worker: {
+          name: cloudflareWorkerName,
           ssr: true,
         },
       },
@@ -1510,13 +1584,24 @@ ${entries.map(([key, entryValue])=>`    '${key}': '${entryValue}',`).join('\n')}
 function createRemoteManifestEnv(remote) {
     return `REMOTE_${toEnvSegment(remote.domain ?? remote.id)}_MF_MANIFEST`;
 }
-function createShellModuleFederationConfig(remotes = remoteApps) {
-    const remoteEntries = remotes.map((remote)=>{
+function createModuleFederationRemotesConfig(app, remotes = remoteApps) {
+    const remoteEntries = resolveRemoteRefs(app, remotes).map((remote)=>{
         const key = remoteDependencyAlias(remote);
         return `    ${key}:
       process.env['${createRemoteManifestEnv(remote)}'] ??
       '${remote.mfName}@http://localhost:${remote.port}/mf-manifest.json',`;
     }).join('\n');
+    if (!remoteEntries) return '';
+    return `  remotes: {
+${remoteEntries}
+  },
+`;
+}
+function createShellModuleFederationConfig(remotes = remoteApps) {
+    const shellHost = {
+        ...shellApp,
+        remoteRefs: 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';
@@ -1540,10 +1625,7 @@ export default createModuleFederationConfig({
   },
   filename: 'remoteEntry.js',
   name: '${shellApp.mfName}',
-  remotes: {
-${remoteEntries}
-  },
-${createSharedModuleFederationConfig()},
+${createModuleFederationRemotesConfig(shellHost, remotes)}${createSharedModuleFederationConfig()},
 });
 `;
 }
@@ -1570,7 +1652,7 @@ export const ultramodernApiMarker = {
 } as const;
 `;
 }
-function createRemoteModuleFederationConfig(app) {
+function createRemoteModuleFederationConfig(app, remotes = remoteApps) {
     const exposes = formatTsObjectLiteral(app.exposes ?? {});
     return `// @effect-diagnostics nodeBuiltinImport:off
 import { createRequire } from 'node:module';
@@ -1596,12 +1678,248 @@ export default createModuleFederationConfig({
   exposes: ${exposes},
   filename: 'remoteEntry.js',
   name: '${app.mfName}',
-${createSharedModuleFederationConfig()},
+${createModuleFederationRemotesConfig(app, remotes)}${createSharedModuleFederationConfig()},
 });
 `;
 }
-function remoteWidgetFile(app) {
-    return `${app.domain ?? app.id.replace(/^remote-/, '')}-widget`;
+function appI18nNamespace(app) {
+    return 'shell' === app.kind ? 'shell' : app.domain ?? app.id;
+}
+function createRouteOwnedI18nPaths(app) {
+    const namespace = appI18nNamespace(app);
+    const base = {
+        mfBoundaryId: app.mfName,
+        namespace,
+        ownerAppId: app.id
+    };
+    if ('shell' === app.kind) return [
+        {
+            ...base,
+            canonicalPath: '/',
+            id: 'shell-home',
+            localisedPaths: {
+                cs: '/',
+                en: '/'
+            },
+            titleKey: 'shell.title'
+        }
+    ];
+    if ('explore' === app.domain) return [
+        {
+            ...base,
+            canonicalPath: '/',
+            id: 'explore-home',
+            localisedPaths: {
+                cs: '/',
+                en: '/'
+            },
+            titleKey: 'explore.title'
+        },
+        {
+            ...base,
+            canonicalPath: '/tractors',
+            id: 'explore-listing',
+            localisedPaths: {
+                cs: '/traktory',
+                en: '/tractors'
+            },
+            titleKey: 'explore.routes.listing'
+        },
+        {
+            ...base,
+            canonicalPath: '/stores',
+            id: 'explore-store-picker',
+            localisedPaths: {
+                cs: '/prodejci',
+                en: '/stores'
+            },
+            titleKey: 'explore.routes.storePicker'
+        },
+        {
+            ...base,
+            canonicalPath: '/unavailable',
+            id: 'explore-unavailable',
+            localisedPaths: {
+                cs: '/nedostupne',
+                en: '/unavailable'
+            },
+            titleKey: 'explore.routes.unavailable'
+        }
+    ];
+    if ('decide' === app.domain) return [
+        {
+            ...base,
+            canonicalPath: '/',
+            id: 'decide-home',
+            localisedPaths: {
+                cs: '/',
+                en: '/'
+            },
+            titleKey: 'decide.title'
+        },
+        {
+            ...base,
+            canonicalPath: '/tractors',
+            id: 'decide-listing-parent',
+            localisedPaths: {
+                cs: '/traktory',
+                en: '/tractors'
+            },
+            titleKey: 'decide.routes.listing'
+        },
+        {
+            ...base,
+            canonicalPath: '/tractors/:slug',
+            id: 'decide-product-detail',
+            localisedPaths: {
+                cs: '/traktory/:slug',
+                en: '/tractors/:slug'
+            },
+            titleKey: 'decide.routes.productDetail'
+        },
+        {
+            ...base,
+            canonicalPath: '/unavailable',
+            id: 'decide-unavailable',
+            localisedPaths: {
+                cs: '/nedostupne',
+                en: '/unavailable'
+            },
+            titleKey: 'decide.routes.unavailable'
+        }
+    ];
+    if ('checkout' === app.domain) return [
+        {
+            ...base,
+            canonicalPath: '/',
+            id: 'checkout-home',
+            localisedPaths: {
+                cs: '/',
+                en: '/'
+            },
+            titleKey: 'checkout.title'
+        },
+        {
+            ...base,
+            canonicalPath: '/cart',
+            id: 'checkout-cart',
+            localisedPaths: {
+                cs: '/kosik',
+                en: '/cart'
+            },
+            titleKey: 'checkout.routes.cart'
+        },
+        {
+            ...base,
+            canonicalPath: '/checkout',
+            id: 'checkout-start',
+            localisedPaths: {
+                cs: '/pokladna',
+                en: '/checkout'
+            },
+            titleKey: 'checkout.routes.checkout'
+        },
+        {
+            ...base,
+            canonicalPath: '/checkout/thank-you',
+            id: 'checkout-thank-you-parent',
+            localisedPaths: {
+                cs: '/pokladna/dekujeme',
+                en: '/checkout/thank-you'
+            },
+            titleKey: 'checkout.routes.thankYou'
+        },
+        {
+            ...base,
+            canonicalPath: '/checkout/thank-you/:orderId?',
+            id: 'checkout-thank-you',
+            localisedPaths: {
+                cs: '/pokladna/dekujeme/:orderId?',
+                en: '/checkout/thank-you/:orderId?'
+            },
+            titleKey: 'checkout.routes.thankYou'
+        },
+        {
+            ...base,
+            canonicalPath: '/unavailable',
+            id: 'checkout-unavailable',
+            localisedPaths: {
+                cs: '/nedostupne',
+                en: '/unavailable'
+            },
+            titleKey: 'checkout.routes.unavailable'
+        }
+    ];
+    return [
+        {
+            ...base,
+            canonicalPath: '/',
+            id: `${app.id}-home`,
+            localisedPaths: {
+                cs: '/',
+                en: '/'
+            },
+            titleKey: `${namespace}.title`
+        }
+    ];
+}
+function createLocalisedUrlsMap(app) {
+    return Object.fromEntries(createRouteOwnedI18nPaths(app).filter((route)=>'/' !== route.canonicalPath).map((route)=>[
+            route.canonicalPath,
+            route.localisedPaths
+        ]));
+}
+function createRouteMetadataModule(app) {
+    const routes = createRouteOwnedI18nPaths(app);
+    const localisedUrls = createLocalisedUrlsMap(app);
+    const namespace = appI18nNamespace(app);
+    return `export const ultramodernRouteNamespace = '${namespace}' as const;
+
+export const ultramodernRouteMetadata = ${JSON.stringify(routes, null, 2)} as const;
+
+export const ultramodernLocalisedUrls = ${JSON.stringify(localisedUrls, null, 2)} as const;
+
+export const ultramodernRouteConfig = {
+  source: 'route-owned',
+  namespace: ultramodernRouteNamespace,
+  localisedUrls: ultramodernLocalisedUrls,
+  routes: ultramodernRouteMetadata,
+} as const;
+`;
+}
+function routeSegmentToDirectory(segment) {
+    if (segment.startsWith(':')) {
+        const name = segment.slice(1).replace(/\?$/u, '');
+        return segment.endsWith('?') ? `[${name}$]` : `[${name}]`;
+    }
+    return segment;
+}
+function createRoutePageFilePath(app, canonicalPath) {
+    const segments = canonicalPath.split('/').filter(Boolean).map(routeSegmentToDirectory);
+    return `${app.directory}/src/routes/[lang]/${[
+        ...segments,
+        'page.tsx'
+    ].join('/')}`;
+}
+function createRouteAliasPage(canonicalPath) {
+    const depth = canonicalPath.split('/').filter(Boolean).length;
+    const rootPageImport = `${'../'.repeat(depth)}page`;
+    return `export { default } from '${rootPageImport}';
+`;
+}
+function createAppEnvDts(app, remotes = remoteApps) {
+    const remoteModuleDeclarations = resolveRemoteRefs(app, remotes).flatMap((remote)=>Object.keys(remote.exposes ?? {}).filter((expose)=>'./Route' !== expose).map((expose)=>{
+            const moduleName = `${remoteDependencyAlias(remote)}/${expose.replace(/^\.\//u, '')}`;
+            return `declare module '${moduleName}' {
+  const Component: import('react').ComponentType<Record<string, never>>;
+  export default Component;
+}
+`;
+        })).join('\n');
+    return `/// <reference types='@modern-js/app-tools/types' />
+
+declare const ULTRAMODERN_SITE_URL: string;
+${remoteModuleDeclarations ? `\n${remoteModuleDeclarations}` : ''}`;
 }
 function createServiceModernConfigFor(service = effectService) {
     return `// @effect-diagnostics processEnv:off
@@ -1639,16 +1957,20 @@ export default defineConfig(
 `;
 }
 function createAppRuntimeConfig(app) {
+    const namespace = appI18nNamespace(app);
     const resources = {
         cs: {
+            [namespace]: createAppLocaleMessages(app, 'cs'),
             translation: createAppLocaleMessages(app, 'cs')
         },
         en: {
+            [namespace]: createAppLocaleMessages(app, 'en'),
             translation: createAppLocaleMessages(app, 'en')
         }
     };
     return `import { defineRuntimeConfig } from '@modern-js/runtime';
 import { createInstance } from 'i18next';
+import { ultramodernRouteNamespace } from './routes/ultramodern-route-metadata';
 
 const i18nInstance = createInstance();
 
@@ -1656,12 +1978,12 @@ export default defineRuntimeConfig({
   i18n: {
     i18nInstance,
     initOptions: {
-      defaultNS: 'translation',
+      defaultNS: ultramodernRouteNamespace,
       fallbackLng: 'en',
       interpolation: {
         escapeValue: false,
       },
-      ns: ['translation'],
+      ns: [ultramodernRouteNamespace, 'translation'],
       resources: ${JSON.stringify(resources, null, 8).split('\n').join('\n      ')},
       supportedLngs: ['en', 'cs'],
     },
@@ -1672,10 +1994,16 @@ export default defineRuntimeConfig({
 });
 `;
 }
-function createAppStyles(enableTailwind) {
-    return `${enableTailwind ? "@import 'tailwindcss';\n\n" : ''}:root {
-  color: #10231c;
-  background: #f1eadc;
+function createCssTokenImport(scope) {
+    return `@import '${ultramodern_workspace_packageName(scope, 'shared-design-tokens')}/tokens.css';\n`;
+}
+function createShellStyles(enableTailwind, scope) {
+    return `${enableTailwind ? "@import 'tailwindcss';\n" : ''}${createCssTokenImport(scope)}
+
+@layer ultramodern-shell-base {
+:root {
+  color: var(--um-color-foreground);
+  background: var(--um-color-canvas);
   font-family:
     Geist,
     Inter,
@@ -1703,9 +2031,52 @@ nav {
 }
 
 a {
-  color: #166b4b;
+  color: var(--um-color-link);
+}
+}
+
+@layer ultramodern-shell-overlay {
+.boundary-overlay {
+  inset: 0;
+  pointer-events: none;
+  position: fixed;
+  z-index: 70;
+}
+
+.boundary-overlay__box {
+  border: 0.0625rem solid var(--boundary-color);
+  border-radius: 0.55rem;
+  box-shadow:
+    0 0 0 0.0625rem rgba(255, 255, 255, 0.72),
+    0 0.35rem 1.25rem color-mix(in srgb, var(--boundary-color) 20%, transparent);
+  position: fixed;
+}
+
+.boundary-overlay__label {
+  background: color-mix(in srgb, var(--boundary-color) 88%, white);
+  border-radius: 999px;
+  color: #0b0a08;
+  font-size: 0.7rem;
+  font-weight: 850;
+  line-height: 1;
+  padding: 0.3rem 0.55rem;
+  position: absolute;
+  right: 0.35rem;
+  top: 0.35rem;
+  white-space: nowrap;
+}
+
+.boundary-overlay__box[data-label-placement="above"] .boundary-overlay__label {
+  bottom: calc(100% + 0.25rem);
+  top: auto;
 }
+}
+`;
+}
+function createRemoteStyles(enableTailwind, scope, app) {
+    if ('commerce' === app.domain) return `${enableTailwind ? "@import 'tailwindcss';\n" : ''}${createCssTokenImport(scope)}
 
+@layer ultramodern-remote-${app.domain} {
 .commerce-shell {
   background: #f1eadc;
   color: #0b0a08;
@@ -1933,41 +2304,6 @@ a {
   width: 1rem;
 }
 
-.boundary-overlay {
-  inset: 0;
-  pointer-events: none;
-  position: fixed;
-  z-index: 70;
-}
-
-.boundary-overlay__box {
-  border: 0.0625rem solid var(--boundary-color);
-  border-radius: 0.55rem;
-  box-shadow:
-    0 0 0 0.0625rem rgba(255, 255, 255, 0.72),
-    0 0.35rem 1.25rem color-mix(in srgb, var(--boundary-color) 20%, transparent);
-  position: fixed;
-}
-
-.boundary-overlay__label {
-  background: color-mix(in srgb, var(--boundary-color) 88%, white);
-  border-radius: 999px;
-  color: #0b0a08;
-  font-size: 0.7rem;
-  font-weight: 850;
-  line-height: 1;
-  padding: 0.3rem 0.55rem;
-  position: absolute;
-  right: 0.35rem;
-  top: 0.35rem;
-  white-space: nowrap;
-}
-
-.boundary-overlay__box[data-label-placement="above"] .boundary-overlay__label {
-  bottom: calc(100% + 0.25rem);
-  top: auto;
-}
-
 @media (max-width: 860px) {
   .commerce-header,
   .commerce-footer,
@@ -1987,8 +2323,78 @@ a {
     min-height: 20rem;
   }
 }
+}
+`;
+    return `${enableTailwind ? "@import 'tailwindcss';\n" : ''}${createCssTokenImport(scope)}
+
+@layer ultramodern-remote-${app.domain ?? app.id} {
+[data-app-id="${app.id}"] {
+  color: var(--um-color-foreground);
+  background: var(--um-color-surface);
+  font-family:
+    Geist,
+    Inter,
+    ui-sans-serif,
+    system-ui,
+    -apple-system,
+    BlinkMacSystemFont,
+    "Segoe UI",
+    sans-serif;
+  min-height: 100vh;
+}
+
+[data-app-id="${app.id}"] main {
+  min-height: 100vh;
+  padding: 2rem;
+}
+
+[data-app-id="${app.id}"] nav {
+  display: flex;
+  gap: 0.75rem;
+  margin-bottom: 2rem;
+}
+
+[data-app-id="${app.id}"] a {
+  color: var(--um-color-link);
+}
+
+[data-mf-remote="${app.id}"] {
+  border: 0.0625rem solid color-mix(in srgb, var(--um-color-accent) 30%, transparent);
+  border-radius: 0.5rem;
+  padding: 1rem;
+}
+}
+`;
+}
+function createServiceStyles(enableTailwind, scope, service) {
+    return `${enableTailwind ? "@import 'tailwindcss';\n" : ''}${createCssTokenImport(scope)}
+
+@layer ultramodern-effect-service {
+[data-app-id="${service.id}"] {
+  color: var(--um-color-foreground);
+  background: var(--um-color-surface);
+  font-family:
+    Geist,
+    Inter,
+    ui-sans-serif,
+    system-ui,
+    -apple-system,
+    BlinkMacSystemFont,
+    "Segoe UI",
+    sans-serif;
+  min-height: 100vh;
+}
+
+[data-app-id="${service.id}"] main {
+  min-height: 100vh;
+  padding: 2rem;
+}
+}
 `;
 }
+function createAppStyles(enableTailwind, scope, app) {
+    return 'shell' === app.kind ? createShellStyles(enableTailwind, scope) : createRemoteStyles(enableTailwind, scope, app);
+}
 function createPostcssConfig() {
     return `export default {
   plugins: {
@@ -2010,57 +2416,177 @@ function createLocalizedHeadComponent() {
 const supportedLanguages = ['en', 'cs'] as const;
 type SupportedLanguage = (typeof supportedLanguages)[number];
 
-const localizedPath = (language: SupportedLanguage) => \`/\${language}\`;
+const localisedUrls = ultramodernLocalisedUrls as Record<
+  string,
+  Record<SupportedLanguage, string>
+>;
 
-const absoluteUrl = (pathname: string) => {
-  const origin = ULTRAMODERN_SITE_URL.replace(/\\/+$/u, '');
-  return \`\${origin}\${pathname}\`;
+const isSupportedLanguage = (value: string): value is SupportedLanguage =>
+  supportedLanguages.includes(value as SupportedLanguage);
+
+const normalisePath = (pathname: string) => {
+  const normalised = pathname.replace(/\\/+$/u, '').replace(/\\/+/gu, '/');
+  return normalised.length > 0 ? normalised : '/';
 };
-const LocalizedHead = () => {
-  const canonicalPath = localizedPath(fallbackLanguage);
 
-  return (
-    <>
-      <link rel="canonical" href={absoluteUrl(canonicalPath)} />
-      {supportedLanguages.map(code => (
-        <link
-          href={absoluteUrl(localizedPath(code))}
-          hrefLang={code}
-          key={code}
-          rel="alternate"
-        />
-      ))}
-      <link
-        href={absoluteUrl(localizedPath(fallbackLanguage))}
-        hrefLang="x-default"
-        rel="alternate"
-      />
-    </>
-  );
+const stripLanguagePrefix = (pathname: string) => {
+  const segments = normalisePath(pathname).split('/').filter(Boolean);
+  if (segments.length > 0 && isSupportedLanguage(segments[0] ?? '')) {
+    segments.shift();
+  }
+  return \`/\${segments.join('/')}\`;
 };
-`;
-}
-function createShellPage() {
-    return `import { useModernI18n } from '@modern-js/plugin-i18n/runtime';
-import { ultramodernUiMarker } from '../../ultramodern-build';
 
-const languageCodes = ['en', 'cs'] as const;
+const escapeRegExp = (value: string) =>
+  value.replace(/[.*+?^\${}()|[\\]\\\\]/g, '\\\\$&');
 
-const remoteKeys = ['commerce', 'identity', 'designSystem'] as const;
+const paramName = (segment: string) => segment.slice(1).replace(/\\?$/u, '');
 
-${createLocalizedHeadComponent()}
-export default function ShellHome() {
-  const { i18nInstance, language } = useModernI18n();
-  const t = i18nInstance.t.bind(i18nInstance);
+const matchPattern = (pathname: string, pattern: string) => {
+  const names: string[] = [];
+  const source = normalisePath(pattern)
+    .split('/')
+    .filter(Boolean)
+    .map(segment => {
+      if (segment.startsWith(':')) {
+        names.push(paramName(segment));
+        return segment.endsWith('?') ? '(?:/([^/]+))?' : '/([^/]+)';
+      }
+      return \`/\${escapeRegExp(segment)}\`;
+    })
+    .join('');
+  const match = new RegExp(\`^\${source || '/'}$\`).exec(normalisePath(pathname));
 
-  return (
-    <main>
+  if (!match) {
+    return undefined;
+  }
+
+  return names.reduce<Record<string, string>>((params, name, index) => {
+    params[name] = decodeURIComponent(match[index + 1] ?? '');
+    return params;
+  }, {});
+};
+
+const buildPath = (pattern: string, params: Record<string, string>) => {
+  const path = normalisePath(pattern)
+    .split('/')
+    .filter(Boolean)
+    .map(segment => {
+      if (!segment.startsWith(':')) {
+        return segment;
+      }
+      const value = params[paramName(segment)];
+      return value ? encodeURIComponent(value) : '';
+    })
+    .filter(Boolean)
+    .join('/');
+
+  return \`/\${path}\`;
+};
+
+const resolveLocalisedPath = (
+  pathname: string,
+  targetLanguage: SupportedLanguage,
+) => {
+  const pathWithoutLanguage = stripLanguagePrefix(pathname);
+
+  for (const entry of Object.values(localisedUrls)) {
+    const targetPattern = entry[targetLanguage];
+    if (!targetPattern) {
+      continue;
+    }
+
+    for (const language of supportedLanguages) {
+      const sourcePattern = entry[language];
+      const params = sourcePattern
+        ? matchPattern(pathWithoutLanguage, sourcePattern)
+        : undefined;
+      if (params) {
+        return buildPath(targetPattern, params);
+      }
+    }
+  }
+
+  return pathWithoutLanguage;
+};
+
+const localizedPath = (pathname: string, language: SupportedLanguage) => {
+  const pathWithoutLanguage = resolveLocalisedPath(pathname, language);
+  return pathWithoutLanguage === '/' ? \`/\${language}\` : \`/\${language}\${pathWithoutLanguage}\`;
+};
+
+const absoluteUrl = (pathname: string) => {
+  const origin = ULTRAMODERN_SITE_URL.replace(/\\/+$/u, '');
+  return \`\${origin}\${pathname}\`;
+};
+
+const locationSuffix = (location: {
+  hash?: unknown;
+  search?: unknown;
+  searchStr?: unknown;
+}) => {
+  const locationSearch =
+    typeof location.searchStr === 'string'
+      ? location.searchStr
+      : typeof location.search === 'string'
+        ? location.search
+        : '';
+  const locationHash = typeof location.hash === 'string' ? location.hash : '';
+
+  return \`\${locationSearch}\${locationHash}\`;
+};
+
+const LocalizedHead = () => {
+  const location = useLocation();
+  const canonicalPath = localizedPath(location.pathname, fallbackLanguage);
+
+  return (
+    <Helmet>
+      <link rel="canonical" href={absoluteUrl(canonicalPath)} />
+      {supportedLanguages.map(code => (
+        <link
+          href={absoluteUrl(localizedPath(location.pathname, code))}
+          hrefLang={code}
+          key={code}
+          rel="alternate"
+        />
+      ))}
+      <link
+        href={absoluteUrl(localizedPath(location.pathname, fallbackLanguage))}
+        hrefLang="x-default"
+        rel="alternate"
+      />
+    </Helmet>
+  );
+};
+`;
+}
+function createShellPage() {
+    return `import { useModernI18n } from '@modern-js/plugin-i18n/runtime';
+import { Helmet } from '@modern-js/runtime/head';
+import { useLocation } from '@modern-js/plugin-tanstack/runtime';
+import { ultramodernLocalisedUrls } from '../ultramodern-route-metadata';
+import { ultramodernUiMarker } from '../../ultramodern-build';
+
+const languageCodes = ['en', 'cs'] as const;
+
+const remoteKeys = ['explore', 'decide', 'checkout'] as const;
+
+${createLocalizedHeadComponent()}
+export default function ShellHome() {
+  const { i18nInstance, language } = useModernI18n();
+  const t = i18nInstance.t.bind(i18nInstance);
+  const location = useLocation();
+  const suffix = locationSuffix(location);
+
+  return (
+    <main>
       <LocalizedHead />
       <nav aria-label={t('shell.language.switcher')}>
         {languageCodes.map(code => (
           <a
             aria-current={language === code ? 'page' : undefined}
-            href={\`/\${code}\`}
+            href={\`\${localizedPath(location.pathname, code)}\${suffix}\`}
             key={code}
           >
             {t(\`shell.language.\${code}\`)}
@@ -2083,11 +2609,13 @@ export default function ShellHome() {
 `;
 }
 function createRemotePage(app) {
-    if ('remote-commerce' === app.id) return createCommerceRemotePage(app);
     const effectBffImport = appHasEffectApi(app) ? `import { useModernI18n } from '@modern-js/plugin-i18n/runtime';
+import { Helmet } from '@modern-js/runtime/head';
+import { useLocation } from '@modern-js/plugin-tanstack/runtime';
 import { useEffect, useState } from 'react';
+import { ultramodernLocalisedUrls } from '../ultramodern-route-metadata';
 import { ultramodernUiMarker } from '../../ultramodern-build';
-` : "import { useModernI18n } from '@modern-js/plugin-i18n/runtime';\nimport { ultramodernUiMarker } from '../../ultramodern-build';\n";
+` : "import { useModernI18n } from '@modern-js/plugin-i18n/runtime';\nimport { Helmet } from '@modern-js/runtime/head';\nimport { useLocation } from '@modern-js/plugin-tanstack/runtime';\nimport { ultramodernLocalisedUrls } from '../ultramodern-route-metadata';\nimport { ultramodernUiMarker } from '../../ultramodern-build';\n";
     const effectBffState = appHasEffectApi(app) ? `  const [effectApiStatus, setEffectApiStatus] = useState('pending');
 
   useEffect(() => {
@@ -2119,6 +2647,8 @@ ${createLocalizedHeadComponent()}
 export default function ${toPascalCase(app.id)}Home() {
   const { i18nInstance, language } = useModernI18n();
   const t = i18nInstance.t.bind(i18nInstance);
+  const location = useLocation();
+  const suffix = locationSuffix(location);
 ${effectBffState}  return (
     <main>
       <LocalizedHead />
@@ -2126,7 +2656,7 @@ ${effectBffState}  return (
         {supportedLanguages.map(code => (
           <a
             aria-current={language === code ? 'page' : undefined}
-            href={\`/\${code}\`}
+            href={\`\${localizedPath(location.pathname, code)}\${suffix}\`}
             key={code}
           >
             {t(\`${app.domain}.language.\${code}\`)}
@@ -2143,399 +2673,6 @@ ${effectBffMarkup}    </main>
 }
 `;
 }
-function createCommerceRemotePage(app) {
-    return `import { useModernI18n } from '@modern-js/plugin-i18n/runtime';
-import { useEffect, useState, type CSSProperties } from 'react';
-import { ultramodernUiMarker } from '../../ultramodern-build';
-
-const languageCodes = ['en', 'cs'] as const;
-
-const boundaryDefinitions = [
-  {
-    color: '#ff5a57',
-    id: 'explore',
-    labelKey: 'commerce.boundaries.explore',
-  },
-  {
-    color: '#24d671',
-    id: 'decide',
-    labelKey: 'commerce.boundaries.decide',
-  },
-  {
-    color: '#f4d044',
-    id: 'checkout',
-    labelKey: 'commerce.boundaries.checkout',
-  },
-] as const;
-
-type BoundaryId = (typeof boundaryDefinitions)[number]['id'];
-type BoundaryDefinition = (typeof boundaryDefinitions)[number];
-
-const boundaryMetadata: Record<BoundaryId, BoundaryDefinition> = {
-  checkout: boundaryDefinitions[2],
-  decide: boundaryDefinitions[1],
-  explore: boundaryDefinitions[0],
-};
-
-const products = [
-  {
-    id: 'field-loader-112',
-    titleKey: 'commerce.products.fieldLoader.title',
-    descriptionKey: 'commerce.products.fieldLoader.description',
-    priceKey: 'commerce.products.fieldLoader.price',
-    powerKey: 'commerce.products.fieldLoader.power',
-    availabilityKey: 'commerce.products.fieldLoader.availability',
-  },
-  {
-    id: 'orchard-tractor',
-    titleKey: 'commerce.products.orchard.title',
-    badgeKey: 'commerce.products.orchard.badge',
-  },
-  {
-    id: 'autonomy-kit',
-    titleKey: 'commerce.products.autonomy.title',
-    badgeKey: 'commerce.products.autonomy.badge',
-  },
-] as const;
-
-type ProductId = (typeof products)[number]['id'];
-type CartState = Partial<Record<ProductId, number>>;
-
-type BoundaryLabels = Record<BoundaryId, string>;
-type BoundaryBox = {
-  color: string;
-  height: number;
-  id: BoundaryId;
-  label: string;
-  labelPlacement: 'above' | 'inside';
-  left: number;
-  top: number;
-  width: number;
-};
-
-const featuredProduct = products[0];
-const recommendations = [products[1], products[2]] as const;
-
-${createLocalizedHeadComponent()}
-const isBoundaryId = (value: string): value is BoundaryId =>
-  Object.prototype.hasOwnProperty.call(boundaryMetadata, value);
-
-function collectBoundaryBoxes(labels: BoundaryLabels): BoundaryBox[] {
-  return Array.from(
-    document.querySelectorAll<HTMLElement>('[data-boundary], [data-boundary-page]'),
-  )
-    .map(element => {
-      const id = element.dataset.boundary ?? element.dataset.boundaryPage;
-
-      if (id === undefined || !isBoundaryId(id)) {
-        return undefined;
-      }
-
-      const rect = element.getBoundingClientRect();
-
-      if (rect.width <= 0 || rect.height <= 0) {
-        return undefined;
-      }
-
-      return {
-        color: boundaryMetadata[id].color,
-        height: rect.height,
-        id,
-        label: labels[id],
-        labelPlacement: rect.top > 28 ? 'above' : 'inside',
-        left: rect.left,
-        top: rect.top,
-        width: rect.width,
-      };
-    })
-    .filter((box): box is BoundaryBox => box !== undefined);
-}
-
-function BoundaryOverlay({
-  labels,
-  visible,
-}: {
-  labels: BoundaryLabels;
-  visible: boolean;
-}) {
-  const [boxes, setBoxes] = useState<BoundaryBox[]>([]);
-
-  useEffect(() => {
-    if (!visible) {
-      setBoxes([]);
-      return;
-    }
-
-    let animationFrame = 0;
-    const update = () => {
-      cancelAnimationFrame(animationFrame);
-      animationFrame = requestAnimationFrame(() => {
-        setBoxes(collectBoundaryBoxes(labels));
-      });
-    };
-    const observer = new ResizeObserver(update);
-
-    observer.observe(document.body);
-    update();
-    window.addEventListener('resize', update);
-    window.addEventListener('scroll', update, true);
-
-    return () => {
-      cancelAnimationFrame(animationFrame);
-      observer.disconnect();
-      window.removeEventListener('resize', update);
-      window.removeEventListener('scroll', update, true);
-    };
-  }, [labels, visible]);
-
-  if (!visible) {
-    return null;
-  }
-
-  return (
-    <div aria-hidden="true" className="boundary-overlay">
-      {boxes.map((box, index) => (
-        <div
-          className="boundary-overlay__box"
-          data-boundary-id={box.id}
-          data-label-placement={box.labelPlacement}
-          key={\`\${box.id}-\${index}\`}
-          style={{
-            '--boundary-color': box.color,
-            height: box.height,
-            left: box.left,
-            top: box.top,
-            width: box.width,
-          } as CSSProperties}
-        >
-          <span className="boundary-overlay__label">{box.label}</span>
-        </div>
-      ))}
-    </div>
-  );
-}
-
-export default function ${toPascalCase(app.id)}Home() {
-  const { i18nInstance, language } = useModernI18n();
-  const t = i18nInstance.t.bind(i18nInstance);
-  const [cart, setCart] = useState<CartState>({});
-  const [showBoundaries, setShowBoundaries] = useState(false);
-  const [effectApiStatus, setEffectApiStatus] = useState('pending');
-  const boundaryLabels = {
-    checkout: t('commerce.boundaries.checkout'),
-    decide: t('commerce.boundaries.decide'),
-    explore: t('commerce.boundaries.explore'),
-  } satisfies BoundaryLabels;
-  const cartLines = products
-    .map(product => ({
-      product,
-      quantity: cart[product.id] ?? 0,
-    }))
-    .filter(line => line.quantity > 0);
-  const cartCount = cartLines.reduce((total, line) => total + line.quantity, 0);
-
-  useEffect(() => {
-    void fetch('${effectApiPrefix(app)}/effect/${effectApiStem(app)}?limit=1', {
-      headers: {
-        accept: 'application/json',
-      },
-    })
-      .then(response => {
-        if (!response.ok) {
-          throw new Error(\`Effect BFF request failed: \${response.status}\`);
-        }
-
-        return response.json() as Promise<{ items?: Array<{ title?: string }> }>;
-      })
-      .then(data => {
-        setEffectApiStatus(data.items[0]?.title ?? 'empty');
-      })
-      .catch(() => {
-        setEffectApiStatus('unavailable');
-      });
-  }, []);
-
-  const addToCart = (id: ProductId) => {
-    setCart(current => ({
-      ...current,
-      [id]: (current[id] ?? 0) + 1,
-    }));
-  };
-
-  const reduceQuantity = (id: ProductId) => {
-    setCart(current => {
-      const quantity = current[id] ?? 0;
-      const next = { ...current };
-
-      if (quantity <= 1) {
-        delete next[id];
-      } else {
-        next[id] = quantity - 1;
-      }
-
-      return next;
-    });
-  };
-
-  const removeFromCart = (id: ProductId) => {
-    setCart(current => {
-      const next = { ...current };
-
-      delete next[id];
-      return next;
-    });
-  };
-
-  return (
-    <main className="commerce-shell">
-      <LocalizedHead />
-      <BoundaryOverlay labels={boundaryLabels} visible={showBoundaries} />
-      <header className="commerce-header" data-boundary="explore">
-        <strong className="commerce-logo">{t('commerce.brand')}</strong>
-        <nav aria-label={t('commerce.navigation.primary')} className="commerce-nav">
-          <a className="commerce-pill" href="#machines">
-            {t('commerce.navigation.machines')}
-          </a>
-          <a className="commerce-pill" href="#checkout">
-            {t('commerce.navigation.checkout')}
-          </a>
-        </nav>
-        <div className="commerce-actions">
-          <a className="commerce-cart-button" data-boundary="checkout" href="#cart">
-            {t('commerce.cart.button', { count: cartCount })}
-          </a>
-          <nav aria-label={t('commerce.language.switcher')} className="commerce-language">
-            {languageCodes.map(code => (
-              <a
-                aria-current={language === code ? 'page' : undefined}
-                className="commerce-pill"
-                href={\`/\${code}\`}
-                key={code}
-              >
-                {t(\`commerce.language.\${code}\`)}
-              </a>
-            ))}
-          </nav>
-        </div>
-      </header>
-
-      <div className="commerce-page">
-        <section className="commerce-product" data-boundary-page="decide" id="machines">
-          <div
-            aria-label={t('commerce.products.fieldLoader.imageAlt')}
-            className="commerce-product-media"
-            role="img"
-          />
-          <div>
-            <p className="commerce-eyebrow">{t('commerce.detail.eyebrow')}</p>
-            <h1 className="commerce-title">{t(featuredProduct.titleKey)}</h1>
-            <p className="commerce-lede">{t(featuredProduct.descriptionKey)}</p>
-            <div className="commerce-facts">
-              <div className="commerce-fact">
-                <span>{t('commerce.detail.price')}</span>
-                <strong>{t(featuredProduct.priceKey)}</strong>
-              </div>
-              <div className="commerce-fact">
-                <span>{t('commerce.detail.power')}</span>
-                <strong>{t(featuredProduct.powerKey)}</strong>
-              </div>
-              <div className="commerce-fact">
-                <span>{t('commerce.detail.availability')}</span>
-                <strong>{t(featuredProduct.availabilityKey)}</strong>
-              </div>
-            </div>
-            <div className="commerce-checkout" data-boundary="checkout" id="checkout">
-              <button
-                className="commerce-button"
-                onClick={() => addToCart(featuredProduct.id)}
-                type="button"
-              >
-                {t('commerce.cart.add')}
-              </button>
-              <a className="commerce-link-button" href="#cart">
-                {t('commerce.cart.view')}
-              </a>
-            </div>
-          </div>
-        </section>
-
-        <section data-boundary="explore">
-          <h2 className="commerce-section-title">{t('commerce.recommendations.title')}</h2>
-          <div className="commerce-grid">
-            {recommendations.map(product => (
-              <article className="commerce-card" key={product.id}>
-                <span>{t(product.badgeKey)}</span>
-                <strong>{t(product.titleKey)}</strong>
-              </article>
-            ))}
-          </div>
-        </section>
-
-        <section className="commerce-cart-panel" data-boundary="checkout" id="cart">
-          <h2>{t('commerce.cart.title')}</h2>
-          {cartLines.length === 0 ? (
-            <p>{t('commerce.cart.empty')}</p>
-          ) : (
-            cartLines.map(line => (
-              <div className="commerce-cart-line" key={line.product.id}>
-                <strong>{t(line.product.titleKey)}</strong>
-                <div className="commerce-quantity">
-                  <button
-                    aria-label={t('commerce.cart.decrease', {
-                      name: t(line.product.titleKey),
-                    })}
-                    className="commerce-quantity-button"
-                    onClick={() => reduceQuantity(line.product.id)}
-                    type="button"
-                  >
-                    -
-                  </button>
-                  <span>{line.quantity}</span>
-                  <button
-                    aria-label={t('commerce.cart.increase', {
-                      name: t(line.product.titleKey),
-                    })}
-                    className="commerce-quantity-button"
-                    onClick={() => addToCart(line.product.id)}
-                    type="button"
-                  >
-                    +
-                  </button>
-                  <button
-                    className="commerce-link-button"
-                    onClick={() => removeFromCart(line.product.id)}
-                    type="button"
-                  >
-                    {t('commerce.cart.remove')}
-                  </button>
-                </div>
-              </div>
-            ))
-          )}
-        </section>
-      </div>
-
-      <footer className="commerce-footer" data-boundary="explore">
-        <span>{t('commerce.footer.stack')}</span>
-        <span data-testid="effect-bff-status">{effectApiStatus}</span>
-        <span data-build-marker={ultramodernUiMarker.build} data-testid="ultramodern-ui-marker">
-          {ultramodernUiMarker.appId}:{ultramodernUiMarker.version}
-        </span>
-      </footer>
-
-      <label className="commerce-boundary-toggle">
-        <input
-          checked={showBoundaries}
-          onChange={event => setShowBoundaries(event.currentTarget.checked)}
-          type="checkbox"
-        />
-        {t('commerce.boundaries.toggle')}
-      </label>
-    </main>
-  );
-}
-`;
-}
 function createLayout(appId) {
     return `import { Outlet } from '@modern-js/plugin-tanstack/runtime';
 import './index.css';
@@ -2550,7 +2687,18 @@ export default function Layout() {
 `;
 }
 function createRemoteEntry(app) {
-    return `export { default } from './components/${remoteWidgetFile(app)}';
+    if (app.exposes?.['./ProductPage']) return `export { default } from './components/product-page';
+`;
+    if (app.exposes?.['./CartPage']) return `export { default } from './components/cart-page';
+`;
+    return `export default function ${toPascalCase(app.domain ?? app.id)}Route() {
+  return (
+    <section data-mf-remote="${app.id}" data-mf-expose="./Route">
+      <h2>${app.displayName}</h2>
+      <p>Route surface for ${app.domain ?? app.id}.</p>
+    </section>
+  );
+}
 `;
 }
 function createRemoteWidget(app) {
@@ -2566,16 +2714,57 @@ function createRemoteWidget(app) {
 }
 `;
 }
+function createRemoteExposeComponent(app, expose) {
+    if ('./Widget' === expose) return createRemoteWidget(app);
+    const componentName = `${toPascalCase(app.domain ?? app.id)}${toPascalCase(expose.replace(/^\.\//u, ''))}`;
+    if ('remote-decide' === app.id && './ProductPage' === expose) return `import AddToCart from 'checkout/AddToCart';
+import Recommendations from 'explore/Recommendations';
+
+export default function ${componentName}() {
+  return (
+    <section data-mf-remote="${app.id}" data-mf-expose="${expose}">
+      <p>Decide owns tractor product selection.</p>
+      <h2>Field Loader 112</h2>
+      <p>Hydraulic-ready compact tractor with guided implement matching.</p>
+      <AddToCart />
+      <Recommendations />
+    </section>
+  );
+}
+`;
+    return `export default function ${componentName}() {
+  return (
+    <section data-mf-remote="${app.id}" data-mf-expose="${expose}">
+      <h2>${app.displayName} ${expose.replace(/^\.\//u, '')}</h2>
+      <p>Module Federation surface owned by ${app.ownership.team}.</p>
+    </section>
+  );
+}
+`;
+}
+function remoteComponentOutputPath(app, expose) {
+    const exposePath = app.exposes?.[expose];
+    if (!exposePath?.startsWith('./src/components/')) return;
+    return `${app.directory}/${exposePath.replace(/^\.\//u, '')}`;
+}
 function createAppLocaleMessages(app, language) {
     const czechLabels = {
-        commerce: {
-            role: 'obchod',
-            title: 'Obchodní remote'
+        checkout: {
+            role: 'pokladna',
+            title: 'Pokladní remote'
+        },
+        decide: {
+            role: 'rozhodování',
+            title: 'Rozhodovací remote'
         },
         'design-system': {
             role: 'design system',
             title: 'Design system remote'
         },
+        explore: {
+            role: 'procházení',
+            title: 'Průzkumný remote'
+        },
         identity: {
             role: 'identita',
             title: 'Identitní remote'
@@ -2589,9 +2778,12 @@ function createAppLocaleMessages(app, language) {
                 switcher: 'en' === language ? 'Language' : 'Jazyk'
             },
             remotes: {
-                commerce: 'en' === language ? 'Commerce Remote' : 'Obchodní remote',
-                designSystem: 'en' === language ? 'Design System Remote' : 'Design system remote',
-                identity: 'en' === language ? 'Identity Remote' : 'Identitní remote'
+                checkout: 'en' === language ? 'Checkout Remote' : 'Checkout remote',
+                decide: 'en' === language ? 'Decide Remote' : 'Decide remote',
+                explore: 'en' === language ? 'Explore Remote' : 'Explore remote'
+            },
+            routes: {
+                home: 'en' === language ? 'Home' : 'Domů'
             },
             title: 'en' === language ? 'UltraModern SuperApp Shell' : 'UltraModern SuperApp shell'
         }
@@ -2601,69 +2793,6 @@ function createAppLocaleMessages(app, language) {
         role: domain,
         title: `${app.displayName} CZ`
     };
-    if ('commerce' === domain) return {
-        commerce: {
-            boundaries: {
-                checkout: 'en' === language ? 'checkout' : 'pokladna',
-                decide: 'en' === language ? 'decide' : 'rozhodování',
-                explore: 'en' === language ? 'explore' : 'procházení',
-                toggle: 'en' === language ? 'show team boundaries' : 'zobrazit hranice týmů'
-            },
-            brand: 'Acre & Iron',
-            cart: {
-                add: 'en' === language ? 'Add to cart' : 'Přidat do košíku',
-                button: 'en' === language ? 'Your cart ({{count}})' : 'Košík ({{count}})',
-                decrease: 'en' === language ? 'Decrease {{name}} quantity' : 'Snížit množství položky {{name}}',
-                empty: 'en' === language ? 'Your cart is empty.' : 'Košík je prázdný.',
-                increase: 'en' === language ? 'Increase {{name}} quantity' : 'Zvýšit množství položky {{name}}',
-                remove: 'en' === language ? 'Remove' : 'Odebrat',
-                title: 'en' === language ? 'Cart' : 'Košík',
-                view: 'en' === language ? 'View cart' : 'Zobrazit košík'
-            },
-            detail: {
-                availability: 'en' === language ? 'Availability' : 'Dostupnost',
-                eyebrow: 'en' === language ? 'Machine detail' : 'Detail stroje',
-                power: 'en' === language ? 'Power' : 'Výkon',
-                price: 'en' === language ? 'Price' : 'Cena'
-            },
-            footer: {
-                stack: 'en' === language ? 'SPA, SSR-ready Module Federation, React, Effect BFF' : 'SPA, SSR-ready Module Federation, React, Effect BFF'
-            },
-            language: {
-                cs: 'en' === language ? 'Czech' : 'Čeština',
-                en: 'en' === language ? 'English' : 'Angličtina',
-                switcher: 'en' === language ? 'Language' : 'Jazyk'
-            },
-            navigation: {
-                checkout: 'en' === language ? 'Checkout' : 'Pokladna',
-                machines: 'en' === language ? 'Machines' : 'Stroje',
-                primary: 'en' === language ? 'Primary commerce navigation' : 'Hlavní navigace obchodu'
-            },
-            products: {
-                autonomy: {
-                    badge: 'en' === language ? 'AI-first option' : 'AI varianta',
-                    title: 'en' === language ? 'Autonomy Retrofit Kit' : 'Sada pro autonomní řízení'
-                },
-                fieldLoader: {
-                    availability: 'en' === language ? 'In stock' : 'Skladem',
-                    description: 'en' === language ? 'A loader-ready tractor for feed, hay, gravel, and winter road work.' : 'Traktor připravený na nakladač pro krmivo, seno, štěrk i zimní údržbu cest.',
-                    imageAlt: 'en' === language ? 'Field Loader 112 tractor working on a bright farm lane' : 'Traktor Field Loader 112 pracuje na světlé polní cestě',
-                    power: '112 hp',
-                    price: 'EUR 42,500',
-                    title: 'Field Loader 112'
-                },
-                orchard: {
-                    badge: 'en' === language ? 'Best for tight rows' : 'Nejlepší do úzkých řádků',
-                    title: 'en' === language ? 'Narrow Orchard Tractor' : 'Úzký sadový traktor'
-                }
-            },
-            recommendations: {
-                title: 'en' === language ? 'Compare alternatives' : 'Porovnat alternativy'
-            },
-            role: 'en' === language ? 'commerce' : 'obchod',
-            title: 'en' === language ? app.displayName : czechLabel.title
-        }
-    };
     return {
         [domain]: {
             language: {
@@ -2672,6 +2801,16 @@ function createAppLocaleMessages(app, language) {
                 switcher: 'en' === language ? 'Language' : 'Jazyk'
             },
             role: 'en' === language ? app.domain ?? app.kind : czechLabel.role,
+            routes: {
+                cart: 'en' === language ? 'Cart' : 'Košík',
+                checkout: 'en' === language ? 'Checkout' : 'Pokladna',
+                home: 'en' === language ? 'Home' : 'Domů',
+                listing: 'en' === language ? 'Tractors' : 'Traktory',
+                productDetail: 'en' === language ? 'Tractor detail' : 'Detail traktoru',
+                storePicker: 'en' === language ? 'Store picker' : 'Výběr prodejce',
+                thankYou: 'en' === language ? 'Order confirmation' : 'Potvrzení objednávky',
+                unavailable: 'en' === language ? 'Unavailable' : 'Nedostupné'
+            },
             title: 'en' === language ? app.displayName : czechLabel.title
         }
     };
@@ -2706,6 +2845,18 @@ function createDesignTokens() {
 } as const;
 `;
 }
+function createSharedDesignTokensCss() {
+    return `@layer ultramodern-shared-tokens {
+:root {
+  --um-color-accent: #2f8f68;
+  --um-color-canvas: #f1eadc;
+  --um-color-foreground: #133225;
+  --um-color-link: #166b4b;
+  --um-color-surface: #f6fbf7;
+}
+}
+`;
+}
 function serviceEffectApiExport(service = effectService) {
     return `${toCamelCase(effectApiStem(service))}EffectApi`;
 }
@@ -2718,6 +2869,12 @@ function serviceEffectApiName(service = effectService) {
 function serviceEffectSchemaExport(service = effectService) {
     return `${toCamelCase(effectApiStem(service))}ItemSchema`;
 }
+function serviceEffectMarkerSchemaExport(service = effectService) {
+    return `${toCamelCase(effectApiStem(service))}MarkerSchema`;
+}
+function serviceEffectReadinessSchemaExport(service = effectService) {
+    return `${toCamelCase(effectApiStem(service))}ReadinessSchema`;
+}
 function serviceEffectErrorStem(service = effectService) {
     const stem = effectApiStem(service);
     return 'recommendations' === stem ? 'recommendation' : stem;
@@ -2743,6 +2900,8 @@ function createEffectSharedApiImports() {
 }
 function createEffectSharedApiContract(service = effectService) {
     const schemaExport = serviceEffectSchemaExport(service);
+    const markerSchemaExport = serviceEffectMarkerSchemaExport(service);
+    const readinessSchemaExport = serviceEffectReadinessSchemaExport(service);
     const createPayloadSchemaExport = serviceEffectCreatePayloadSchemaExport(service);
     const notFoundErrorExport = serviceEffectNotFoundErrorExport(service);
     const notFoundSchemaExport = serviceEffectNotFoundSchemaExport(service);
@@ -2751,19 +2910,33 @@ function createEffectSharedApiContract(service = effectService) {
     const groupName = serviceEffectGroupName(service);
     const stem = effectApiStem(service);
     const servicePrefix = effectApiPrefix(service);
-    return `export const ${schemaExport} = Schema.Struct({
+    return `export const ${markerSchemaExport} = Schema.Struct({
+  appId: Schema.String,
+  packageName: Schema.String,
+  version: Schema.String,
+  build: Schema.String,
+  deployProfile: Schema.String,
+  surface: Schema.String,
+});
+
+export const ${schemaExport} = Schema.Struct({
   id: Schema.String,
-  marker: Schema.Struct({
-    appId: Schema.String,
-    packageName: Schema.String,
-    version: Schema.String,
-    build: Schema.String,
-    deployProfile: Schema.String,
-    surface: Schema.String,
-  }),
+  marker: ${markerSchemaExport},
   title: Schema.String,
 });
 
+export const ${readinessSchemaExport} = Schema.Struct({
+  checks: Schema.Struct({
+    effectBff: Schema.Literal('ready'),
+    moduleFederation: Schema.Literal('ready'),
+    ssr: Schema.Literal('ready'),
+    translations: Schema.Literal('ready'),
+  }),
+  marker: ${markerSchemaExport},
+  status: Schema.Literal('ready'),
+  versionSkew: Schema.Literal('none'),
+});
+
 export const ${createPayloadSchemaExport} = Schema.Struct({
   title: Schema.String,
 });
@@ -2799,6 +2972,11 @@ export const ${apiExport} = HttpApi.make('${apiName}').add(
         }),
       }),
     )
+    .add(
+      HttpApiEndpoint.get('readiness', '/effect/${stem}/readiness', {
+        success: ${readinessSchemaExport},
+      }),
+    )
     .add(
       HttpApiEndpoint.get('get', '/effect/${stem}/:id', {
         params: {
@@ -2825,6 +3003,12 @@ export const ${groupName}OperationContexts = {
     method: 'GET',
     source: 'generated-client',
   },
+  readiness: {
+    operationId: '${apiName}:${groupName}:readiness',
+    routePath: '/effect/${stem}/readiness',
+    method: 'GET',
+    source: 'generated-client',
+  },
   get: {
     operationId: '${apiName}:${groupName}:get',
     routePath: '/effect/${stem}/:id',
@@ -2843,6 +3027,7 @@ export const ${groupName}ApiContract = {
   basePath: '${servicePrefix}/effect/${stem}',
   ownerId: '${service.id}',
   servicePrefix: '${servicePrefix}',
+  readinessPath: '${servicePrefix}/effect/${stem}/readiness',
 } as const;
 `;
 }
@@ -2911,6 +3096,24 @@ const ${groupName}Layer = HttpApiBuilder.group(
           }),
         ),
       )
+      .handle('readiness', () =>
+        Effect.succeed({
+          checks: {
+            effectBff: 'ready' as const,
+            moduleFederation: 'ready' as const,
+            ssr: 'ready' as const,
+            translations: 'ready' as const,
+          },
+          marker: ultramodernApiMarker,
+          status: 'ready' as const,
+          versionSkew: 'none' as const,
+        }).pipe(
+          Effect.withSpan('ultramodern.effect.${groupName}.readiness', {
+            attributes: operationAttributes(${groupName}OperationContexts.readiness),
+            kind: 'server',
+          }),
+        ),
+      )
       .handle('get', ({ params }) => {
         const item = ${groupName}Items.find(item => item.id === params.id);
         return (item !== undefined
@@ -2960,6 +3163,7 @@ function createEffectClient(service, contractImportPath) {
     const clientOptionsName = `${toPascalCase(stem)}ClientOptions`;
     const createClientName = `create${toPascalCase(stem)}Client`;
     const listName = `list${toPascalCase(stem)}`;
+    const readinessName = `get${toPascalCase(stem)}Readiness`;
     const getName = `get${toPascalCase(singular)}`;
     const createName = `create${toPascalCase(singular)}`;
     return `import {
@@ -3004,6 +3208,20 @@ export function ${listName}(
   );
 }
 
+export function ${readinessName}(
+  options: ${clientOptionsName} = {},
+) {
+  return runEffectRequest(
+    ${createClientName}({
+      ...options,
+      operationContext:
+        options.operationContext ?? ${groupName}OperationContexts.readiness,
+    }),
+  ).then(client =>
+    runEffectRequest(client.${groupName}.readiness({})),
+  );
+}
+
 export function ${getName}(
   id: string,
   options: ${clientOptionsName} = {},
@@ -3039,17 +3257,141 @@ export function ${createName}(
 }
 function createShellEffectClient(scope) {
     return `export {
-  createRecommendation,
-  createRecommendationsClient,
-  getRecommendation,
-  listRecommendations,
-  type RecommendationsClientOptions,
-} from '${ultramodern_workspace_packageName(scope, 'remote-commerce')}/effect/client';
+  createCheckout,
+  createCheckoutClient,
+  getCheckout,
+  getCheckoutReadiness,
+  listCheckout,
+  type CheckoutClientOptions,
+} from '${ultramodern_workspace_packageName(scope, 'remote-checkout')}/effect/client';
+
+export {
+  createDecide,
+  createDecideClient,
+  getDecide,
+  getDecideReadiness,
+  listDecide,
+  type DecideClientOptions,
+} from '${ultramodern_workspace_packageName(scope, 'remote-decide')}/effect/client';
+
+export {
+  createExplore,
+  createExploreClient,
+  getExplore,
+  getExploreReadiness,
+  listExplore,
+  type ExploreClientOptions,
+} from '${ultramodern_workspace_packageName(scope, 'remote-explore')}/effect/client';
 `;
 }
 function toPascalCase(value) {
     return value.split(/[-_]+/).filter(Boolean).map((part)=>`${part.charAt(0).toUpperCase()}${part.slice(1)}`).join('');
 }
+function createEffectReadinessContract(app) {
+    const stem = effectApiStem(app);
+    return {
+        endpoint: `/effect/${stem}/readiness`,
+        marker: {
+            ui: 'ultramodernUiMarker',
+            api: 'ultramodernApiMarker',
+            skew: 'none'
+        },
+        checks: [
+            'moduleFederation',
+            'ssr',
+            'translations',
+            'effectBff'
+        ]
+    };
+}
+function createEffectRequestContextContract() {
+    return {
+        propagatedHeaders: [
+            'accept-language',
+            'authorization',
+            'traceparent',
+            'x-correlation-id',
+            'x-tenant-id',
+            'x-ultramodern-env',
+            'x-vertical-version-id'
+        ],
+        source: 'shell-to-vertical-effect-client'
+    };
+}
+function createEffectDomainOperations(app) {
+    const stem = effectApiStem(app);
+    const group = serviceEffectGroupName(app);
+    const basePath = `/effect/${stem}`;
+    if ('checkout' === stem) return {
+        cartSnapshot: {
+            client: 'listCheckout',
+            method: 'GET',
+            path: basePath,
+            resource: 'cart',
+            owner: app.id
+        },
+        cartMutation: {
+            client: 'createCheckout',
+            method: 'POST',
+            path: basePath,
+            resource: 'cart-line',
+            owner: app.id
+        },
+        orderConfirmation: {
+            client: 'getCheckout',
+            method: 'GET',
+            path: `${basePath}/:id`,
+            resource: 'order',
+            owner: app.id
+        }
+    };
+    if ('decide' === stem) return {
+        productDetail: {
+            client: 'getDecide',
+            method: 'GET',
+            path: `${basePath}/:id`,
+            resource: 'product-detail',
+            owner: app.id
+        },
+        configurationDraft: {
+            client: 'createDecide',
+            method: 'POST',
+            path: basePath,
+            resource: 'configuration',
+            owner: app.id
+        },
+        productList: {
+            client: 'listDecide',
+            method: 'GET',
+            path: basePath,
+            resource: 'products',
+            owner: app.id
+        }
+    };
+    return {
+        recommendationFeed: {
+            client: `list${toPascalCase(stem)}`,
+            method: 'GET',
+            path: basePath,
+            resource: 'recommendations',
+            owner: app.id
+        },
+        recommendationDetail: {
+            client: `get${toPascalCase(serviceEffectErrorStem(app))}`,
+            method: 'GET',
+            path: `${basePath}/:id`,
+            resource: 'recommendation',
+            owner: app.id
+        },
+        recommendationCreate: {
+            client: `create${toPascalCase(serviceEffectErrorStem(app))}`,
+            method: 'POST',
+            path: basePath,
+            resource: group,
+            owner: app.id
+        }
+    };
+}
 function effectApiTopologyMetadata(app) {
     if (!appHasEffectApi(app)) return;
     return {
@@ -3069,7 +3411,10 @@ function effectApiTopologyMetadata(app) {
             },
             serverEntry: `${app.directory}/api/effect/index.ts`,
             basePath: `${app.effectApi.prefix}/effect/${app.effectApi.stem}`,
-            consumedBy: app.effectApi.consumedBy
+            consumedBy: app.effectApi.consumedBy,
+            readiness: createEffectReadinessContract(app),
+            requestContext: createEffectRequestContextContract(),
+            domainOperations: createEffectDomainOperations(app)
         }
     };
 }
@@ -3088,14 +3433,11 @@ function createTopology(scope) {
             moduleFederation: {
                 role: 'host',
                 name: shellApp.mfName,
-                remotes: remoteApps.map((remote)=>({
-                        id: remote.id,
-                        name: remote.mfName,
-                        manifestUrl: `http://localhost:${remote.port}/mf-manifest.json`
-                    })),
+                remotes: createModuleFederationRemoteContracts(shellApp),
                 ssr: true,
                 sharedContractVersion: 'mf-ssr-contract-v1'
             },
+            cloudflare: createCloudflareDeployContract(scope, shellApp),
             ownership: shellApp.ownership
         },
         remotes: remoteApps.map((remote)=>({
@@ -3108,6 +3450,10 @@ function createTopology(scope) {
                     name: remote.mfName,
                     manifestUrl: `http://localhost:${remote.port}/mf-manifest.json`,
                     exposes: Object.keys(remote.exposes ?? {}),
+                    ...remote.remoteRefs?.length ? {
+                        remoteRefs: remote.remoteRefs,
+                        remotes: createModuleFederationRemoteContracts(remote)
+                    } : {},
                     ssr: true,
                     fallbackTelemetryEvent: 'modernjs:mv-runtime-parity',
                     sharedContractVersion: 'mf-ssr-contract-v1'
@@ -3115,6 +3461,7 @@ function createTopology(scope) {
                 ...effectApiTopologyMetadata(remote) ? {
                     api: effectApiTopologyMetadata(remote)
                 } : {},
+                cloudflare: createCloudflareDeployContract(scope, remote),
                 ownership: remote.ownership
             })),
         effectServices: [],
@@ -3225,6 +3572,11 @@ function createEffectOperationContract(target) {
                 path: `/effect/${stem}`,
                 source: 'generated-client'
             },
+            readiness: {
+                method: 'GET',
+                path: `/effect/${stem}/readiness`,
+                source: 'generated-client'
+            },
             get: {
                 method: 'GET',
                 path: `/effect/${stem}/:id`,
@@ -3281,7 +3633,143 @@ function createAppConfigContract(app) {
         } : {}
     };
 }
-function createStylingContract(enableTailwind) {
+function cssLayerName(app) {
+    if ('shell' === app.kind) return 'ultramodern-shell-base';
+    return `ultramodern-remote-${app.domain ?? app.id}`;
+}
+function cssRole(app) {
+    if ('shell' === app.kind) return 'shell-base-overlay';
+    return 'horizontal-remote' === app.kind ? 'horizontal-remote-css' : 'vertical-remote-css';
+}
+function cssClassPrefix(app) {
+    if ('shell' === app.kind) return 'shell-';
+    return `${app.domain ?? app.id.replace(/^remote-/, '')}-`;
+}
+function createCssDedupeContract(scope) {
+    return {
+        strategy: 'shared-token-package-plus-css-content-hash',
+        sharedPackage: ultramodern_workspace_packageName(scope, 'shared-design-tokens'),
+        sharedLayers: [
+            'ultramodern-shared-tokens'
+        ],
+        runtimeLoad: 'once-per-content-hash',
+        duplicateBaseStylesAllowed: false
+    };
+}
+function createCssSsrContract(app) {
+    return {
+        cloudflare: true,
+        firstPaintRequired: true,
+        linkEmission: 'modern-ssr-css-assets',
+        remoteCss: 'shell' === app.kind ? 'host-preloads-shell-and-shared-css' : 'remote-manifest-owned-css'
+    };
+}
+function createAppCssFederationContract(scope, app) {
+    const ownedLayers = 'shell' === app.kind ? [
+        'ultramodern-shell-base',
+        'ultramodern-shell-overlay'
+    ] : [
+        cssLayerName(app)
+    ];
+    return {
+        owner: {
+            id: app.id,
+            package: ultramodern_workspace_packageName(scope, app.packageSuffix),
+            team: app.ownership.team
+        },
+        role: cssRole(app),
+        rootSelector: `[data-app-id="${app.id}"]`,
+        classPrefix: cssClassPrefix(app),
+        layers: {
+            shared: [
+                'ultramodern-shared-tokens'
+            ],
+            owned: ownedLayers,
+            imports: 'shell' === app.kind ? [
+                'ultramodern-shared-tokens'
+            ] : [
+                'ultramodern-shared-tokens'
+            ]
+        },
+        entrypoints: {
+            layoutImport: 'src/routes/layout.tsx',
+            css: [
+                'src/routes/index.css'
+            ],
+            ...'shell' !== app.kind ? {
+                remoteEntry: 'src/remote-entry.tsx'
+            } : {}
+        },
+        assets: {
+            shared: [
+                `${ultramodern_workspace_packageName(scope, 'shared-design-tokens')}/tokens.css`
+            ],
+            owned: [
+                'src/routes/index.css'
+            ],
+            emittedBy: 'modern-rspack-css-extraction',
+            contentHash: true
+        },
+        dedupe: createCssDedupeContract(scope),
+        ssr: createCssSsrContract(app)
+    };
+}
+function createCssFederationContract(scope) {
+    return {
+        schemaVersion: 1,
+        sharedDesignTokens: {
+            owner: {
+                id: 'shared-design-tokens',
+                package: ultramodern_workspace_packageName(scope, 'shared-design-tokens'),
+                team: 'super-app-platform'
+            },
+            role: 'shared-design-tokens',
+            rootSelector: ':root',
+            classPrefix: '--um-',
+            layers: {
+                owned: [
+                    'ultramodern-shared-tokens'
+                ]
+            },
+            entrypoints: {
+                css: [
+                    'packages/shared-design-tokens/src/tokens.css'
+                ],
+                typescript: [
+                    'packages/shared-design-tokens/src/index.ts'
+                ]
+            },
+            assets: {
+                exports: [
+                    './tokens.css'
+                ],
+                css: [
+                    'packages/shared-design-tokens/src/tokens.css'
+                ]
+            },
+            dedupe: createCssDedupeContract(scope),
+            ssr: {
+                cloudflare: true,
+                firstPaintRequired: true,
+                importedByApps: true
+            }
+        },
+        ownershipRules: {
+            shell: [
+                'base',
+                'overlay'
+            ],
+            remotes: [
+                'vertical-css'
+            ],
+            forbiddenRemoteLayers: [
+                'ultramodern-shell-base',
+                'ultramodern-shell-overlay'
+            ]
+        }
+    };
+}
+function createStylingContract(scope, app, enableTailwind) {
     return {
         tailwind: enableTailwind,
         ...enableTailwind ? {
@@ -3291,21 +3779,28 @@ function createStylingContract(enableTailwind) {
             contentGlobs: [
                 './src/**/*.{js,jsx,ts,tsx}'
             ]
-        } : {}
+        } : {},
+        federation: createAppCssFederationContract(scope, app)
     };
 }
 function createAppGeneratedContract(scope, app, apps, enableTailwind) {
-    const remoteAppsForShell = apps.filter((candidate)=>'shell' !== candidate.kind && candidate.mfName);
+    const appWithResolvedRefs = 'shell' === app.kind ? {
+        ...app,
+        remoteRefs: apps.filter((candidate)=>'shell' !== candidate.kind).map((candidate)=>candidate.id)
+    } : app;
+    const consumedRemotes = createModuleFederationRemoteContracts(appWithResolvedRefs, apps);
     return {
         id: app.id,
         package: ultramodern_workspace_packageName(scope, app.packageSuffix),
         path: app.directory,
         kind: app.kind,
         config: createAppConfigContract(app),
-        styling: createStylingContract(enableTailwind),
+        styling: createStylingContract(scope, app, enableTailwind),
         deploy: {
             target: 'cloudflare',
+            cloudflare: createCloudflareDeployContract(scope, app),
             worker: {
+                name: createCloudflareWorkerName(scope, app),
                 ssr: true
             },
             output: {
@@ -3319,25 +3814,42 @@ function createAppGeneratedContract(scope, app, apps, enableTailwind) {
         },
         i18n: {
             plugin: '@modern-js/plugin-i18n',
-            backend: false,
+            backend: {
+                enabled: true,
+                loadPath: '/locales/{{lng}}/{{ns}}.json'
+            },
             reactI18next: false,
             languages: [
                 'en',
                 'cs'
             ],
             fallbackLanguage: 'en',
-            publicDir: './locales'
+            namespace: appI18nNamespace(app),
+            namespaces: [
+                appI18nNamespace(app),
+                'translation'
+            ],
+            publicDir: './locales',
+            localisedUrls: createLocalisedUrlsMap(app),
+            resourceOwnership: {
+                ownerAppId: app.id,
+                source: 'route-owned',
+                staticJson: `./locales/{lng}/${appI18nNamespace(app)}.json`
+            }
+        },
+        routes: {
+            source: 'route-owned',
+            metadataExport: './src/routes/ultramodern-route-metadata',
+            localisedUrls: createLocalisedUrlsMap(app),
+            owned: createRouteOwnedI18nPaths(app),
+            generatedRouteMap: true,
+            manualOverrides: []
         },
         moduleFederation: {
             name: app.mfName,
-            ...'shell' === app.kind ? {
-                remotes: remoteAppsForShell.map((remote)=>({
-                        id: remote.id,
-                        alias: remoteDependencyAlias(remote),
-                        name: remote.mfName,
-                        manifestEnv: createRemoteManifestEnv(remote),
-                        manifestUrl: `http://localhost:${remote.port}/mf-manifest.json`
-                    }))
+            ...appWithResolvedRefs.remoteRefs?.length ? {
+                remoteRefs: appWithResolvedRefs.remoteRefs,
+                remotes: consumedRemotes
             } : {},
             exposes: Object.keys(app.exposes ?? {}),
             dts: {
@@ -3358,48 +3870,6 @@ function createAppGeneratedContract(scope, app, apps, enableTailwind) {
                 apiSurface: 'effect-bff'
             } : {}
         },
-        ...'commerce' === app.domain ? {
-            boundaryVisualization: {
-                mode: 'overlay',
-                layoutAffecting: false,
-                toggle: 'user-controlled',
-                boundaries: [
-                    {
-                        id: 'explore',
-                        labelKey: 'commerce.boundaries.explore',
-                        owner: 'team-explore',
-                        color: '#ff5a57',
-                        owns: [
-                            'header',
-                            'footer',
-                            'recommendations',
-                            'catalog'
-                        ]
-                    },
-                    {
-                        id: 'decide',
-                        labelKey: 'commerce.boundaries.decide',
-                        owner: 'team-decide',
-                        color: '#24d671',
-                        owns: [
-                            'product-detail',
-                            'variant-selection'
-                        ]
-                    },
-                    {
-                        id: 'checkout',
-                        labelKey: 'commerce.boundaries.checkout',
-                        owner: 'team-checkout',
-                        color: '#f4d044',
-                        owns: [
-                            'add-to-cart',
-                            'cart-link',
-                            'cart-lines'
-                        ]
-                    }
-                ]
-            }
-        } : {},
         ...appHasEffectApi(app) ? {
             effect: {
                 runtime: 'effect',
@@ -3409,6 +3879,9 @@ function createAppGeneratedContract(scope, app, apps, enableTailwind) {
                 workerEntry: 'worker/__modern_bff_effect.js',
                 contract: './shared/effect/api',
                 client: './effect/client',
+                readiness: createEffectReadinessContract(app),
+                requestContext: createEffectRequestContextContract(),
+                domainOperations: createEffectDomainOperations(app),
                 ...createEffectOperationContract(app)
             }
         } : {}
@@ -3437,6 +3910,7 @@ function createGeneratedContract(scope, apps = [
             zephyrAgent: ZEPHYR_AGENT_VERSION,
             wrangler: WRANGLER_VERSION
         },
+        cssFederation: createCssFederationContract(scope),
         apps: apps.map((app)=>createAppGeneratedContract(scope, app, apps, enableTailwind))
     };
 }
@@ -3559,16 +4033,670 @@ function createTemplateManifest(modernVersion, packageSource) {
         }
     };
 }
+function createAssertMfTypesScript(remotes = remoteApps) {
+    return `import fs from 'node:fs';
+import path from 'node:path';
+
+const root = process.cwd();
+const generatedContractPath = path.join(
+  root,
+  '.modernjs/ultramodern-generated-contract.json',
+);
+const generatedContract = fs.existsSync(generatedContractPath)
+  ? JSON.parse(fs.readFileSync(generatedContractPath, 'utf-8'))
+  : undefined;
+const defaultAppDirs = ${JSON.stringify(remotes.map((remote)=>remote.directory), null, 2)};
+
+const candidateDirs = process.argv.slice(2);
+const appDirs = candidateDirs.length
+  ? candidateDirs
+  : fs.existsSync(path.join(root, 'module-federation.config.ts'))
+    ? ['.']
+    : defaultAppDirs;
+
+for (const appDir of appDirs) {
+  const configPath = path.join(root, appDir, 'module-federation.config.ts');
+  if (!fs.existsSync(configPath)) {
+    throw new Error(
+      \`Missing Module Federation config: \${path.relative(root, configPath)}\`,
+    );
+  }
+
+  const contractEntry = generatedContract?.apps?.find(
+    app => app.path === appDir.replace(/\\\\/g, '/'),
+  );
+  if (
+    contractEntry &&
+    contractEntry.moduleFederation?.dts?.compilerInstance !==
+      '--package typescript -- tsc'
+  ) {
+    throw new Error(
+      \`Module Federation DTS must use the workspace TypeScript compiler: \${appDir}\`,
+    );
+  }
+
+  if (contractEntry && contractEntry.moduleFederation?.exposes?.length === 0) {
+    continue;
+  }
+
+  const typesArchivePath = path.join(root, appDir, 'dist/@mf-types.zip');
+  if (!fs.existsSync(typesArchivePath)) {
+    throw new Error(
+      \`Missing Module Federation DTS archive: \${path.relative(root, typesArchivePath)}\`,
+    );
+  }
+
+  const stats = fs.statSync(typesArchivePath);
+  if (stats.size === 0) {
+    throw new Error(
+      \`Empty Module Federation DTS archive: \${path.relative(root, typesArchivePath)}\`,
+    );
+  }
+}
+`;
+}
+function createWorkspaceValidationScript(scope, enableTailwind, remotes = remoteApps) {
+    const verticals = remotes.filter(appHasEffectApi).map((remote)=>({
+            id: remote.id,
+            domain: remote.domain,
+            stem: remote.effectApi.stem,
+            group: serviceEffectGroupName(remote),
+            path: remote.directory,
+            mfName: remote.mfName,
+            apiPrefix: remote.effectApi.prefix,
+            packageName: ultramodern_workspace_packageName(scope, remote.packageSuffix),
+            exposes: Object.keys(remote.exposes ?? {}),
+            componentPaths: Object.keys(remote.exposes ?? {}).map((expose)=>remoteComponentOutputPath(remote, expose)).filter((componentPath)=>Boolean(componentPath)),
+            namespace: appI18nNamespace(remote),
+            routePagePaths: createRouteOwnedI18nPaths(remote).filter((route)=>'/' !== route.canonicalPath).map((route)=>createRoutePageFilePath(remote, route.canonicalPath)),
+            localisedUrls: createLocalisedUrlsMap(remote),
+            remoteRefs: remote.remoteRefs ?? []
+        }));
+    const shellNamespace = appI18nNamespace(shellApp);
+    const oldRemotePaths = [
+        'apps/remotes/remote-commerce',
+        'apps/remotes/remote-identity',
+        'apps/remotes/remote-design-system'
+    ];
+    return `import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const root = process.cwd();
+const packageScope = '${scope}';
+const expectedPnpmVersion = '${PNPM_VERSION}';
+const tailwindEnabled = ${JSON.stringify(enableTailwind)};
+const fullStackVerticals = ${JSON.stringify(verticals, null, 2)};
+const shellNamespace = ${JSON.stringify(shellNamespace)};
+const oldRemotePaths = ${JSON.stringify(oldRemotePaths, null, 2)};
+
+const readText = relativePath => fs.readFileSync(path.join(root, relativePath), 'utf-8');
+const readJson = relativePath => JSON.parse(readText(relativePath));
+const assert = (condition, message) => {
+  if (!condition) {
+    throw new Error(message);
+  }
+};
+const assertExists = relativePath => {
+  assert(fs.existsSync(path.join(root, relativePath)), \`Missing \${relativePath}\`);
+};
+const assertNotExists = relativePath => {
+  assert(!fs.existsSync(path.join(root, relativePath)), \`Unexpected \${relativePath}\`);
+};
+const expectedWorkerName = packageSuffix => \`\${packageScope}-\${packageSuffix}\`.slice(0, 63);
+
+const activePnpmVersion = execFileSync('pnpm', ['--version'], {
+  cwd: root,
+  encoding: 'utf-8',
+  stdio: ['ignore', 'pipe', 'pipe'],
+}).trim();
+
+assert(
+  activePnpmVersion === expectedPnpmVersion,
+  \`Generated workspace requires pnpm \${expectedPnpmVersion}; active pnpm is \${activePnpmVersion}. Run mise install, then rerun through mise exec -- pnpm ...\`,
+);
+
+const requiredPaths = [
+  'AGENTS.md',
+  '.gitignore',
+  'package.json',
+  'pnpm-workspace.yaml',
+  'tsconfig.base.json',
+  'oxlint.config.ts',
+  'oxfmt.config.ts',
+  '.github/renovate.json',
+  '.github/workflows/ultramodern-workspace-gates.yml',
+  '.agents/skills-lock.json',
+  '.agents/agent-reference-repos.json',
+  '.agents/rstackjs-agent-skills-LICENSE',
+  'topology/reference-topology.json',
+  'topology/ownership.json',
+  'topology/local-overlays/development.json',
+  '.modernjs/ultramodern-workspace-template-manifest.json',
+  '.modernjs/ultramodern-package-source.json',
+  '.modernjs/ultramodern-generated-contract.json',
+  'scripts/assert-mf-types.mjs',
+  'scripts/bootstrap-agent-skills.mjs',
+  'scripts/proof-cloudflare-version.mjs',
+  'scripts/setup-agent-reference-repos.mjs',
+  'apps/shell-super-app/package.json',
+  'apps/shell-super-app/modern.config.ts',
+  'apps/shell-super-app/module-federation.config.ts',
+  'apps/shell-super-app/src/modern-app-env.d.ts',
+  'apps/shell-super-app/src/modern.runtime.ts',
+  'apps/shell-super-app/src/effect/recommendations-client.ts',
+  'apps/shell-super-app/locales/en/translation.json',
+  \`apps/shell-super-app/locales/en/\${shellNamespace}.json\`,
+  'apps/shell-super-app/locales/cs/translation.json',
+  \`apps/shell-super-app/locales/cs/\${shellNamespace}.json\`,
+  'apps/shell-super-app/src/routes/index.css',
+  'apps/shell-super-app/src/routes/layout.tsx',
+  'apps/shell-super-app/src/routes/ultramodern-route-metadata.ts',
+  'apps/shell-super-app/src/routes/[lang]/page.tsx',
+  'packages/shared-contracts/src/index.ts',
+  'packages/shared-design-tokens/src/index.ts',
+  'packages/shared-design-tokens/src/tokens.css',
+  'packages/shared-effect-api/src/index.ts',
+];
+
+for (const vertical of fullStackVerticals) {
+  requiredPaths.push(
+    \`\${vertical.path}/package.json\`,
+    \`\${vertical.path}/modern.config.ts\`,
+    \`\${vertical.path}/module-federation.config.ts\`,
+    \`\${vertical.path}/api/effect/index.ts\`,
+    \`\${vertical.path}/shared/effect/api.ts\`,
+    \`\${vertical.path}/src/effect/\${vertical.stem}-client.ts\`,
+    \`\${vertical.path}/src/modern-app-env.d.ts\`,
+    \`\${vertical.path}/src/modern.runtime.ts\`,
+    \`\${vertical.path}/src/remote-entry.tsx\`,
+    ...vertical.componentPaths,
+    \`\${vertical.path}/locales/en/translation.json\`,
+    \`\${vertical.path}/locales/en/\${vertical.namespace}.json\`,
+    \`\${vertical.path}/locales/cs/translation.json\`,
+    \`\${vertical.path}/locales/cs/\${vertical.namespace}.json\`,
+    \`\${vertical.path}/src/routes/index.css\`,
+    \`\${vertical.path}/src/routes/layout.tsx\`,
+    \`\${vertical.path}/src/routes/ultramodern-route-metadata.ts\`,
+    \`\${vertical.path}/src/routes/[lang]/page.tsx\`,
+    ...vertical.routePagePaths,
+  );
+}
+
+if (tailwindEnabled) {
+  requiredPaths.push(
+    'apps/shell-super-app/postcss.config.mjs',
+    'apps/shell-super-app/tailwind.config.ts',
+    ...fullStackVerticals.flatMap(vertical => [
+      \`\${vertical.path}/postcss.config.mjs\`,
+      \`\${vertical.path}/tailwind.config.ts\`,
+    ]),
+  );
+}
+
+for (const requiredPath of requiredPaths) {
+  assertExists(requiredPath);
+}
+for (const oldRemotePath of oldRemotePaths) {
+  assertNotExists(oldRemotePath);
+}
+assertNotExists('services/service-recommendations-effect');
+
+const rootPackage = readJson('package.json');
+const packageSource = readJson('.modernjs/ultramodern-package-source.json');
+const generatedContract = readJson('.modernjs/ultramodern-generated-contract.json');
+const topology = readJson('topology/reference-topology.json');
+const ownership = readJson('topology/ownership.json');
+const overlay = readJson('topology/local-overlays/development.json');
+
+assert(rootPackage.private === true, 'Root package must be private');
+assert(rootPackage.packageManager === \`pnpm@\${expectedPnpmVersion}\`, 'Root must pin pnpm');
+assert(rootPackage.modernjs?.preset === 'presetUltramodern', 'Root must declare presetUltramodern');
+assert(rootPackage.modernjs?.packageSource?.config === './.modernjs/ultramodern-package-source.json', 'Root must point at package source metadata');
+assert(rootPackage.modernjs?.packageSource?.strategy === packageSource.strategy, 'Root package source strategy must match metadata');
+assert(packageSource.strategy === 'workspace' || packageSource.strategy === 'install', 'Package source strategy must be workspace or install');
+assert(packageSource.generatedWorkspacePackages?.specifier === 'workspace:*', 'Generated workspace packages must keep workspace:* links');
+assert(
+  rootPackage.scripts?.build ===
+    'pnpm -r --filter "./apps/remotes/**" run build && pnpm --filter "./apps/shell-super-app" run build && pnpm ultramodern:assert-mf-types',
+  'Root build script must build remotes before shell',
+);
+assert(rootPackage.scripts?.['ultramodern:check'] === 'node ./scripts/validate-ultramodern-workspace.mjs', 'Root must expose ultramodern:check');
+assert(rootPackage.scripts?.['ultramodern:assert-mf-types'] === 'node ./scripts/assert-mf-types.mjs', 'Root must expose ultramodern:assert-mf-types');
+assert(rootPackage.scripts?.['cloudflare:deploy']?.includes('run cloudflare:deploy'), 'Root must expose cloudflare:deploy');
+assert(rootPackage.scripts?.['cloudflare:proof'] === 'node ./scripts/proof-cloudflare-version.mjs --out .codex/reports/cloudflare-version-proof/public-url-proof.json', 'Root must expose cloudflare:proof');
+
+const expectedAppIds = ['shell-super-app', ...fullStackVerticals.map(vertical => vertical.id)];
+assert(
+  JSON.stringify(generatedContract.apps?.map(app => app.id)) === JSON.stringify(expectedAppIds),
+  'Generated contract must contain shell plus the Tractor full-stack remotes',
+);
+assert(generatedContract.cssFederation?.sharedDesignTokens?.owner?.id === 'shared-design-tokens', 'CSS federation must declare shared design token ownership');
+assert(generatedContract.cssFederation?.sharedDesignTokens?.role === 'shared-design-tokens', 'CSS federation must mark shared-design-tokens as token owner');
+assert(generatedContract.cssFederation?.sharedDesignTokens?.rootSelector === ':root', 'Shared design tokens must declare their root selector');
+assert(generatedContract.cssFederation?.sharedDesignTokens?.classPrefix === '--um-', 'Shared design tokens must declare their CSS custom property prefix');
+assert(generatedContract.cssFederation?.sharedDesignTokens?.layers?.owned?.includes('ultramodern-shared-tokens'), 'Shared design tokens must own the shared token CSS layer');
+assert(generatedContract.cssFederation?.sharedDesignTokens?.entrypoints?.css?.includes('packages/shared-design-tokens/src/tokens.css'), 'Shared design tokens must declare their CSS entrypoint');
+assert(generatedContract.cssFederation?.sharedDesignTokens?.assets?.exports?.includes('./tokens.css'), 'Shared design tokens must export their CSS asset');
+assert(generatedContract.cssFederation?.sharedDesignTokens?.dedupe?.duplicateBaseStylesAllowed === false, 'Shared design token CSS must be deduplicated');
+assert(generatedContract.cssFederation?.sharedDesignTokens?.ssr?.firstPaintRequired === true, 'Shared design token CSS must be required for SSR first paint');
+
+const shellPackage = readJson('apps/shell-super-app/package.json');
+const expectedZephyrDependencies = Object.fromEntries(
+  fullStackVerticals.map(vertical => [
+    vertical.domain,
+    \`\${vertical.packageName}@workspace:*\`,
+  ]),
+);
+assert(
+  JSON.stringify(shellPackage['zephyr:dependencies']) ===
+    JSON.stringify(expectedZephyrDependencies),
+  'Shell Zephyr dependencies must reference every Tractor remote package',
+);
+const shellContract = generatedContract.apps?.find(app => app.id === 'shell-super-app');
+assert(shellContract?.deploy?.cloudflare?.workerName === expectedWorkerName('shell-super-app'), 'Shell Cloudflare workerName is incorrect');
+assert(shellContract?.deploy?.cloudflare?.publicUrlEnv === 'ULTRAMODERN_PUBLIC_URL_SHELL_SUPER_APP', 'Shell Cloudflare public URL env is incorrect');
+assert(topology.shell?.cloudflare?.workerName === expectedWorkerName('shell-super-app'), 'Shell topology Cloudflare workerName is incorrect');
+assert(shellContract?.styling?.federation?.owner?.id === 'shell-super-app', 'Shell CSS federation owner is missing');
+assert(shellContract?.styling?.federation?.role === 'shell-base-overlay', 'Shell must own base and overlay CSS');
+assert(shellContract?.styling?.federation?.rootSelector === '[data-app-id="shell-super-app"]', 'Shell CSS root selector is incorrect');
+assert(shellContract?.styling?.federation?.classPrefix === 'shell-', 'Shell CSS class prefix is incorrect');
+assert(shellContract?.styling?.federation?.layers?.owned?.includes('ultramodern-shell-base'), 'Shell must own the base CSS layer');
+assert(shellContract?.styling?.federation?.layers?.owned?.includes('ultramodern-shell-overlay'), 'Shell must own the overlay CSS layer');
+assert(shellContract?.styling?.federation?.entrypoints?.css?.includes('src/routes/index.css'), 'Shell CSS entrypoint is missing');
+assert(shellContract?.styling?.federation?.assets?.shared?.some(asset => asset.endsWith('/shared-design-tokens/tokens.css')), 'Shell must import the shared design token CSS asset');
+assert(shellContract?.styling?.federation?.dedupe?.duplicateBaseStylesAllowed === false, 'Shell CSS contract must forbid duplicated base styles');
+assert(shellContract?.styling?.federation?.ssr?.firstPaintRequired === true, 'Shell CSS must be required for SSR first paint');
+assert(
+  topology.shell?.remoteRefs?.join(',') === fullStackVerticals.map(vertical => vertical.id).join(','),
+  'Topology shell remoteRefs must match Tractor remotes',
+);
+assert(topology.remotes?.length === fullStackVerticals.length, 'Topology must contain only Tractor remotes');
+assert((topology.effectServices ?? []).length === 0, 'Default APIs must be vertical-owned, not effectServices');
+
+for (const vertical of fullStackVerticals) {
+  const packageJson = readJson(\`\${vertical.path}/package.json\`);
+  assert(packageJson.name === vertical.packageName, \`\${vertical.id} package name is incorrect\`);
+  assert(packageJson.scripts?.['cloudflare:deploy'] === 'MODERNJS_DEPLOY=cloudflare modern deploy', \`\${vertical.id} must expose cloudflare:deploy\`);
+  assert(packageJson.scripts?.['cloudflare:proof']?.includes(\`--app \${vertical.id}\`), \`\${vertical.id} must expose cloudflare:proof\`);
+  assert(packageJson.dependencies?.['@modern-js/plugin-bff'], \`\${vertical.id} must depend on plugin-bff\`);
+  assert(packageJson.exports?.['./effect/client'] === \`./src/effect/\${vertical.stem}-client.ts\`, \`\${vertical.id} must export its Effect client\`);
+  assert(packageJson.exports?.['./shared/effect/api'] === './shared/effect/api.ts', \`\${vertical.id} must export its Effect API contract\`);
+  const expectedVerticalZephyrDependencies = Object.fromEntries(
+    fullStackVerticals
+      .filter(candidate => vertical.remoteRefs.includes(candidate.id))
+      .map(candidate => [
+        candidate.domain,
+        \`\${candidate.packageName}@workspace:*\`,
+      ]),
+  );
+  assert(
+    JSON.stringify(packageJson['zephyr:dependencies']) ===
+      JSON.stringify(expectedVerticalZephyrDependencies),
+    \`\${vertical.id} Zephyr dependencies must match declared MF remote refs\`,
+  );
+
+  const contractEntry = generatedContract.apps?.find(app => app.id === vertical.id);
+  assert(contractEntry?.path === vertical.path, \`\${vertical.id} generated contract path is incorrect\`);
+  assert(contractEntry?.kind === 'vertical', \`\${vertical.id} generated contract kind is incorrect\`);
+  assert(contractEntry?.deploy?.cloudflare?.workerName === expectedWorkerName(vertical.id), \`\${vertical.id} Cloudflare workerName is incorrect\`);
+  assert(contractEntry?.deploy?.cloudflare?.publicUrlEnv === \`ULTRAMODERN_PUBLIC_URL_\${vertical.id.replace(/-/g, '_').toUpperCase()}\`, \`\${vertical.id} Cloudflare public URL env is incorrect\`);
+  assert(contractEntry?.deploy?.cloudflare?.routes?.effectReadiness === \`\${vertical.apiPrefix}/effect/\${vertical.stem}/readiness\`, \`\${vertical.id} Cloudflare proof readiness route is incorrect\`);
+  assert(contractEntry?.moduleFederation?.name === vertical.mfName, \`\${vertical.id} MF name is incorrect\`);
+  assert(JSON.stringify(contractEntry?.moduleFederation?.exposes) === JSON.stringify(vertical.exposes), \`\${vertical.id} MF exposes are incorrect\`);
+  assert(contractEntry?.moduleFederation?.dts?.compilerInstance === '--package typescript -- tsc', \`\${vertical.id} must keep mandatory DTS compiler\`);
+  assert(JSON.stringify(contractEntry?.moduleFederation?.remoteRefs ?? []) === JSON.stringify(vertical.remoteRefs), \`\${vertical.id} MF remoteRefs are incorrect\`);
+  assert(
+    JSON.stringify((contractEntry?.moduleFederation?.remotes ?? []).map(remote => remote.id)) ===
+      JSON.stringify(vertical.remoteRefs),
+    \`\${vertical.id} MF consumed remotes are incorrect\`,
+  );
+  assert(contractEntry?.effect?.prefix === vertical.apiPrefix, \`\${vertical.id} Effect API prefix is incorrect\`);
+  assert(contractEntry?.effect?.group === vertical.group, \`\${vertical.id} Effect group is incorrect\`);
+  assert(contractEntry?.effect?.readiness?.endpoint === \`/effect/\${vertical.stem}/readiness\`, \`\${vertical.id} readiness endpoint is incorrect\`);
+  assert(contractEntry?.effect?.operations?.readiness?.path === \`/effect/\${vertical.stem}/readiness\`, \`\${vertical.id} readiness operation is missing\`);
+  assert(contractEntry?.effect?.requestContext?.propagatedHeaders?.includes('traceparent'), \`\${vertical.id} trace context propagation is missing\`);
+  assert(Object.keys(contractEntry?.effect?.domainOperations ?? {}).length >= 3, \`\${vertical.id} domain operations are missing\`);
+  assert(contractEntry?.i18n?.languages?.includes('en') && contractEntry?.i18n?.languages?.includes('cs'), \`\${vertical.id} must declare i18n languages\`);
+  assert(contractEntry?.i18n?.namespace === vertical.namespace, \`\${vertical.id} i18n namespace is incorrect\`);
+  assert(
+    JSON.stringify(contractEntry?.i18n?.localisedUrls) === JSON.stringify(vertical.localisedUrls),
+    \`\${vertical.id} localisedUrls must come from route metadata\`,
+  );
+  assert(contractEntry?.routes?.source === 'route-owned', \`\${vertical.id} routes must be route-owned\`);
+  assert(contractEntry?.routes?.metadataExport === './src/routes/ultramodern-route-metadata', \`\${vertical.id} route metadata export is incorrect\`);
+  assert(contractEntry?.styling?.federation?.owner?.id === vertical.id, \`\${vertical.id} CSS federation owner is missing\`);
+  assert(contractEntry?.styling?.federation?.role === 'vertical-remote-css', \`\${vertical.id} must own only vertical CSS\`);
+  assert(contractEntry?.styling?.federation?.rootSelector === \`[data-app-id="\${vertical.id}"]\`, \`\${vertical.id} CSS root selector is incorrect\`);
+  assert(contractEntry?.styling?.federation?.classPrefix === \`\${vertical.domain}-\`, \`\${vertical.id} CSS class prefix is incorrect\`);
+  assert(contractEntry?.styling?.federation?.layers?.owned?.includes(\`ultramodern-remote-\${vertical.domain}\`), \`\${vertical.id} remote CSS layer is missing\`);
+  assert(!contractEntry?.styling?.federation?.layers?.owned?.includes('ultramodern-shell-base'), \`\${vertical.id} must not own shell base CSS\`);
+  assert(contractEntry?.styling?.federation?.entrypoints?.remoteEntry === 'src/remote-entry.tsx', \`\${vertical.id} remote CSS contract must include remote entry\`);
+  assert(contractEntry?.styling?.federation?.assets?.shared?.some(asset => asset.endsWith('/shared-design-tokens/tokens.css')), \`\${vertical.id} must import shared design token CSS\`);
+  assert(contractEntry?.styling?.federation?.dedupe?.runtimeLoad === 'once-per-content-hash', \`\${vertical.id} CSS dedupe strategy is incorrect\`);
+  assert(contractEntry?.styling?.federation?.ssr?.remoteCss === 'remote-manifest-owned-css', \`\${vertical.id} SSR CSS loading contract is incorrect\`);
+
+  const topologyEntry = topology.remotes?.find(remote => remote.id === vertical.id);
+  assert(topologyEntry?.kind === 'vertical', \`\${vertical.id} topology kind is incorrect\`);
+  assert(topologyEntry?.package === vertical.packageName, \`\${vertical.id} topology package is incorrect\`);
+  assert(topologyEntry?.cloudflare?.workerName === expectedWorkerName(vertical.id), \`\${vertical.id} topology Cloudflare workerName is incorrect\`);
+  assert(topologyEntry?.moduleFederation?.name === vertical.mfName, \`\${vertical.id} topology MF name is incorrect\`);
+  assert(JSON.stringify(topologyEntry?.moduleFederation?.exposes) === JSON.stringify(vertical.exposes), \`\${vertical.id} topology exposes are incorrect\`);
+  assert(JSON.stringify(topologyEntry?.moduleFederation?.remoteRefs ?? []) === JSON.stringify(vertical.remoteRefs), \`\${vertical.id} topology remoteRefs are incorrect\`);
+  assert(topologyEntry?.api?.effect?.bff?.prefix === vertical.apiPrefix, \`\${vertical.id} topology API prefix is incorrect\`);
+  assert(topologyEntry?.api?.effect?.serverEntry === \`\${vertical.path}/api/effect/index.ts\`, \`\${vertical.id} topology server entry is incorrect\`);
+  assert(topologyEntry?.api?.effect?.readiness?.endpoint === \`/effect/\${vertical.stem}/readiness\`, \`\${vertical.id} topology readiness endpoint is incorrect\`);
+  assert(Object.keys(topologyEntry?.api?.effect?.domainOperations ?? {}).length >= 3, \`\${vertical.id} topology domain operations are missing\`);
+
+  assert(ownership.owners?.some(owner => owner.id === vertical.id && owner.path === vertical.path), \`\${vertical.id} ownership entry is missing\`);
+  assert(overlay.ports?.[vertical.id], \`\${vertical.id} development port is missing\`);
+  assert(overlay.manifests?.[vertical.id]?.includes('/mf-manifest.json'), \`\${vertical.id} development manifest is missing\`);
+  assert(overlay.apis?.[vertical.id]?.endsWith(vertical.apiPrefix), \`\${vertical.id} development API URL is missing\`);
+}
+
+console.log('UltraModern workspace scaffold validated');
+`;
+}
+function createCloudflareVersionProofScript() {
+    return `#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const workspaceRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '..',
+);
+const contractPath = path.join(
+  workspaceRoot,
+  '.modernjs/ultramodern-generated-contract.json',
+);
+const defaultOut = path.join(
+  workspaceRoot,
+  '.codex/reports/cloudflare-version-proof/public-url-proof.json',
+);
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function parseArgs(argv) {
+  const parsed = {
+    appId: undefined,
+    out: defaultOut,
+    requirePublicUrls: false,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--app') {
+      parsed.appId = argv[index + 1];
+      index += 1;
+    } else if (arg === '--out') {
+      parsed.out = argv[index + 1];
+      index += 1;
+    } else if (arg === '--require-public-urls') {
+      parsed.requirePublicUrls = true;
+    } else if (arg === '--help' || arg === '-h') {
+      parsed.help = true;
+    } else {
+      throw new Error(\`Unknown argument: \${arg}\`);
+    }
+  }
+
+  return parsed;
+}
+
+function printHelp() {
+  process.stdout.write(\`Usage:
+  node scripts/proof-cloudflare-version.mjs [--app remote-explore] [--out evidence.json] [--require-public-urls]
+
+Set each app's public URL using the contract env key, for example:
+  ULTRAMODERN_PUBLIC_URL_REMOTE_EXPLORE=https://remote-explore.example.workers.dev
+\`);
+}
+
+function joinUrl(baseUrl, routePath) {
+  return new URL(routePath, baseUrl.endsWith('/') ? baseUrl : \`\${baseUrl}/\`);
+}
+
+async function fetchText(url) {
+  const response = await fetch(url);
+  return {
+    ok: response.ok,
+    status: response.status,
+    contentType: response.headers.get('content-type'),
+    body: await response.text(),
+  };
+}
+
+function parseMaybeJson(body) {
+  try {
+    return JSON.parse(body);
+  } catch {
+    return undefined;
+  }
+}
+
+function markerFromJson(value) {
+  if (!value || typeof value !== 'object') {
+    return undefined;
+  }
+  if (value.marker && typeof value.marker.build === 'string') {
+    return value.marker.build;
+  }
+  if (typeof value.build === 'string') {
+    return value.build;
+  }
+  for (const nested of Object.values(value)) {
+    if (Array.isArray(nested)) {
+      for (const item of nested) {
+        const marker = markerFromJson(item);
+        if (marker) {
+          return marker;
+        }
+      }
+    } else {
+      const marker = markerFromJson(nested);
+      if (marker) {
+        return marker;
+      }
+    }
+  }
+  return undefined;
+}
+
+function extractUiMarker(html) {
+  return html.match(/data-build-marker=["']([^"']+)["']/u)?.[1];
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+async function validateApp(app, publicUrl) {
+  const cloudflare = app.deploy?.cloudflare;
+  const routes = cloudflare?.routes ?? {};
+  const evidence = {
+    appId: app.id,
+    publicUrl,
+    workerName: cloudflare?.workerName,
+    publicUrlEnv: cloudflare?.publicUrlEnv,
+    assertions: [],
+  };
+
+  const ssrRoute = routes.ssr ?? '/en';
+  const ssr = await fetchText(joinUrl(publicUrl, ssrRoute));
+  evidence.assertions.push({
+    type: 'ssr',
+    route: ssrRoute,
+    status: ssr.ok ? 'pass' : 'fail',
+    statusCode: ssr.status,
+  });
+  assert(ssr.ok, \`\${app.id} SSR route returned HTTP \${ssr.status}\`);
+
+  const uiMarker = extractUiMarker(ssr.body);
+  evidence.assertions.push({
+    type: 'ui-marker',
+    expected: app.marker?.build,
+    actual: uiMarker,
+    status: uiMarker === app.marker?.build ? 'pass' : 'fail',
+  });
+  assert(uiMarker === app.marker?.build, \`\${app.id} UI marker mismatch\`);
+
+  const cssRootSelector = app.styling?.federation?.rootSelector;
+  const expectedAppId = cssRootSelector?.match(/data-app-id="([^"]+)"/u)?.[1];
+  evidence.assertions.push({
+    type: 'css-root-marker',
+    expected: cssRootSelector,
+    status:
+      expectedAppId && ssr.body.includes(\`data-app-id="\${expectedAppId}"\`)
+        ? 'pass'
+        : 'fail',
+  });
+  assert(
+    expectedAppId && ssr.body.includes(\`data-app-id="\${expectedAppId}"\`),
+    \`\${app.id} SSR response is missing CSS root marker \${cssRootSelector}\`,
+  );
+
+  const manifestRoute = routes.mfManifest ?? '/mf-manifest.json';
+  const manifest = await fetchText(joinUrl(publicUrl, manifestRoute));
+  evidence.assertions.push({
+    type: 'mf-manifest',
+    route: manifestRoute,
+    status: manifest.ok ? 'pass' : 'fail',
+    statusCode: manifest.status,
+  });
+  assert(
+    manifest.ok,
+    \`\${app.id} MF manifest returned HTTP \${manifest.status}\`,
+  );
+
+  const localeRoute = routes.locale ?? \`/locales/en/\${app.i18n?.namespace}.json\`;
+  const locale = await fetchText(joinUrl(publicUrl, localeRoute));
+  const localeJson = parseMaybeJson(locale.body);
+  evidence.assertions.push({
+    type: 'i18n-marker',
+    namespace: app.i18n?.namespace,
+    route: localeRoute,
+    status:
+      locale.ok &&
+      localeJson &&
+      Object.hasOwn(localeJson, app.i18n?.namespace)
+        ? 'pass'
+        : 'fail',
+    statusCode: locale.status,
+  });
+  assert(locale.ok, \`\${app.id} locale JSON returned HTTP \${locale.status}\`);
+  assert(
+    localeJson && Object.hasOwn(localeJson, app.i18n?.namespace),
+    \`\${app.id} locale JSON is missing namespace \${app.i18n?.namespace}\`,
+  );
+
+  if (routes.effectReadiness) {
+    const readiness = await fetchText(joinUrl(publicUrl, routes.effectReadiness));
+    const readinessJson = parseMaybeJson(readiness.body);
+    const apiMarker = markerFromJson(readinessJson);
+    evidence.assertions.push({
+      type: 'api-marker',
+      route: routes.effectReadiness,
+      expected: app.marker?.build,
+      actual: apiMarker,
+      status: readiness.ok && apiMarker === app.marker?.build ? 'pass' : 'fail',
+      statusCode: readiness.status,
+    });
+    assert(
+      readiness.ok,
+      \`\${app.id} Effect readiness returned HTTP \${readiness.status}\`,
+    );
+    assert(apiMarker === app.marker?.build, \`\${app.id} API marker mismatch\`);
+  }
+
+  return evidence;
+}
+
+async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  if (args.help) {
+    printHelp();
+    return 0;
+  }
+
+  const contract = readJson(contractPath);
+  const apps = args.appId
+    ? contract.apps.filter(app => app.id === args.appId)
+    : contract.apps;
+  assert(apps.length > 0, \`No generated app matched \${args.appId}\`);
+
+  const results = [];
+  const skipped = [];
+  for (const app of apps) {
+    const publicUrlEnv = app.deploy?.cloudflare?.publicUrlEnv;
+    const publicUrl = publicUrlEnv && process.env[publicUrlEnv];
+    if (!publicUrl) {
+      const skippedEntry = {
+        appId: app.id,
+        status: args.requirePublicUrls ? 'fail' : 'skipped',
+        publicUrlEnv,
+        reason: 'public URL environment variable is not set',
+      };
+      skipped.push(skippedEntry);
+      if (args.requirePublicUrls) {
+        throw new Error(\`\${app.id} requires \${publicUrlEnv}\`);
+      }
+      continue;
+    }
+    results.push(await validateApp(app, publicUrl));
+  }
+
+  const report = {
+    schemaVersion: 1,
+    generatedAt: new Date().toISOString(),
+    status: results.length > 0 ? 'pass' : 'skipped',
+    contractPath,
+    results,
+    skipped,
+  };
+
+  fs.mkdirSync(path.dirname(args.out), { recursive: true });
+  fs.writeFileSync(args.out, \`\${JSON.stringify(report, null, 2)}\\n\`);
+  process.stdout.write(
+    \`[cloudflare-version-proof] \${report.status}: \${args.out}\\n\`,
+  );
+  return 0;
+}
+
+main().then(
+  exitCode => {
+    process.exitCode = exitCode;
+  },
+  error => {
+    process.stderr.write(\`[cloudflare-version-proof] \${error.message}\\n\`);
+    process.exitCode = 1;
+  },
+);
+`;
+}
+function writeGeneratedWorkspaceScripts(targetDir, scope, enableTailwind) {
+    writeFileReplacing(targetDir, "scripts/assert-mf-types.mjs", createAssertMfTypesScript());
+    writeFileReplacing(targetDir, "scripts/validate-ultramodern-workspace.mjs", createWorkspaceValidationScript(scope, enableTailwind));
+    writeFileReplacing(targetDir, "scripts/proof-cloudflare-version.mjs", createCloudflareVersionProofScript());
+}
 function writeApp(targetDir, scope, app, packageSource, enableTailwind) {
     writeJson(targetDir, `${app.directory}/package.json`, createAppPackage(scope, app, packageSource, enableTailwind));
     writeJson(targetDir, `${app.directory}/tsconfig.json`, createPackageTsConfig(app.directory, appHasEffectApi(app)));
-    writeFile(targetDir, `${app.directory}/src/modern-app-env.d.ts`, "/// <reference types='@modern-js/app-tools/types' />\n\ndeclare const ULTRAMODERN_SITE_URL: string;\n");
+    writeFile(targetDir, `${app.directory}/src/modern-app-env.d.ts`, createAppEnvDts(app));
     writeFile(targetDir, `${app.directory}/src/ultramodern-build.ts`, createUltramodernBuildModule(scope, app));
-    writeFile(targetDir, `${app.directory}/modern.config.ts`, createAppModernConfig(app));
+    writeFile(targetDir, `${app.directory}/src/routes/ultramodern-route-metadata.ts`, createRouteMetadataModule(app));
+    writeFile(targetDir, `${app.directory}/modern.config.ts`, createAppModernConfig(scope, app));
     writeFile(targetDir, `${app.directory}/src/modern.runtime.ts`, createAppRuntimeConfig(app));
     writeJson(targetDir, `${app.directory}/locales/en/translation.json`, createAppLocaleMessages(app, 'en'));
+    writeJson(targetDir, `${app.directory}/locales/en/${appI18nNamespace(app)}.json`, createAppLocaleMessages(app, 'en'));
     writeJson(targetDir, `${app.directory}/locales/cs/translation.json`, createAppLocaleMessages(app, 'cs'));
-    writeFile(targetDir, `${app.directory}/src/routes/index.css`, createAppStyles(enableTailwind));
+    writeJson(targetDir, `${app.directory}/locales/cs/${appI18nNamespace(app)}.json`, createAppLocaleMessages(app, 'cs'));
+    writeFile(targetDir, `${app.directory}/src/routes/index.css`, createAppStyles(enableTailwind, scope, app));
     if (enableTailwind) {
         writeFile(targetDir, `${app.directory}/postcss.config.mjs`, createPostcssConfig());
         writeFile(targetDir, `${app.directory}/tailwind.config.ts`, createTailwindConfig());
@@ -3576,6 +4704,7 @@ function writeApp(targetDir, scope, app, packageSource, enableTailwind) {
     writeFile(targetDir, `${app.directory}/module-federation.config.ts`, 'shell' === app.kind ? createShellModuleFederationConfig() : createRemoteModuleFederationConfig(app));
     writeFile(targetDir, `${app.directory}/src/routes/layout.tsx`, createLayout(app.id));
     writeFile(targetDir, `${app.directory}/src/routes/[lang]/page.tsx`, 'shell' === app.kind ? createShellPage() : createRemotePage(app));
+    for (const route of createRouteOwnedI18nPaths(app))if ('/' !== route.canonicalPath) writeFile(targetDir, createRoutePageFilePath(app, route.canonicalPath), createRouteAliasPage(route.canonicalPath));
     if ('shell' === app.kind) writeFile(targetDir, `${app.directory}/src/effect/recommendations-client.ts`, createShellEffectClient(scope));
     if (appHasEffectApi(app)) {
         writeFile(targetDir, `${app.directory}/shared/effect/api.ts`, createEffectSharedApi(app));
@@ -3584,7 +4713,10 @@ function writeApp(targetDir, scope, app, packageSource, enableTailwind) {
     }
     if ('vertical' === app.kind || 'horizontal-remote' === app.kind) {
         writeFile(targetDir, `${app.directory}/src/remote-entry.tsx`, createRemoteEntry(app));
-        writeFile(targetDir, `${app.directory}/src/components/${remoteWidgetFile(app)}.tsx`, createRemoteWidget(app));
+        for (const expose of Object.keys(app.exposes ?? {})){
+            const outputPath = remoteComponentOutputPath(app, expose);
+            if (outputPath) writeFile(targetDir, outputPath, createRemoteExposeComponent(app, expose));
+        }
     }
     if ('horizontal-design-system' === app.kind) {
         writeFile(targetDir, `${app.directory}/src/components/button.tsx`, createDesignButton());
@@ -3601,7 +4733,7 @@ function writeEffectService(targetDir, scope, packageSource, enableTailwind, ser
   return <main>${service.id} Effect service</main>;
 }
 `);
-    writeFile(targetDir, `${service.directory}/src/routes/index.css`, createAppStyles(enableTailwind));
+    writeFile(targetDir, `${service.directory}/src/routes/index.css`, createServiceStyles(enableTailwind, scope, service));
     if (enableTailwind) {
         writeFile(targetDir, `${service.directory}/postcss.config.mjs`, createPostcssConfig());
         writeFile(targetDir, `${service.directory}/tailwind.config.ts`, createTailwindConfig());
@@ -3619,6 +4751,7 @@ function writeGenericSharedPackage(targetDir, scope, packageSource, sharedPackag
     });
     writeFile(targetDir, `${sharedPackage.directory}/src/index.ts`, `export const packageId = '${sharedPackage.id}';
 `);
+    if ('shared-design-tokens' === sharedPackage.id) writeFile(targetDir, `${sharedPackage.directory}/src/tokens.css`, createSharedDesignTokensCss());
 }
 function writeSharedPackages(targetDir, scope, packageSource) {
     for (const sharedPackage of sharedPackages){
@@ -3644,6 +4777,7 @@ function writeSharedPackages(targetDir, scope, packageSource) {
   },
 } as const;
 `);
+    writeFile(targetDir, 'packages/shared-design-tokens/src/tokens.css', createSharedDesignTokensCss());
     writeFile(targetDir, 'packages/shared-effect-api/src/index.ts', createEffectSharedApi());
 }
 function readJsonFile(filePath) {
@@ -3742,6 +4876,10 @@ function remoteTopologyEntry(scope, remote) {
             name: remote.mfName,
             manifestUrl: `http://localhost:${remote.port}/mf-manifest.json`,
             exposes: Object.keys(remote.exposes ?? {}),
+            ...remote.remoteRefs?.length ? {
+                remoteRefs: remote.remoteRefs,
+                remotes: createModuleFederationRemoteContracts(remote)
+            } : {},
             ssr: true,
             fallbackTelemetryEvent: 'modernjs:mv-runtime-parity',
             sharedContractVersion: 'mf-ssr-contract-v1'
@@ -3780,6 +4918,17 @@ function remotesFromTopology(topology, ports) {
             portEnv: '',
             port: 'number' == typeof ports[remote.id] ? ports[remote.id] : 0,
             mfName: remote.moduleFederation?.name ?? `remote${toPascalCase(remote.id)}`,
+            ...Array.isArray(remote.moduleFederation?.exposes) ? {
+                exposes: Object.fromEntries(remote.moduleFederation.exposes.map((expose)=>[
+                        expose,
+                        ''
+                    ]))
+            } : {},
+            ...Array.isArray(remote.moduleFederation?.remoteRefs) ? {
+                remoteRefs: remote.moduleFederation.remoteRefs
+            } : Array.isArray(remote.moduleFederation?.remotes) ? {
+                remoteRefs: remote.moduleFederation.remotes.map((entry)=>entry.id).filter((id)=>'string' == typeof id)
+            } : {},
             ...effectApi ? {
                 effectApi
             } : {},
@@ -3837,7 +4986,10 @@ function addUltramodernMicroVertical(options) {
         writeJsonFile(ownershipPath, ownership);
         writeJsonFile(overlayPath, overlay);
         writeJsonFile(node_path.join(options.workspaceRoot, GENERATED_CONTRACT_PATH), createGeneratedContract(scope, [
-            shellApp,
+            {
+                ...shellApp,
+                remoteRefs: remotesFromTopology(topology, overlay.ports).map((remote)=>remote.id)
+            },
             ...remotesFromTopology(topology, overlay.ports)
         ], enableTailwind));
         const shellConfigPath = node_path.join(options.workspaceRoot, `${shellApp.directory}/module-federation.config.ts`);
@@ -3940,6 +5092,7 @@ function generateUltramodernWorkspace(options) {
     writeApp(options.targetDir, scope, shellApp, packageSource, enableTailwind);
     for (const remote of remoteApps)writeApp(options.targetDir, scope, remote, packageSource, enableTailwind);
     writeSharedPackages(options.targetDir, scope, packageSource);
+    writeGeneratedWorkspaceScripts(options.targetDir, scope, enableTailwind);
 }
 const src_dirname = node_path.dirname(fileURLToPath(import.meta.url));
 const templateDir = node_path.resolve(src_dirname, '..', 'template');