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

package/dist/esm-node/ultramodern-workspace/package-json.js

@@ -81,7 +81,7 @@ const effectDiagnostics = [
     'unnecessaryPipe',
     'unnecessaryPipeChain'
 ];
-function appDependencies(scope, packageSource, app, remotes = []) {
+function appDependencies(scope, packageSource, app, remotes = [], bridge) {
     const dependencies = {
         '@modern-js/plugin-tanstack': modernPackageSpecifier('@modern-js/plugin-tanstack', packageSource),
         '@modern-js/plugin-i18n': modernPackageSpecifier('@modern-js/plugin-i18n', packageSource),
@@ -98,6 +98,7 @@ function appDependencies(scope, packageSource, app, remotes = []) {
         'react-dom': REACT_DOM_VERSION,
         'react-router': REACT_ROUTER_VERSION
     };
+    for (const dependency of bridge?.dependencies ?? [])dependencies[dependency] = WORKSPACE_PACKAGE_VERSION;
     if ('shell' === app.kind) {
         dependencies['@modern-js/plugin-bff'] = modernPackageSpecifier('@modern-js/plugin-bff', packageSource);
         for (const remote of verticalEffectApps(remotes))dependencies[packageName(scope, remote.packageSuffix)] = WORKSPACE_PACKAGE_VERSION;
@@ -124,12 +125,28 @@ function appDevDependencies(packageSource, enableTailwind) {
         wrangler: WRANGLER_VERSION
     };
 }
-function createRootPackageJson(scope, packageSource, remotes = []) {
+function createRootPackageJson(scope, packageSource, remotes = [], bridge) {
     const shellFilter = `--filter ${packageName(scope, shellApp.packageSuffix)}`;
     const remoteFilters = remotes.map((remote)=>`--filter ${packageName(scope, remote.packageSuffix)}`);
     const remoteBuildPrefix = remotes.length > 0 ? 'ULTRAMODERN_ZEPHYR=false pnpm -r --filter "./verticals/*" run build && ' : '';
     const remoteCloudflareBuildPrefix = remotes.length > 0 ? 'pnpm -r --filter "./verticals/*" run cloudflare:build && ' : '';
     const remoteCloudflareDeployPrefix = remotes.length > 0 ? 'pnpm -r --filter "./verticals/*" run cloudflare:deploy && ' : '';
+    const generatedPackageTypecheck = 'pnpm -r --filter "./apps/*" --filter "./verticals/*" --filter "./packages/*" run typecheck';
+    const typecheck = bridge ? generatedPackageTypecheck : "node ./scripts/ultramodern-typecheck.mjs --build tsconfig.json";
+    const bridgeScripts = bridge ? {
+        ...Object.fromEntries(bridge.gates.map((gate)=>[
+                `bridge:${gate.name}`,
+                `${gate.cwd ? `cd ${gate.cwd} && ` : ''}${gate.command}`
+            ])),
+        'bridge:check': bridge.gates.map((gate)=>`pnpm run bridge:${gate.name}`).join(' && ')
+    } : {};
+    const bridgeCheck = bridge ? ' && pnpm bridge:check' : '';
+    const workspacePackages = [
+        'apps/*',
+        'verticals/*',
+        'packages/*',
+        ...bridge?.workspacePackages.map((entry)=>entry.pattern) ?? []
+    ];
     return {
         private: true,
         name: scope,
@@ -151,7 +168,7 @@ function createRootPackageJson(scope, packageSource, remotes = []) {
             'format:check': "oxfmt --check . '!repos/**'",
             lint: 'oxlint apps verticals packages',
             'lint:fix': 'oxlint apps verticals packages --fix',
-            typecheck: "node ./scripts/ultramodern-typecheck.mjs --build tsconfig.json",
+            typecheck,
             'cloudflare:build': `${remoteCloudflareBuildPrefix}pnpm --filter "./apps/shell-super-app" run cloudflare:build && pnpm mf:types`,
             'cloudflare:deploy': `${remoteCloudflareDeployPrefix}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",
@@ -163,18 +180,15 @@ function createRootPackageJson(scope, packageSource, remotes = []) {
             'performance:readiness': "node ./scripts/ultramodern-performance-readiness.mjs",
             'contract:check': "node ./scripts/validate-ultramodern-workspace.mjs",
             'i18n:boundaries': "node ./scripts/check-ultramodern-i18n-boundaries.mjs",
+            ...bridgeScripts,
             postinstall: "oxfmt . '!repos/**' && node ./scripts/bootstrap-agent-skills.mjs --postinstall",
-            check: 'pnpm format:check && pnpm lint && pnpm typecheck && pnpm skills:check && pnpm i18n:boundaries && pnpm contract:check && pnpm performance:readiness'
+            check: `pnpm format:check && pnpm lint && pnpm typecheck && pnpm skills:check && pnpm i18n:boundaries && pnpm contract:check && pnpm performance:readiness${bridgeCheck}`
         },
         engines: {
             node: '>=26',
             pnpm: '>=11'
         },
-        workspaces: [
-            'apps/*',
-            'verticals/*',
-            'packages/*'
-        ],
+        workspaces: workspacePackages,
         modernjs: {
             preset: 'presetUltramodern',
             workspace: 'ultramodern-superapp',
@@ -182,7 +196,7 @@ function createRootPackageJson(scope, packageSource, remotes = []) {
             ownership: './topology/ownership.json',
             packageSource: {
                 strategy: packageSource.strategy,
-                config: './.modernjs/ultramodern-package-source.json'
+                config: './.modernjs/ultramodern.json#packageSource'
             }
         },
         devDependencies: {
@@ -340,7 +354,7 @@ function createRootTsConfig(apps = []) {
         ]
     };
 }
-function createAppPackage(scope, app, packageSource, enableTailwind, remotes = []) {
+function createAppPackage(scope, app, packageSource, enableTailwind, remotes = [], bridge) {
     const publicSurfaceBuildCommand = createPublicSurfaceGenerationCommand(app, 'dist');
     const publicSurfaceCloudflareBuildCommand = createPublicSurfaceGenerationCommand(app, 'dist');
     const publicSurfaceCloudflareOutputCommand = createPublicSurfaceGenerationCommand(app, 'cloudflare');
@@ -372,7 +386,7 @@ function createAppPackage(scope, app, packageSource, enableTailwind, remotes = [
             } : {}
         },
         'zephyr:dependencies': createZephyrDependencies(scope, app, remotes),
-        dependencies: appDependencies(scope, packageSource, app, remotes),
+        dependencies: appDependencies(scope, packageSource, app, remotes, bridge),
         devDependencies: appDevDependencies(packageSource, enableTailwind)
     };
     if (appHasEffectApi(app)) Object.assign(packageExports, {

package/dist/esm-node/ultramodern-workspace/public-api.js

@@ -1,3 +1,4 @@
 import "node:module";
 export { addUltramodernVertical, planUltramodernVertical } from "./add-vertical.js";
+export { normalizeUltramodernBridgeConfig } from "./bridge-config.js";
 export { generateUltramodernWorkspace } from "./write-workspace.js";

package/dist/esm-node/ultramodern-workspace/workspace-scripts.js

@@ -8,10 +8,73 @@ import { createCloudflareSecurityContract } from "./policy.js";
 import { publicSurfaceManagedSourceAssetPaths } from "./public-surface.js";
 import { createLocalisedUrlsMap, createRouteMetaFilePath, createRouteOwnedI18nPaths, createRoutePageFilePath } from "./routes.js";
 import { CLOUDFLARE_COMPATIBILITY_DATE, NODE_VERSION, PNPM_VERSION } from "./versions.js";
-function createAssertMfTypesScript(remotes = []) {
-    return renderFileTemplate("workspace-scripts/assert-mf-types.mjs", {
-        defaultAppDirsJson: JSON.stringify(remotes.map((remote)=>remote.directory), null, 2)
+function createToolWrapperScript(command, extraArgs = []) {
+    const commandJson = JSON.stringify(command);
+    const extraArgsJson = JSON.stringify(extraArgs);
+    return `#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const createBin = process.env.ULTRAMODERN_CREATE_BIN;
+const forwardedArgs = process.argv.slice(2);
+const workspaceRoot =
+  process.env.ULTRAMODERN_WORKSPACE_ROOT ??
+  path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const ultramodernArgs = ['ultramodern', ${commandJson}, ...${extraArgsJson}, ...forwardedArgs];
+const result = createBin
+  ? spawnSync(process.execPath, [createBin, ...ultramodernArgs], {
+      env: { ...process.env, ULTRAMODERN_WORKSPACE_ROOT: workspaceRoot },
+      stdio: 'inherit',
+    })
+  : spawnSync('modern-js-create', ultramodernArgs, {
+      env: { ...process.env, ULTRAMODERN_WORKSPACE_ROOT: workspaceRoot },
+      shell: process.platform === 'win32',
+      stdio: 'inherit',
     });
+
+if (result.error) {
+  console.error(result.error.message);
+  process.exit(1);
+}
+
+process.exit(result.status ?? 1);
+`;
+}
+function createSkillsToolWrapperScript() {
+    return `#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const createBin = process.env.ULTRAMODERN_CREATE_BIN;
+const forwardedArgs = process.argv.slice(2);
+const workspaceRoot =
+  process.env.ULTRAMODERN_WORKSPACE_ROOT ??
+  path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const checkOnly = forwardedArgs.includes('--check');
+const skillArgs = checkOnly
+  ? ['skills', 'check', ...forwardedArgs.filter(arg => arg !== '--check')]
+  : ['skills', 'install', ...forwardedArgs];
+const ultramodernArgs = ['ultramodern', ...skillArgs];
+const result = createBin
+  ? spawnSync(process.execPath, [createBin, ...ultramodernArgs], {
+      env: { ...process.env, ULTRAMODERN_WORKSPACE_ROOT: workspaceRoot },
+      stdio: 'inherit',
+    })
+  : spawnSync('modern-js-create', ultramodernArgs, {
+      env: { ...process.env, ULTRAMODERN_WORKSPACE_ROOT: workspaceRoot },
+      shell: process.platform === 'win32',
+      stdio: 'inherit',
+    });
+
+if (result.error) {
+  console.error(result.error.message);
+  process.exit(1);
+}
+
+process.exit(result.status ?? 1);
+`;
 }
 function createWorkspaceValidationScript(scope, enableTailwind, remotes = []) {
     const verticals = remotes.filter(appHasEffectApi).map((remote)=>({
@@ -65,33 +128,18 @@ function createWorkspaceValidationScript(scope, enableTailwind, remotes = []) {
 function createWorkspaceI18nBoundaryValidationScript() {
     return readFileTemplate("workspace-scripts/check-ultramodern-i18n-boundaries.mjs");
 }
-function createPublicSurfaceAssetsScript() {
-    return readFileTemplate("workspace-scripts/generate-public-surface-assets.mjs");
-}
-function createCloudflareProofHelperScript() {
-    return readFileTemplate("workspace-scripts/ultramodern-cloudflare-proof.mjs");
-}
-function createCloudflareVersionProofScript() {
-    return readFileTemplate("workspace-scripts/proof-cloudflare-version.mjs");
-}
 function createPerformanceReadinessConfigScript() {
     return readFileTemplate("workspace-scripts/ultramodern-performance-readiness.config.mjs");
 }
-function createPerformanceReadinessScript() {
-    return readFileTemplate("workspace-scripts/ultramodern-performance-readiness.mjs");
-}
-function createUltramodernTypecheckScript() {
-    return readFileTemplate("workspace-scripts/ultramodern-typecheck.mjs");
-}
-function writeGeneratedWorkspaceScripts(targetDir, scope, enableTailwind, remotes = []) {
-    writeFileReplacing(targetDir, "scripts/assert-mf-types.mjs", createAssertMfTypesScript(remotes));
-    writeFileReplacing(targetDir, "scripts/validate-ultramodern-workspace.mjs", createWorkspaceValidationScript(scope, enableTailwind, remotes));
+function writeGeneratedWorkspaceScripts(targetDir, _scope, _enableTailwind, _remotes = []) {
+    writeFileReplacing(targetDir, "scripts/assert-mf-types.mjs", createToolWrapperScript('mf-types'));
+    writeFileReplacing(targetDir, "scripts/validate-ultramodern-workspace.mjs", createToolWrapperScript('validate'));
     writeFileReplacing(targetDir, "scripts/check-ultramodern-i18n-boundaries.mjs", createWorkspaceI18nBoundaryValidationScript());
-    writeFileReplacing(targetDir, "scripts/generate-public-surface-assets.mjs", createPublicSurfaceAssetsScript());
-    writeFileReplacing(targetDir, "scripts/ultramodern-cloudflare-proof.mjs", createCloudflareProofHelperScript());
-    writeFileReplacing(targetDir, "scripts/proof-cloudflare-version.mjs", createCloudflareVersionProofScript());
+    writeFileReplacing(targetDir, "scripts/generate-public-surface-assets.mjs", createToolWrapperScript('public-surface'));
+    writeFileReplacing(targetDir, "scripts/proof-cloudflare-version.mjs", createToolWrapperScript('cloudflare-proof'));
     writeFileReplacing(targetDir, "scripts/ultramodern-performance-readiness.config.mjs", createPerformanceReadinessConfigScript());
-    writeFileReplacing(targetDir, "scripts/ultramodern-performance-readiness.mjs", createPerformanceReadinessScript());
-    writeFileReplacing(targetDir, "scripts/ultramodern-typecheck.mjs", createUltramodernTypecheckScript());
+    writeFileReplacing(targetDir, "scripts/ultramodern-performance-readiness.mjs", createToolWrapperScript('performance-readiness'));
+    writeFileReplacing(targetDir, "scripts/ultramodern-typecheck.mjs", createToolWrapperScript('typecheck'));
+    writeFileReplacing(targetDir, "scripts/bootstrap-agent-skills.mjs", createSkillsToolWrapperScript());
 }
-export { createAssertMfTypesScript, createCloudflareProofHelperScript, createCloudflareVersionProofScript, createPerformanceReadinessConfigScript, createPerformanceReadinessScript, createPublicSurfaceAssetsScript, createUltramodernTypecheckScript, createWorkspaceI18nBoundaryValidationScript, createWorkspaceValidationScript, writeGeneratedWorkspaceScripts };
+export { createPerformanceReadinessConfigScript, createWorkspaceI18nBoundaryValidationScript, createWorkspaceValidationScript, writeGeneratedWorkspaceScripts };

package/dist/esm-node/ultramodern-workspace/write-workspace.js

@@ -1,11 +1,12 @@
 import "node:module";
 import node_fs from "node:fs";
 import { createAppEnvDts, createAppRuntimeConfig, createAppStyles, createPostcssConfig, createSharedDesignTokensCss, createShellFrameComponent, createTailwindConfig } from "./app-files.js";
-import { createDevelopmentOverlay, createGeneratedContract, createOwnership, createPackageSourceMetadata, createTemplateManifest, createTopology } from "./contracts.js";
+import { normalizeUltramodernBridgeConfig } from "./bridge-config.js";
+import { createDevelopmentOverlay, createOwnership, createTopology, createUltramodernConfig } from "./contracts.js";
 import { createLayout, createRemoteEntry, createRemoteExposeComponent, createRemotePage, createShellPage, createShellRemoteComponents, remoteComponentOutputPath } from "./demo-components.js";
-import { GENERATED_CONTRACT_PATH, appHasEffectApi, appI18nNamespace, createShellHost, sharedPackages, shellApp } from "./descriptors.js";
+import { ULTRAMODERN_CONFIG_PATH, appHasEffectApi, appI18nNamespace, createShellHost, sharedPackages, shellApp } from "./descriptors.js";
 import { createEffectClient, createEffectServiceEntry, createEffectSharedApi, createShellEffectClient } from "./effect-api.js";
-import { copyRootTemplate, writeFile, writeJson } from "./fs-io.js";
+import { copyRootTemplate, writeFile, writeFileReplacing, writeJson } from "./fs-io.js";
 import { createFileSnapshot, createGenerationResult, diffFileSnapshots } from "./generation-result.js";
 import { createAppPublicLocaleMessages } from "./locales.js";
 import { createAppModernConfig, createRemoteModuleFederationConfig, createShellModuleFederationConfig, createUltramodernBuildModule, createUltramodernBuildReexportModule } from "./module-federation.js";
@@ -16,13 +17,13 @@ import { resolvePackageSource } from "./package-source.js";
 import { createPublicWebAppArtifacts } from "./public-surface.js";
 import { NODE_FETCH_VERSION, NODE_VERSION, PNPM_VERSION, TANSTACK_ROUTER_CORE_VERSION, TANSTACK_ROUTER_VERSION, TYPESCRIPT_VERSION } from "./versions.js";
 import { writeGeneratedWorkspaceScripts } from "./workspace-scripts.js";
-function writeApp(targetDir, scope, app, packageSource, enableTailwind, remotes = []) {
+function writeApp(targetDir, scope, app, packageSource, enableTailwind, remotes = [], bridge) {
     const resolvedApp = 'shell' === app.kind ? createShellHost(remotes) : app;
     const publicWeb = createPublicWebAppArtifacts(resolvedApp);
     const writeAppFile = (relativePath, content)=>{
         writeFile(targetDir, `${resolvedApp.directory}/${relativePath}`, content);
     };
-    writeJson(targetDir, `${resolvedApp.directory}/package.json`, createAppPackage(scope, resolvedApp, packageSource, enableTailwind, remotes));
+    writeJson(targetDir, `${resolvedApp.directory}/package.json`, createAppPackage(scope, resolvedApp, packageSource, enableTailwind, remotes, bridge));
     writeJson(targetDir, `${resolvedApp.directory}/tsconfig.json`, createAppTsConfig(resolvedApp, remotes));
     writeJson(targetDir, `${resolvedApp.directory}/tsconfig.mf-types.json`, createAppMfTypesTsConfig(resolvedApp));
     writeFile(targetDir, `${resolvedApp.directory}/src/modern-app-env.d.ts`, createAppEnvDts(resolvedApp, remotes));
@@ -81,10 +82,36 @@ function writeSharedPackages(targetDir, scope) {
 `);
     writeFile(targetDir, 'packages/shared-design-tokens/src/tokens.css', createSharedDesignTokensCss());
 }
+function createCompactRootPackageJson(scope, packageSource, remotes, bridge) {
+    const rootPackage = createRootPackageJson(scope, packageSource, remotes, bridge);
+    if (rootPackage.modernjs?.packageSource && 'object' == typeof rootPackage.modernjs.packageSource) rootPackage.modernjs.packageSource.config = `./${ULTRAMODERN_CONFIG_PATH}`;
+    return rootPackage;
+}
+function createCompactUltramodernConfig(scope, modernVersion, packageSource, apps = [
+    createShellHost()
+], enableTailwind = true, bridge) {
+    const config = createUltramodernConfig(scope, modernVersion, packageSource, apps, enableTailwind, bridge);
+    if (config.packageSource && 'object' == typeof config.packageSource && !Array.isArray(config.packageSource)) delete config.packageSource.metadata;
+    return config;
+}
+function writePnpmWorkspacePackages(targetDir, bridge) {
+    if (!bridge) return;
+    const pnpmWorkspacePath = `${targetDir}/pnpm-workspace.yaml`;
+    const pnpmWorkspace = node_fs.readFileSync(pnpmWorkspacePath, 'utf-8');
+    const packages = [
+        'apps/*',
+        'verticals/*',
+        'packages/*',
+        ...bridge.workspacePackages.map((entry)=>entry.pattern)
+    ];
+    const renderedPackages = packages.map((pattern)=>`  - ${pattern}`).join('\n');
+    writeFileReplacing(targetDir, 'pnpm-workspace.yaml', pnpmWorkspace.replace(/^packages:\n(?: {2}- .+\n)+/u, `packages:\n${renderedPackages}\n`));
+}
 function generateUltramodernWorkspace(options) {
     const beforeFiles = createFileSnapshot(options.targetDir);
     const scope = toPackageScope(options.packageName);
     const packageSource = resolvePackageSource(options);
+    const bridge = normalizeUltramodernBridgeConfig(options.bridge);
     const enableTailwind = false !== options.enableTailwind;
     const initialVerticals = [];
     const createdApps = [
@@ -109,17 +136,16 @@ function generateUltramodernWorkspace(options) {
         typescriptVersion: TYPESCRIPT_VERSION,
         tailwindEnabled: String(enableTailwind)
     });
-    writeJson(options.targetDir, 'package.json', createRootPackageJson(scope, packageSource, initialVerticals));
+    writePnpmWorkspacePackages(options.targetDir, bridge);
+    writeJson(options.targetDir, 'package.json', createCompactRootPackageJson(scope, packageSource, initialVerticals, bridge));
     writeJson(options.targetDir, 'tsconfig.base.json', createTsConfigBase());
     writeJson(options.targetDir, 'tsconfig.json', createRootTsConfig(createdApps));
     writeJson(options.targetDir, 'topology/reference-topology.json', createTopology(scope, initialVerticals));
     writeJson(options.targetDir, 'topology/ownership.json', createOwnership(scope, initialVerticals));
     writeJson(options.targetDir, 'topology/local-overlays/development.json', createDevelopmentOverlay(initialVerticals));
-    writeJson(options.targetDir, '.modernjs/ultramodern-workspace-template-manifest.json', createTemplateManifest(options.modernVersion, packageSource));
-    writeJson(options.targetDir, '.modernjs/ultramodern-package-source.json', createPackageSourceMetadata(scope, packageSource));
-    writeJson(options.targetDir, GENERATED_CONTRACT_PATH, createGeneratedContract(scope, createdApps, enableTailwind));
-    writeApp(options.targetDir, scope, shellApp, packageSource, enableTailwind, initialVerticals);
-    for (const remote of initialVerticals)writeApp(options.targetDir, scope, remote, packageSource, enableTailwind, initialVerticals);
+    writeJson(options.targetDir, ULTRAMODERN_CONFIG_PATH, createCompactUltramodernConfig(scope, options.modernVersion, packageSource, createdApps, enableTailwind, bridge));
+    writeApp(options.targetDir, scope, shellApp, packageSource, enableTailwind, initialVerticals, bridge);
+    for (const remote of initialVerticals)writeApp(options.targetDir, scope, remote, packageSource, enableTailwind, initialVerticals, bridge);
     writeSharedPackages(options.targetDir, scope);
     writeGeneratedWorkspaceScripts(options.targetDir, scope, enableTailwind, initialVerticals);
     const afterFiles = createFileSnapshot(options.targetDir);
@@ -140,4 +166,4 @@ function generateUltramodernWorkspace(options) {
     });
     return result;
 }
-export { generateUltramodernWorkspace, writeApp, writeSharedPackages };
+export { createCompactUltramodernConfig, generateUltramodernWorkspace, writeApp, writeSharedPackages };

package/dist/types/locale/en.d.ts

@@ -38,6 +38,16 @@ export declare const EN_LOCALE: {
         optionUltramodernPackageRegistry: string;
         optionUltramodernPackageScope: string;
         optionUltramodernPackageNamePrefix: string;
+        optionBridge: string;
+        optionBridgeParentRoot: string;
+        optionBridgeWorkspacePackage: string;
+        optionBridgeWorkspacePackageName: string;
+        optionBridgeTestAlias: string;
+        optionBridgeDependency: string;
+        optionBridgeLockfilePolicy: string;
+        optionBridgeGate: string;
+        optionBridgeGateCwd: string;
+        optionBridgeReactSingleton: string;
         optionVertical: string;
         optionVerticalName: string;
         optionDryRun: string;

package/dist/types/locale/index.d.ts

@@ -40,6 +40,16 @@ declare const localeKeys: {
         optionUltramodernPackageRegistry: string;
         optionUltramodernPackageScope: string;
         optionUltramodernPackageNamePrefix: string;
+        optionBridge: string;
+        optionBridgeParentRoot: string;
+        optionBridgeWorkspacePackage: string;
+        optionBridgeWorkspacePackageName: string;
+        optionBridgeTestAlias: string;
+        optionBridgeDependency: string;
+        optionBridgeLockfilePolicy: string;
+        optionBridgeGate: string;
+        optionBridgeGateCwd: string;
+        optionBridgeReactSingleton: string;
         optionVertical: string;
         optionVerticalName: string;
         optionDryRun: string;
@@ -101,6 +111,16 @@ declare const localeKeys: {
         optionUltramodernPackageRegistry: string;
         optionUltramodernPackageScope: string;
         optionUltramodernPackageNamePrefix: string;
+        optionBridge: string;
+        optionBridgeParentRoot: string;
+        optionBridgeWorkspacePackage: string;
+        optionBridgeWorkspacePackageName: string;
+        optionBridgeTestAlias: string;
+        optionBridgeDependency: string;
+        optionBridgeLockfilePolicy: string;
+        optionBridgeGate: string;
+        optionBridgeGateCwd: string;
+        optionBridgeReactSingleton: string;
         optionVertical: string;
         optionVerticalName: string;
         optionDryRun: string;

package/dist/types/locale/zh.d.ts

@@ -38,6 +38,16 @@ export declare const ZH_LOCALE: {
         optionUltramodernPackageRegistry: string;
         optionUltramodernPackageScope: string;
         optionUltramodernPackageNamePrefix: string;
+        optionBridge: string;
+        optionBridgeParentRoot: string;
+        optionBridgeWorkspacePackage: string;
+        optionBridgeWorkspacePackageName: string;
+        optionBridgeTestAlias: string;
+        optionBridgeDependency: string;
+        optionBridgeLockfilePolicy: string;
+        optionBridgeGate: string;
+        optionBridgeGateCwd: string;
+        optionBridgeReactSingleton: string;
         optionVertical: string;
         optionVerticalName: string;
         optionDryRun: string;

package/dist/types/ultramodern-tooling/commands.d.ts

@@ -0,0 +1 @@
+export declare function runUltramodernToolingCli(args: string[], workspaceRoot?: any): Promise<number>;

package/dist/types/ultramodern-tooling/config.d.ts

@@ -0,0 +1,43 @@
+import { type UltramodernBridgeConfig } from '../ultramodern-workspace/bridge-config';
+import type { ResolvedPackageSource, WorkspaceApp, WorkspaceEffectApi } from '../ultramodern-workspace/types';
+export type UltramodernToolingConfigSource = 'compact' | 'legacy';
+export type UltramodernToolingConfigApp = {
+    id: string;
+    kind: WorkspaceApp['kind'];
+    path: string;
+    package?: string;
+    packageSuffix?: string;
+    displayName?: string;
+    domain?: string;
+    port?: number;
+    portEnv?: string;
+    moduleFederation?: {
+        role?: 'host' | 'remote';
+        name?: string;
+        exposes?: string[];
+        verticalRefs?: string[];
+        hostOnly?: boolean;
+        noExposes?: boolean;
+    };
+    effectApi?: WorkspaceEffectApi;
+};
+export type UltramodernToolingConfig = {
+    schemaVersion: number;
+    profile?: string;
+    source: UltramodernToolingConfigSource;
+    sourcePath: string;
+    workspace: {
+        packageScope: string;
+    };
+    packageSource?: ResolvedPackageSource;
+    features: {
+        tailwind: boolean;
+    };
+    bridge?: UltramodernBridgeConfig;
+    topology: {
+        apps: UltramodernToolingConfigApp[];
+    };
+    legacyContract?: Record<string, any>;
+};
+export declare function readUltramodernConfig(workspaceRoot?: any): UltramodernToolingConfig;
+export declare function workspaceAppsFromToolingConfig(config: UltramodernToolingConfig): WorkspaceApp[];

package/dist/types/ultramodern-workspace/add-vertical.d.ts

@@ -1,3 +1,4 @@
+import type { UltramodernBridgeConfig } from './bridge-config';
 import type { AddUltramodernVerticalOptions, JsonValue, Ownership, ResolvedPackageSource, UltramodernGenerationResult, UltramodernVerticalPlan, UltramodernWorkspaceOptions, WorkspaceApp } from './types';
 export type AddUltramodernVerticalPreflight = {
     name: string;
@@ -11,16 +12,18 @@ export type AddUltramodernVerticalPreflight = {
     overlay: Record<string, any>;
     packageSource: ResolvedPackageSource;
     enableTailwind: boolean;
+    bridge?: UltramodernBridgeConfig;
     vertical: WorkspaceApp;
     updatedVerticals: WorkspaceApp[];
 };
 export declare function existingPackageSource(workspaceRoot: string, modernVersion: string, packageSource?: UltramodernWorkspaceOptions['packageSource']): ResolvedPackageSource;
 export declare function existingTailwindEnabled(workspaceRoot: string): boolean;
+export declare function existingBridgeConfig(workspaceRoot: string): UltramodernBridgeConfig | undefined;
 export declare function assertValidVerticalName(name: string): string;
 export declare function nextAvailablePort(ports: Record<string, unknown>): number;
 export declare function assertCanCreate(workspaceRoot: string, relativePath: string): void;
-export declare function updateRootWorkspaceScripts(workspaceRoot: string, scope: string, packageSource: ResolvedPackageSource, remotes: WorkspaceApp[]): void;
-export declare function rewriteShellAppFiles(workspaceRoot: string, scope: string, packageSource: ResolvedPackageSource, enableTailwind: boolean, remotes: WorkspaceApp[]): void;
+export declare function updateRootWorkspaceScripts(workspaceRoot: string, scope: string, packageSource: ResolvedPackageSource, remotes: WorkspaceApp[], bridge?: UltramodernBridgeConfig): void;
+export declare function rewriteShellAppFiles(workspaceRoot: string, scope: string, packageSource: ResolvedPackageSource, enableTailwind: boolean, remotes: WorkspaceApp[], bridge?: UltramodernBridgeConfig): void;
 export declare function addShellZephyrDependency(workspaceRoot: string, scope: string, remote: WorkspaceApp): void;
 export declare function addShellWorkspaceDependency(workspaceRoot: string, scope: string, remote: WorkspaceApp): void;
 export declare function verticalTopologyEntry(scope: string, vertical: WorkspaceApp, remotes?: WorkspaceApp[]): JsonValue;

package/dist/types/ultramodern-workspace/bridge-config.d.ts

@@ -0,0 +1,64 @@
+export declare const ultramodernBridgeCliFlags: {
+    readonly enabled: '--bridge';
+    readonly parentRoot: '--bridge-parent-root';
+    readonly workspacePackage: '--bridge-workspace-package';
+    readonly workspacePackageName: '--bridge-workspace-package-name';
+    readonly testAlias: '--bridge-test-alias';
+    readonly dependency: '--bridge-dependency';
+    readonly lockfilePolicy: '--bridge-lockfile-policy';
+    readonly gate: '--bridge-gate';
+    readonly gateCwd: '--bridge-gate-cwd';
+    readonly reactSingleton: '--bridge-react-singleton';
+};
+export declare const ultramodernBridgeCliValueFlags: readonly ["--bridge-parent-root", "--bridge-workspace-package", "--bridge-workspace-package-name", "--bridge-test-alias", "--bridge-dependency", "--bridge-lockfile-policy", "--bridge-gate", "--bridge-gate-cwd", "--bridge-react-singleton"];
+export declare const ultramodernBridgeCliBooleanFlags: readonly ["--bridge"];
+export declare const ultramodernBridgeLockfilePolicies: readonly ['nested', 'parent'];
+export type UltramodernBridgeLockfilePolicy = (typeof ultramodernBridgeLockfilePolicies)[number];
+export type UltramodernBridgeTestAlias = {
+    alias: string;
+    target: string;
+};
+export type UltramodernBridgeWorkspacePackage = {
+    pattern: string;
+    packageNames?: string[];
+    testAliases?: UltramodernBridgeTestAlias[];
+};
+export type UltramodernBridgeGate = {
+    name: string;
+    command: string;
+    cwd?: string;
+};
+export type UltramodernBridgeConfig = {
+    enabled: true;
+    parentRoot: string;
+    workspacePackages: UltramodernBridgeWorkspacePackage[];
+    dependencies: string[];
+    lockfilePolicy: UltramodernBridgeLockfilePolicy;
+    gates: UltramodernBridgeGate[];
+    reactSingletons: string[];
+};
+export type UltramodernBridgeWorkspacePackageInput = {
+    pattern: string;
+    packageNames?: readonly string[];
+    testAliases?: readonly UltramodernBridgeTestAlias[];
+};
+export type UltramodernBridgeGateInput = {
+    name: string;
+    command: string;
+    cwd?: string;
+};
+export type UltramodernEnabledBridgeConfigInput = {
+    enabled?: true;
+    parentRoot: string;
+    workspacePackages: readonly UltramodernBridgeWorkspacePackageInput[];
+    dependencies: readonly string[];
+    lockfilePolicy?: UltramodernBridgeLockfilePolicy;
+    gates: readonly UltramodernBridgeGateInput[];
+    reactSingletons?: readonly string[];
+};
+export type UltramodernBridgeConfigInput = UltramodernEnabledBridgeConfigInput | {
+    enabled: false;
+};
+export declare function hasUltramodernBridgeCliOptions(args: string[]): boolean;
+export declare function parseUltramodernBridgeCliOptions(args: string[]): UltramodernBridgeConfig | undefined;
+export declare function normalizeUltramodernBridgeConfig(bridge: UltramodernBridgeConfigInput | undefined): UltramodernBridgeConfig | undefined;

package/dist/types/ultramodern-workspace/codesmith.d.ts

@@ -12,6 +12,7 @@ export type UltramodernCodeSmithConfig = {
     tailwind?: boolean;
     dryRun?: boolean;
     logResult?: boolean;
+    bridge?: UltramodernWorkspaceOptions['bridge'];
     overlays?: UltramodernWorkspaceOptions['overlays'];
     packageSource?: UltramodernWorkspaceOptions['packageSource'];
     packageSourceStrategy?: NonNullable<UltramodernWorkspaceOptions['packageSource']>['strategy'];

package/dist/types/ultramodern-workspace/contracts.d.ts

@@ -1,21 +1,6 @@
+import type { UltramodernBridgeConfig } from './bridge-config';
 import type { JsonValue, ResolvedPackageSource, WorkspaceApp } from './types';
-export declare const baselineAgentSkills: string[];
-export declare const moduleFederationAgentSkills: string[];
-export declare const privateAgentSkills: string[];
 export declare function createTopology(scope: string, remotes?: WorkspaceApp[]): JsonValue;
 export declare function createOwnership(scope: string, remotes?: WorkspaceApp[]): JsonValue;
 export declare function createDevelopmentOverlay(remotes?: WorkspaceApp[]): JsonValue;
-export declare function createPackageSourceMetadata(scope: string, packageSource: ResolvedPackageSource): JsonValue;
-export declare function createAppConfigContract(app: WorkspaceApp): JsonValue;
-export declare function createPerformanceReadinessContract(): JsonValue;
-export declare function cssLayerName(app: WorkspaceApp): string;
-export declare function cssRole(app: WorkspaceApp): string;
-export declare function cssClassPrefix(app: WorkspaceApp): string;
-export declare function createCssDedupeContract(scope: string): JsonValue;
-export declare function createCssSsrContract(app: WorkspaceApp): JsonValue;
-export declare function createAppCssFederationContract(scope: string, app: WorkspaceApp): JsonValue;
-export declare function createCssFederationContract(scope: string): JsonValue;
-export declare function createStylingContract(scope: string, app: WorkspaceApp, enableTailwind: boolean): JsonValue;
-export declare function createAppGeneratedContract(scope: string, app: WorkspaceApp, apps: WorkspaceApp[], enableTailwind: boolean): JsonValue;
-export declare function createGeneratedContract(scope: string, apps?: WorkspaceApp[], enableTailwind?: boolean): JsonValue;
-export declare function createTemplateManifest(modernVersion: string, packageSource: ResolvedPackageSource): JsonValue;
+export declare function createUltramodernConfig(scope: string, modernVersion: string, packageSource: ResolvedPackageSource, apps?: WorkspaceApp[], enableTailwind?: boolean, bridge?: UltramodernBridgeConfig): JsonValue;

package/dist/types/ultramodern-workspace/descriptors.d.ts

@@ -1,5 +1,6 @@
 import type { Ownership, WorkspaceApp, WorkspaceEffectApi } from './types';
 export declare const GENERATED_CONTRACT_PATH = ".modernjs/ultramodern-generated-contract.json";
+export declare const ULTRAMODERN_CONFIG_PATH = ".modernjs/ultramodern.json";
 export declare const shellApp: WorkspaceApp;
 export declare function createShellHost(remotes?: WorkspaceApp[]): WorkspaceApp;
 export declare const sharedPackages: {

package/dist/types/ultramodern-workspace/index.d.ts

@@ -1,4 +1,6 @@
 export { addUltramodernVertical, planUltramodernVertical, } from './add-vertical';
+export type { UltramodernBridgeConfig, UltramodernBridgeConfigInput, UltramodernBridgeGate, UltramodernBridgeGateInput, UltramodernBridgeLockfilePolicy, UltramodernBridgeTestAlias, UltramodernBridgeWorkspacePackage, UltramodernBridgeWorkspacePackageInput, UltramodernEnabledBridgeConfigInput, } from './bridge-config';
+export { normalizeUltramodernBridgeConfig } from './bridge-config';
 export type { AddUltramodernVerticalOptions, UltramodernCodeSmithOverlay, UltramodernCodeSmithOverlayRuntimeConfig, UltramodernGeneratedAppDescriptor, UltramodernGeneratedContractChange, UltramodernGenerationOperation, UltramodernGenerationResult, UltramodernGenerationWarning, UltramodernJsonMutation, UltramodernShellDependencyChange, UltramodernVerticalPlan, UltramodernWorkspaceOptions, } from './types';
 export { ultramodernWorkspaceVersions } from './versions';
 export { generateUltramodernWorkspace } from './write-workspace';

package/dist/types/ultramodern-workspace/mf-validation.d.ts

@@ -0,0 +1,27 @@
+export type ModuleFederationConfigInspection = {
+    appDir: string;
+    configPath: string;
+    dts: {
+        compilerInstance?: string;
+        tsConfigPath?: string;
+    };
+    exposes: string[];
+    hostOnlyNoExposes: boolean;
+};
+export type ModuleFederationDiscoveredConfig = {
+    appDir: string;
+    configPath: string;
+};
+export type ModuleFederationValidationResult = {
+    configCount: number;
+    exposedAppCount: number;
+    hostOnlyAppCount: number;
+    apps: ModuleFederationConfigInspection[];
+};
+export type ModuleFederationValidationOptions = {
+    workspaceRoot: string;
+    appDirs?: string[];
+};
+export declare function discoverModuleFederationConfigs(options: ModuleFederationValidationOptions): ModuleFederationDiscoveredConfig[];
+export declare function inspectModuleFederationConfigSource(source: string, appDir: string, configPath: string): ModuleFederationConfigInspection;
+export declare function validateModuleFederationTypes(options: ModuleFederationValidationOptions): ModuleFederationValidationResult;

package/dist/types/ultramodern-workspace/package-json.d.ts

@@ -1,9 +1,10 @@
+import type { UltramodernBridgeConfig } from './bridge-config';
 import type { JsonValue, ResolvedPackageSource, WorkspaceApp } from './types';
 export declare const createEffectTsgoTypecheckCommand: (packageDir: string) => string;
 export declare const effectDiagnostics: string[];
-export declare function appDependencies(scope: string, packageSource: ResolvedPackageSource, app: WorkspaceApp, remotes?: WorkspaceApp[]): Record<string, string>;
+export declare function appDependencies(scope: string, packageSource: ResolvedPackageSource, app: WorkspaceApp, remotes?: WorkspaceApp[], bridge?: UltramodernBridgeConfig): Record<string, string>;
 export declare function appDevDependencies(packageSource: ResolvedPackageSource, enableTailwind: boolean): Record<string, string>;
-export declare function createRootPackageJson(scope: string, packageSource: ResolvedPackageSource, remotes?: WorkspaceApp[]): JsonValue;
+export declare function createRootPackageJson(scope: string, packageSource: ResolvedPackageSource, remotes?: WorkspaceApp[], bridge?: UltramodernBridgeConfig): JsonValue;
 export declare function createZephyrDependencies(scope: string, app: WorkspaceApp, remotes?: WorkspaceApp[]): JsonValue;
 export declare function createTsConfigBase(): JsonValue;
 type CreatePackageTsConfigOptions = {
@@ -16,7 +17,7 @@ export declare function createAppTsConfig(app: WorkspaceApp, remotes?: Workspace
 export declare function createAppMfTypesTsConfig(app: WorkspaceApp): JsonValue;
 export declare function createSharedPackageTsConfig(packageDir: string): JsonValue;
 export declare function createRootTsConfig(apps?: WorkspaceApp[]): JsonValue;
-export declare function createAppPackage(scope: string, app: WorkspaceApp, packageSource: ResolvedPackageSource, enableTailwind: boolean, remotes?: WorkspaceApp[]): JsonValue;
+export declare function createAppPackage(scope: string, app: WorkspaceApp, packageSource: ResolvedPackageSource, enableTailwind: boolean, remotes?: WorkspaceApp[], bridge?: UltramodernBridgeConfig): JsonValue;
 export declare function createSharedPackage(scope: string, id: string, description: string): JsonValue;
 export declare function createSharedContractsIndex(): string;
 export {};