@bleedingdev/modern-js-ultramodern-app-tools 3.9.0-ultramodern.16 → 3.9.0-ultramodern.18

package/dist/cjs/native-composition/module-federation-shared-plugin.js

@@ -0,0 +1,236 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    FederationPrivateContextsPlugin: ()=>FederationPrivateContextsPlugin,
+    resolveFrameworkSharedPackages: ()=>resolveFrameworkSharedPackages,
+    ultramodernModuleFederationSharedPlugin: ()=>ultramodernModuleFederationSharedPlugin,
+    withFrameworkShared: ()=>withFrameworkShared,
+    withReactJsxRuntimeShared: ()=>withReactJsxRuntimeShared
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const REACT_JSX_RUNTIMES = [
+    'react/jsx-runtime',
+    'react/jsx-dev-runtime'
+];
+const MODULE_FEDERATION_CHAIN_IDS = [
+    'plugin-module-federation',
+    'plugin-module-federation-server'
+];
+const FRAMEWORK_SHARES = [
+    {
+        packageName: '@modern-js/runtime',
+        prefix: '@modern-js/runtime/',
+        contextsRequest: '@modern-js/runtime/context',
+        contexts: /[\\/]core[\\/]context[\\/](?:index|runtime)\.[cm]?[jt]sx?$/
+    },
+    {
+        packageName: '@modern-js/plugin-i18n',
+        prefix: '@modern-js/plugin-i18n/runtime/',
+        contextsRequest: '@modern-js/plugin-i18n/runtime/contexts',
+        contexts: /[\\/]runtime[\\/]contexts\.[cm]?[jt]sx?$/
+    },
+    {
+        packageName: '@modern-js/bff-effect',
+        prefix: '@modern-js/bff-effect/',
+        contextsRequest: '@modern-js/bff-effect/context',
+        contexts: /[\\/]effect[\\/]context\.[cm]?[jt]sx?$/
+    }
+];
+const loadsCode = (target)=>'string' == typeof target ? !target.endsWith('.d.ts') : Boolean(target) && 'object' == typeof target && Object.entries(target).some(([condition, value])=>'types' !== condition && loadsCode(value));
+const exportedRequests = (packageName, prefix, exports1)=>Object.entries(exports1 && 'object' == typeof exports1 ? exports1 : {}).filter(([subpath, target])=>'./package.json' !== subpath && !subpath.includes('*') && loadsCode(target)).map(([subpath])=>`${packageName}${subpath.slice(1)}`).filter((request)=>request.startsWith(prefix)).sort();
+const findInstalledManifest = (appDirectory, packageName)=>{
+    for(let directory = appDirectory;;){
+        const manifest = external_node_path_default().join(directory, 'node_modules', packageName, 'package.json');
+        if ((0, external_node_fs_namespaceObject.existsSync)(manifest)) return manifest;
+        const parent = external_node_path_default().dirname(directory);
+        if (parent === directory) return;
+        directory = parent;
+    }
+};
+const resolveFrameworkSharedPackages = (appDirectory)=>FRAMEWORK_SHARES.flatMap((share)=>{
+        const manifest = findInstalledManifest(appDirectory, share.packageName);
+        if (!manifest) return [];
+        const { version, exports: exports1 } = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(manifest, 'utf8'));
+        return [
+            {
+                ...share,
+                version,
+                requests: exportedRequests(share.packageName, share.prefix, exports1),
+                directory: (0, external_node_fs_namespaceObject.realpathSync)(external_node_path_default().dirname(manifest))
+            }
+        ];
+    });
+const findShared = (entries, request)=>{
+    for (const entry of entries){
+        if (entry === request) return {};
+        if ('object' == typeof entry && Object.hasOwn(entry, request)) {
+            const config = entry[request];
+            return 'string' == typeof config ? {
+                requiredVersion: config
+            } : config;
+        }
+    }
+};
+const toEntries = (shared)=>Array.isArray(shared) ? shared : [
+        shared
+    ];
+const withShared = (shared, missing)=>{
+    const entries = toEntries(shared);
+    const added = Object.fromEntries(Object.entries(missing).filter(([request])=>!findShared(entries, request)));
+    if (0 === Object.keys(added).length) return shared;
+    if (!shared) return added;
+    return Array.isArray(shared) ? [
+        ...shared,
+        added
+    ] : {
+        ...shared,
+        ...added
+    };
+};
+const withReactJsxRuntimeShared = (shared)=>{
+    if (!shared || 'object' != typeof shared) return shared;
+    const react = findShared(toEntries(shared), 'react');
+    if (!react) return shared;
+    return withShared(shared, Object.fromEntries(REACT_JSX_RUNTIMES.map((request)=>[
+            request,
+            {
+                ...void 0 === react.requiredVersion ? {} : {
+                    requiredVersion: react.requiredVersion
+                },
+                singleton: true,
+                treeShaking: false
+            }
+        ])));
+};
+const withFrameworkShared = (shared, packages)=>withShared(shared, Object.fromEntries(packages.flatMap(({ requests, version })=>requests.map((request)=>[
+                request,
+                {
+                    requiredVersion: version,
+                    singleton: true,
+                    treeShaking: false
+                }
+            ]))));
+const federationConfig = (options)=>options.mfConfig && 'object' == typeof options.mfConfig ? federationConfig(options.mfConfig) : options;
+const withDefaults = (options, packages)=>options.mfConfig && 'object' == typeof options.mfConfig ? {
+        ...options,
+        mfConfig: withDefaults(options.mfConfig, packages)
+    } : {
+        ...options,
+        shared: withFrameworkShared(withReactJsxRuntimeShared(options.shared), packages)
+    };
+const hasExposes = (options)=>{
+    const { exposes } = federationConfig(options);
+    return Array.isArray(exposes) ? exposes.length > 0 : Boolean(exposes) && Object.keys(exposes).length > 0;
+};
+const SHARED_MODULE_TYPES = new Set([
+    'consume-shared-module',
+    'provide-module'
+]);
+const resourceOf = (module)=>module && 'resource' in module && 'string' == typeof module.resource ? module.resource : void 0;
+const describeModule = (module)=>module ? resourceOf(module) ?? module.identifier() : 'an entry';
+const CONTAINER_ENTRY_DEPENDENCY = 'container entry';
+const buildsContainer = (compilation)=>[
+        ...compilation.entries.values()
+    ].some(({ dependencies })=>dependencies.some(({ type })=>type === CONTAINER_ENTRY_DEPENDENCY));
+class FederationPrivateContextsPlugin {
+    apply(compiler) {
+        const name = 'FederationPrivateContextsPlugin';
+        const definitionOf = (module)=>{
+            const resource = resourceOf(module);
+            return void 0 === resource ? void 0 : this.packages.find(({ contexts, directory })=>contexts?.test(resource) && resource.startsWith(directory + external_node_path_default().sep));
+        };
+        compiler.hooks.compilation.tap(name, (compilation)=>{
+            compilation.hooks.finishModules.tap(name, (modules)=>{
+                if (!buildsContainer(compilation)) return;
+                for (const module of modules){
+                    const share = definitionOf(module);
+                    if (!share) continue;
+                    const importer = compilation.moduleGraph.getIncomingConnections(module).map((connection)=>connection.originModule).find((origin)=>!(origin && SHARED_MODULE_TYPES.has(origin.type)) && definitionOf(origin) !== share);
+                    if (void 0 !== importer) compilation.errors.push(new compiler.webpack.WebpackError(`[ultramodern] This Module Federation build bundles a private copy of ${share.contextsRequest}: ${describeModule(importer)} imports ${describeModule(module)} directly. It would not see the host's request state. Share the "${share.prefix}" subpaths and import the contexts through "${share.contextsRequest}".`));
+                }
+            });
+        });
+    }
+    constructor(packages){
+        this.packages = packages;
+    }
+}
+const ultramodernModuleFederationSharedPlugin = ()=>({
+        name: '@modern-js/ultramodern-module-federation-shared',
+        pre: [
+            '@modern-js/plugin-module-federation',
+            '@modern-js/plugin-module-federation-ssr'
+        ],
+        setup (api) {
+            api.modifyBundlerChain((chain)=>{
+                const ids = MODULE_FEDERATION_CHAIN_IDS.filter((id)=>chain.plugins.has(id));
+                if (0 === ids.length) return;
+                const packages = resolveFrameworkSharedPackages(api.getAppContext().appDirectory);
+                let exposes = false;
+                for (const id of ids){
+                    const [options] = chain.plugin(id).get('args');
+                    exposes ||= hasExposes(options);
+                    chain.plugin(id).tap(([options, ...rest])=>[
+                            withDefaults(options, packages),
+                            ...rest
+                        ]);
+                }
+                if (exposes) chain.plugin('ultramodern-federation-private-contexts').use(FederationPrivateContextsPlugin, [
+                    packages
+                ]);
+            });
+        }
+    });
+exports.FederationPrivateContextsPlugin = __webpack_exports__.FederationPrivateContextsPlugin;
+exports.resolveFrameworkSharedPackages = __webpack_exports__.resolveFrameworkSharedPackages;
+exports.ultramodernModuleFederationSharedPlugin = __webpack_exports__.ultramodernModuleFederationSharedPlugin;
+exports.withFrameworkShared = __webpack_exports__.withFrameworkShared;
+exports.withReactJsxRuntimeShared = __webpack_exports__.withReactJsxRuntimeShared;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "FederationPrivateContextsPlugin",
+    "resolveFrameworkSharedPackages",
+    "ultramodernModuleFederationSharedPlugin",
+    "withFrameworkShared",
+    "withReactJsxRuntimeShared"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/native-composition/preset.js

@@ -51,6 +51,7 @@ const release_identity_namespaceObject = require("@modern-js/app-tools-extension
 const runtime_package_resolution_namespaceObject = require("@modern-js/app-tools-extensions/runtime-package-resolution");
 const cli_namespaceObject = require("@modern-js/plugin/cli");
 const core_namespaceObject = require("@rsbuild/core");
+const external_module_federation_shared_plugin_js_namespaceObject = require("./module-federation-shared-plugin.js");
 const DEFAULT_OTLP_ENDPOINT = 'http://127.0.0.1:4318/v1/logs';
 const DEFAULT_VICTORIA_METRICS_ENDPOINT = 'http://127.0.0.1:8428/api/v1/import/prometheus';
 const resolveReactRouterPackageDir = (appDirectory)=>{
@@ -111,6 +112,9 @@ const createPresetUltramodernConfig = (options = {})=>{
         output: {
             precompress: true
         },
+        plugins: [
+            (0, external_module_federation_shared_plugin_js_namespaceObject.ultramodernModuleFederationSharedPlugin)()
+        ],
         server,
         source: {
             reactCompiler: true,

package/dist/esm/native-composition/module-federation-shared-plugin.mjs

@@ -0,0 +1,176 @@
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import node_path from "node:path";
+const REACT_JSX_RUNTIMES = [
+    'react/jsx-runtime',
+    'react/jsx-dev-runtime'
+];
+const MODULE_FEDERATION_CHAIN_IDS = [
+    'plugin-module-federation',
+    'plugin-module-federation-server'
+];
+const FRAMEWORK_SHARES = [
+    {
+        packageName: '@modern-js/runtime',
+        prefix: '@modern-js/runtime/',
+        contextsRequest: '@modern-js/runtime/context',
+        contexts: /[\\/]core[\\/]context[\\/](?:index|runtime)\.[cm]?[jt]sx?$/
+    },
+    {
+        packageName: '@modern-js/plugin-i18n',
+        prefix: '@modern-js/plugin-i18n/runtime/',
+        contextsRequest: '@modern-js/plugin-i18n/runtime/contexts',
+        contexts: /[\\/]runtime[\\/]contexts\.[cm]?[jt]sx?$/
+    },
+    {
+        packageName: '@modern-js/bff-effect',
+        prefix: '@modern-js/bff-effect/',
+        contextsRequest: '@modern-js/bff-effect/context',
+        contexts: /[\\/]effect[\\/]context\.[cm]?[jt]sx?$/
+    }
+];
+const loadsCode = (target)=>'string' == typeof target ? !target.endsWith('.d.ts') : Boolean(target) && 'object' == typeof target && Object.entries(target).some(([condition, value])=>'types' !== condition && loadsCode(value));
+const exportedRequests = (packageName, prefix, exports)=>Object.entries(exports && 'object' == typeof exports ? exports : {}).filter(([subpath, target])=>'./package.json' !== subpath && !subpath.includes('*') && loadsCode(target)).map(([subpath])=>`${packageName}${subpath.slice(1)}`).filter((request)=>request.startsWith(prefix)).sort();
+const findInstalledManifest = (appDirectory, packageName)=>{
+    for(let directory = appDirectory;;){
+        const manifest = node_path.join(directory, 'node_modules', packageName, 'package.json');
+        if (existsSync(manifest)) return manifest;
+        const parent = node_path.dirname(directory);
+        if (parent === directory) return;
+        directory = parent;
+    }
+};
+const resolveFrameworkSharedPackages = (appDirectory)=>FRAMEWORK_SHARES.flatMap((share)=>{
+        const manifest = findInstalledManifest(appDirectory, share.packageName);
+        if (!manifest) return [];
+        const { version, exports } = JSON.parse(readFileSync(manifest, 'utf8'));
+        return [
+            {
+                ...share,
+                version,
+                requests: exportedRequests(share.packageName, share.prefix, exports),
+                directory: realpathSync(node_path.dirname(manifest))
+            }
+        ];
+    });
+const findShared = (entries, request)=>{
+    for (const entry of entries){
+        if (entry === request) return {};
+        if ('object' == typeof entry && Object.hasOwn(entry, request)) {
+            const config = entry[request];
+            return 'string' == typeof config ? {
+                requiredVersion: config
+            } : config;
+        }
+    }
+};
+const toEntries = (shared)=>Array.isArray(shared) ? shared : [
+        shared
+    ];
+const withShared = (shared, missing)=>{
+    const entries = toEntries(shared);
+    const added = Object.fromEntries(Object.entries(missing).filter(([request])=>!findShared(entries, request)));
+    if (0 === Object.keys(added).length) return shared;
+    if (!shared) return added;
+    return Array.isArray(shared) ? [
+        ...shared,
+        added
+    ] : {
+        ...shared,
+        ...added
+    };
+};
+const withReactJsxRuntimeShared = (shared)=>{
+    if (!shared || 'object' != typeof shared) return shared;
+    const react = findShared(toEntries(shared), 'react');
+    if (!react) return shared;
+    return withShared(shared, Object.fromEntries(REACT_JSX_RUNTIMES.map((request)=>[
+            request,
+            {
+                ...void 0 === react.requiredVersion ? {} : {
+                    requiredVersion: react.requiredVersion
+                },
+                singleton: true,
+                treeShaking: false
+            }
+        ])));
+};
+const withFrameworkShared = (shared, packages)=>withShared(shared, Object.fromEntries(packages.flatMap(({ requests, version })=>requests.map((request)=>[
+                request,
+                {
+                    requiredVersion: version,
+                    singleton: true,
+                    treeShaking: false
+                }
+            ]))));
+const federationConfig = (options)=>options.mfConfig && 'object' == typeof options.mfConfig ? federationConfig(options.mfConfig) : options;
+const withDefaults = (options, packages)=>options.mfConfig && 'object' == typeof options.mfConfig ? {
+        ...options,
+        mfConfig: withDefaults(options.mfConfig, packages)
+    } : {
+        ...options,
+        shared: withFrameworkShared(withReactJsxRuntimeShared(options.shared), packages)
+    };
+const hasExposes = (options)=>{
+    const { exposes } = federationConfig(options);
+    return Array.isArray(exposes) ? exposes.length > 0 : Boolean(exposes) && Object.keys(exposes).length > 0;
+};
+const SHARED_MODULE_TYPES = new Set([
+    'consume-shared-module',
+    'provide-module'
+]);
+const resourceOf = (module)=>module && 'resource' in module && 'string' == typeof module.resource ? module.resource : void 0;
+const describeModule = (module)=>module ? resourceOf(module) ?? module.identifier() : 'an entry';
+const CONTAINER_ENTRY_DEPENDENCY = 'container entry';
+const buildsContainer = (compilation)=>[
+        ...compilation.entries.values()
+    ].some(({ dependencies })=>dependencies.some(({ type })=>type === CONTAINER_ENTRY_DEPENDENCY));
+class FederationPrivateContextsPlugin {
+    apply(compiler) {
+        const name = 'FederationPrivateContextsPlugin';
+        const definitionOf = (module)=>{
+            const resource = resourceOf(module);
+            return void 0 === resource ? void 0 : this.packages.find(({ contexts, directory })=>contexts?.test(resource) && resource.startsWith(directory + node_path.sep));
+        };
+        compiler.hooks.compilation.tap(name, (compilation)=>{
+            compilation.hooks.finishModules.tap(name, (modules)=>{
+                if (!buildsContainer(compilation)) return;
+                for (const module of modules){
+                    const share = definitionOf(module);
+                    if (!share) continue;
+                    const importer = compilation.moduleGraph.getIncomingConnections(module).map((connection)=>connection.originModule).find((origin)=>!(origin && SHARED_MODULE_TYPES.has(origin.type)) && definitionOf(origin) !== share);
+                    if (void 0 !== importer) compilation.errors.push(new compiler.webpack.WebpackError(`[ultramodern] This Module Federation build bundles a private copy of ${share.contextsRequest}: ${describeModule(importer)} imports ${describeModule(module)} directly. It would not see the host's request state. Share the "${share.prefix}" subpaths and import the contexts through "${share.contextsRequest}".`));
+                }
+            });
+        });
+    }
+    constructor(packages){
+        this.packages = packages;
+    }
+}
+const ultramodernModuleFederationSharedPlugin = ()=>({
+        name: '@modern-js/ultramodern-module-federation-shared',
+        pre: [
+            '@modern-js/plugin-module-federation',
+            '@modern-js/plugin-module-federation-ssr'
+        ],
+        setup (api) {
+            api.modifyBundlerChain((chain)=>{
+                const ids = MODULE_FEDERATION_CHAIN_IDS.filter((id)=>chain.plugins.has(id));
+                if (0 === ids.length) return;
+                const packages = resolveFrameworkSharedPackages(api.getAppContext().appDirectory);
+                let exposes = false;
+                for (const id of ids){
+                    const [options] = chain.plugin(id).get('args');
+                    exposes ||= hasExposes(options);
+                    chain.plugin(id).tap(([options, ...rest])=>[
+                            withDefaults(options, packages),
+                            ...rest
+                        ]);
+                }
+                if (exposes) chain.plugin('ultramodern-federation-private-contexts').use(FederationPrivateContextsPlugin, [
+                    packages
+                ]);
+            });
+        }
+    });
+export { FederationPrivateContextsPlugin, resolveFrameworkSharedPackages, ultramodernModuleFederationSharedPlugin, withFrameworkShared, withReactJsxRuntimeShared };

package/dist/esm/native-composition/preset.mjs

@@ -7,6 +7,7 @@ import { resolveUltramodernReleaseIdentity } from "@modern-js/app-tools-extensio
 import { findHostingModuleDirectory } from "@modern-js/app-tools-extensions/runtime-package-resolution";
 import { mergeConfig } from "@modern-js/plugin/cli";
 import { rspack } from "@rsbuild/core";
+import { ultramodernModuleFederationSharedPlugin } from "./module-federation-shared-plugin.mjs";
 const DEFAULT_OTLP_ENDPOINT = 'http://127.0.0.1:4318/v1/logs';
 const DEFAULT_VICTORIA_METRICS_ENDPOINT = 'http://127.0.0.1:8428/api/v1/import/prometheus';
 const resolveReactRouterPackageDir = (appDirectory)=>{
@@ -67,6 +68,9 @@ const createPresetUltramodernConfig = (options = {})=>{
         output: {
             precompress: true
         },
+        plugins: [
+            ultramodernModuleFederationSharedPlugin()
+        ],
         server,
         source: {
             reactCompiler: true,

package/dist/esm-node/native-composition/module-federation-shared-plugin.mjs

@@ -0,0 +1,177 @@
+import "node:module";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import node_path from "node:path";
+const REACT_JSX_RUNTIMES = [
+    'react/jsx-runtime',
+    'react/jsx-dev-runtime'
+];
+const MODULE_FEDERATION_CHAIN_IDS = [
+    'plugin-module-federation',
+    'plugin-module-federation-server'
+];
+const FRAMEWORK_SHARES = [
+    {
+        packageName: '@modern-js/runtime',
+        prefix: '@modern-js/runtime/',
+        contextsRequest: '@modern-js/runtime/context',
+        contexts: /[\\/]core[\\/]context[\\/](?:index|runtime)\.[cm]?[jt]sx?$/
+    },
+    {
+        packageName: '@modern-js/plugin-i18n',
+        prefix: '@modern-js/plugin-i18n/runtime/',
+        contextsRequest: '@modern-js/plugin-i18n/runtime/contexts',
+        contexts: /[\\/]runtime[\\/]contexts\.[cm]?[jt]sx?$/
+    },
+    {
+        packageName: '@modern-js/bff-effect',
+        prefix: '@modern-js/bff-effect/',
+        contextsRequest: '@modern-js/bff-effect/context',
+        contexts: /[\\/]effect[\\/]context\.[cm]?[jt]sx?$/
+    }
+];
+const loadsCode = (target)=>'string' == typeof target ? !target.endsWith('.d.ts') : Boolean(target) && 'object' == typeof target && Object.entries(target).some(([condition, value])=>'types' !== condition && loadsCode(value));
+const exportedRequests = (packageName, prefix, exports)=>Object.entries(exports && 'object' == typeof exports ? exports : {}).filter(([subpath, target])=>'./package.json' !== subpath && !subpath.includes('*') && loadsCode(target)).map(([subpath])=>`${packageName}${subpath.slice(1)}`).filter((request)=>request.startsWith(prefix)).sort();
+const findInstalledManifest = (appDirectory, packageName)=>{
+    for(let directory = appDirectory;;){
+        const manifest = node_path.join(directory, 'node_modules', packageName, 'package.json');
+        if (existsSync(manifest)) return manifest;
+        const parent = node_path.dirname(directory);
+        if (parent === directory) return;
+        directory = parent;
+    }
+};
+const resolveFrameworkSharedPackages = (appDirectory)=>FRAMEWORK_SHARES.flatMap((share)=>{
+        const manifest = findInstalledManifest(appDirectory, share.packageName);
+        if (!manifest) return [];
+        const { version, exports } = JSON.parse(readFileSync(manifest, 'utf8'));
+        return [
+            {
+                ...share,
+                version,
+                requests: exportedRequests(share.packageName, share.prefix, exports),
+                directory: realpathSync(node_path.dirname(manifest))
+            }
+        ];
+    });
+const findShared = (entries, request)=>{
+    for (const entry of entries){
+        if (entry === request) return {};
+        if ('object' == typeof entry && Object.hasOwn(entry, request)) {
+            const config = entry[request];
+            return 'string' == typeof config ? {
+                requiredVersion: config
+            } : config;
+        }
+    }
+};
+const toEntries = (shared)=>Array.isArray(shared) ? shared : [
+        shared
+    ];
+const withShared = (shared, missing)=>{
+    const entries = toEntries(shared);
+    const added = Object.fromEntries(Object.entries(missing).filter(([request])=>!findShared(entries, request)));
+    if (0 === Object.keys(added).length) return shared;
+    if (!shared) return added;
+    return Array.isArray(shared) ? [
+        ...shared,
+        added
+    ] : {
+        ...shared,
+        ...added
+    };
+};
+const withReactJsxRuntimeShared = (shared)=>{
+    if (!shared || 'object' != typeof shared) return shared;
+    const react = findShared(toEntries(shared), 'react');
+    if (!react) return shared;
+    return withShared(shared, Object.fromEntries(REACT_JSX_RUNTIMES.map((request)=>[
+            request,
+            {
+                ...void 0 === react.requiredVersion ? {} : {
+                    requiredVersion: react.requiredVersion
+                },
+                singleton: true,
+                treeShaking: false
+            }
+        ])));
+};
+const withFrameworkShared = (shared, packages)=>withShared(shared, Object.fromEntries(packages.flatMap(({ requests, version })=>requests.map((request)=>[
+                request,
+                {
+                    requiredVersion: version,
+                    singleton: true,
+                    treeShaking: false
+                }
+            ]))));
+const federationConfig = (options)=>options.mfConfig && 'object' == typeof options.mfConfig ? federationConfig(options.mfConfig) : options;
+const withDefaults = (options, packages)=>options.mfConfig && 'object' == typeof options.mfConfig ? {
+        ...options,
+        mfConfig: withDefaults(options.mfConfig, packages)
+    } : {
+        ...options,
+        shared: withFrameworkShared(withReactJsxRuntimeShared(options.shared), packages)
+    };
+const hasExposes = (options)=>{
+    const { exposes } = federationConfig(options);
+    return Array.isArray(exposes) ? exposes.length > 0 : Boolean(exposes) && Object.keys(exposes).length > 0;
+};
+const SHARED_MODULE_TYPES = new Set([
+    'consume-shared-module',
+    'provide-module'
+]);
+const resourceOf = (module)=>module && 'resource' in module && 'string' == typeof module.resource ? module.resource : void 0;
+const describeModule = (module)=>module ? resourceOf(module) ?? module.identifier() : 'an entry';
+const CONTAINER_ENTRY_DEPENDENCY = 'container entry';
+const buildsContainer = (compilation)=>[
+        ...compilation.entries.values()
+    ].some(({ dependencies })=>dependencies.some(({ type })=>type === CONTAINER_ENTRY_DEPENDENCY));
+class FederationPrivateContextsPlugin {
+    apply(compiler) {
+        const name = 'FederationPrivateContextsPlugin';
+        const definitionOf = (module)=>{
+            const resource = resourceOf(module);
+            return void 0 === resource ? void 0 : this.packages.find(({ contexts, directory })=>contexts?.test(resource) && resource.startsWith(directory + node_path.sep));
+        };
+        compiler.hooks.compilation.tap(name, (compilation)=>{
+            compilation.hooks.finishModules.tap(name, (modules)=>{
+                if (!buildsContainer(compilation)) return;
+                for (const module of modules){
+                    const share = definitionOf(module);
+                    if (!share) continue;
+                    const importer = compilation.moduleGraph.getIncomingConnections(module).map((connection)=>connection.originModule).find((origin)=>!(origin && SHARED_MODULE_TYPES.has(origin.type)) && definitionOf(origin) !== share);
+                    if (void 0 !== importer) compilation.errors.push(new compiler.webpack.WebpackError(`[ultramodern] This Module Federation build bundles a private copy of ${share.contextsRequest}: ${describeModule(importer)} imports ${describeModule(module)} directly. It would not see the host's request state. Share the "${share.prefix}" subpaths and import the contexts through "${share.contextsRequest}".`));
+                }
+            });
+        });
+    }
+    constructor(packages){
+        this.packages = packages;
+    }
+}
+const ultramodernModuleFederationSharedPlugin = ()=>({
+        name: '@modern-js/ultramodern-module-federation-shared',
+        pre: [
+            '@modern-js/plugin-module-federation',
+            '@modern-js/plugin-module-federation-ssr'
+        ],
+        setup (api) {
+            api.modifyBundlerChain((chain)=>{
+                const ids = MODULE_FEDERATION_CHAIN_IDS.filter((id)=>chain.plugins.has(id));
+                if (0 === ids.length) return;
+                const packages = resolveFrameworkSharedPackages(api.getAppContext().appDirectory);
+                let exposes = false;
+                for (const id of ids){
+                    const [options] = chain.plugin(id).get('args');
+                    exposes ||= hasExposes(options);
+                    chain.plugin(id).tap(([options, ...rest])=>[
+                            withDefaults(options, packages),
+                            ...rest
+                        ]);
+                }
+                if (exposes) chain.plugin('ultramodern-federation-private-contexts').use(FederationPrivateContextsPlugin, [
+                    packages
+                ]);
+            });
+        }
+    });
+export { FederationPrivateContextsPlugin, resolveFrameworkSharedPackages, ultramodernModuleFederationSharedPlugin, withFrameworkShared, withReactJsxRuntimeShared };

package/dist/esm-node/native-composition/preset.mjs

@@ -8,6 +8,7 @@ import { resolveUltramodernReleaseIdentity } from "@modern-js/app-tools-extensio
 import { findHostingModuleDirectory } from "@modern-js/app-tools-extensions/runtime-package-resolution";
 import { mergeConfig } from "@modern-js/plugin/cli";
 import { rspack } from "@rsbuild/core";
+import { ultramodernModuleFederationSharedPlugin } from "./module-federation-shared-plugin.mjs";
 const DEFAULT_OTLP_ENDPOINT = 'http://127.0.0.1:4318/v1/logs';
 const DEFAULT_VICTORIA_METRICS_ENDPOINT = 'http://127.0.0.1:8428/api/v1/import/prometheus';
 const resolveReactRouterPackageDir = (appDirectory)=>{
@@ -68,6 +69,9 @@ const createPresetUltramodernConfig = (options = {})=>{
         output: {
             precompress: true
         },
+        plugins: [
+            ultramodernModuleFederationSharedPlugin()
+        ],
         server,
         source: {
             reactCompiler: true,

package/dist/types/native-composition/module-federation-shared-plugin.d.ts

@@ -0,0 +1,45 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+import type { Rspack } from '@rsbuild/core';
+export type FrameworkSharedPackage = {
+    prefix: string;
+    version: string;
+    /** Exported subpath requests under `prefix` that load code. */
+    requests: string[];
+    /** Real path of the installed package directory. */
+    directory: string;
+    contextsRequest?: string;
+    contexts?: RegExp;
+};
+/** The framework packages the app installs, with their installed versions. */
+export declare const resolveFrameworkSharedPackages: (appDirectory: string) => FrameworkSharedPackage[];
+/**
+ * Share `react/jsx-runtime` and `react/jsx-dev-runtime` as singletons at the
+ * shared `react` version whenever `react` itself is shared. Entries the app
+ * configured explicitly are kept as written.
+ */
+export declare const withReactJsxRuntimeShared: <T>(shared: T) => T;
+/**
+ * Share every exported subpath of the framework packages as a singleton at
+ * the installed version. Entries the app configured explicitly are kept.
+ */
+export declare const withFrameworkShared: <T>(shared: T, packages: FrameworkSharedPackage[]) => T;
+/**
+ * Fails a federation build that exposes modules when a framework context file
+ * is imported other than through its shared request. That remote would run
+ * with its own contexts and never see the host's request state.
+ *
+ * The check runs only when the compilation really builds a container: an
+ * environment may drop the federation plugin after the chain was configured
+ * (the Cloudflare workerd SSR graph does), and a graph with no container has
+ * no host to share contexts with.
+ */
+export declare class FederationPrivateContextsPlugin {
+    private readonly packages;
+    constructor(packages: FrameworkSharedPackage[]);
+    apply(compiler: Rspack.Compiler): void;
+}
+/**
+ * Apply UltraModern's Module Federation share defaults to the federation
+ * plugins that `@module-federation/modern-js-v3` registered on the chain.
+ */
+export declare const ultramodernModuleFederationSharedPlugin: () => CliPlugin<AppTools>;

package/dist/types-esm/native-composition/module-federation-shared-plugin.d.mts

@@ -0,0 +1,45 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+import type { Rspack } from '@rsbuild/core';
+export type FrameworkSharedPackage = {
+    prefix: string;
+    version: string;
+    /** Exported subpath requests under `prefix` that load code. */
+    requests: string[];
+    /** Real path of the installed package directory. */
+    directory: string;
+    contextsRequest?: string;
+    contexts?: RegExp;
+};
+/** The framework packages the app installs, with their installed versions. */
+export declare const resolveFrameworkSharedPackages: (appDirectory: string) => FrameworkSharedPackage[];
+/**
+ * Share `react/jsx-runtime` and `react/jsx-dev-runtime` as singletons at the
+ * shared `react` version whenever `react` itself is shared. Entries the app
+ * configured explicitly are kept as written.
+ */
+export declare const withReactJsxRuntimeShared: <T>(shared: T) => T;
+/**
+ * Share every exported subpath of the framework packages as a singleton at
+ * the installed version. Entries the app configured explicitly are kept.
+ */
+export declare const withFrameworkShared: <T>(shared: T, packages: FrameworkSharedPackage[]) => T;
+/**
+ * Fails a federation build that exposes modules when a framework context file
+ * is imported other than through its shared request. That remote would run
+ * with its own contexts and never see the host's request state.
+ *
+ * The check runs only when the compilation really builds a container: an
+ * environment may drop the federation plugin after the chain was configured
+ * (the Cloudflare workerd SSR graph does), and a graph with no container has
+ * no host to share contexts with.
+ */
+export declare class FederationPrivateContextsPlugin {
+    private readonly packages;
+    constructor(packages: FrameworkSharedPackage[]);
+    apply(compiler: Rspack.Compiler): void;
+}
+/**
+ * Apply UltraModern's Module Federation share defaults to the federation
+ * plugins that `@module-federation/modern-js-v3` registered on the chain.
+ */
+export declare const ultramodernModuleFederationSharedPlugin: () => CliPlugin<AppTools>;

package/package.json

@@ -11,7 +11,7 @@
     "directory": "packages/solutions/ultramodern-app-tools"
   },
   "license": "MIT",
-  "version": "3.9.0-ultramodern.16",
+  "version": "3.9.0-ultramodern.18",
   "files": [
     "dist",
     "src"
@@ -62,26 +62,26 @@
     "node": ">=26.7.0"
   },
   "dependencies": {
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.9.0-ultramodern.16",
-    "@modern-js/app-tools-extensions": "npm:@bleedingdev/modern-js-app-tools-extensions@3.9.0-ultramodern.16",
-    "@modern-js/i18n-integration": "npm:@bleedingdev/modern-js-i18n-integration@3.9.0-ultramodern.16",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.16",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.16",
-    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.16",
-    "@modern-js/runtime-renderer-extensions": "npm:@bleedingdev/modern-js-runtime-renderer-extensions@3.9.0-ultramodern.16",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.0-ultramodern.16",
-    "@modern-js/server-runtime-extensions": "npm:@bleedingdev/modern-js-server-runtime-extensions@3.9.0-ultramodern.16",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.9.0-ultramodern.18",
+    "@modern-js/app-tools-extensions": "npm:@bleedingdev/modern-js-app-tools-extensions@3.9.0-ultramodern.18",
+    "@modern-js/i18n-integration": "npm:@bleedingdev/modern-js-i18n-integration@3.9.0-ultramodern.18",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.18",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.18",
+    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.18",
+    "@modern-js/runtime-renderer-extensions": "npm:@bleedingdev/modern-js-runtime-renderer-extensions@3.9.0-ultramodern.18",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.9.0-ultramodern.18",
+    "@modern-js/server-runtime-extensions": "npm:@bleedingdev/modern-js-server-runtime-extensions@3.9.0-ultramodern.18",
     "@rsbuild/core": "2.2.9"
   },
   "devDependencies": {
-    "@modern-js/backend-federation-contracts": "npm:@bleedingdev/modern-js-backend-federation-contracts@3.9.0-ultramodern.16",
-    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.9.0-ultramodern.16",
-    "@modern-js/plugin-bff": "npm:@bleedingdev/modern-js-plugin-bff@3.9.0-ultramodern.16",
-    "@modern-js/plugin-tanstack": "npm:@bleedingdev/modern-js-plugin-tanstack@3.9.0-ultramodern.16",
-    "@modern-js/prod-server": "npm:@bleedingdev/modern-js-prod-server@3.9.0-ultramodern.16",
-    "@modern-js/server": "npm:@bleedingdev/modern-js-server@3.9.0-ultramodern.16",
-    "@modern-js/tsconfig": "npm:@bleedingdev/modern-js-tsconfig@3.9.0-ultramodern.16",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.16",
+    "@modern-js/backend-federation-contracts": "npm:@bleedingdev/modern-js-backend-federation-contracts@3.9.0-ultramodern.18",
+    "@modern-js/builder": "npm:@bleedingdev/modern-js-builder@3.9.0-ultramodern.18",
+    "@modern-js/plugin-bff": "npm:@bleedingdev/modern-js-plugin-bff@3.9.0-ultramodern.18",
+    "@modern-js/plugin-tanstack": "npm:@bleedingdev/modern-js-plugin-tanstack@3.9.0-ultramodern.18",
+    "@modern-js/prod-server": "npm:@bleedingdev/modern-js-prod-server@3.9.0-ultramodern.18",
+    "@modern-js/server": "npm:@bleedingdev/modern-js-server@3.9.0-ultramodern.18",
+    "@modern-js/tsconfig": "npm:@bleedingdev/modern-js-tsconfig@3.9.0-ultramodern.18",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.18",
     "@rslib/core": "1.0.2",
     "@scripts/rstest-config": "2.66.0",
     "@types/node": "^26.6.2",

package/src/native-composition/module-federation-shared-plugin.ts

@@ -0,0 +1,367 @@
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+import type { Rspack } from '@rsbuild/core';
+
+type SharedConfig = { requiredVersion?: unknown } & Record<string, unknown>;
+type SharedRecord = Record<string, string | SharedConfig>;
+type Shared = SharedRecord | Array<string | SharedRecord>;
+
+// The compiled JSX in every federated bundle imports these React entries.
+// Sharing `react` without them gives each bundle its own JSX runtime, so a
+// remote's elements reach the host's React with a foreign runtime identity.
+const REACT_JSX_RUNTIMES = ['react/jsx-runtime', 'react/jsx-dev-runtime'];
+
+// Chain ids under which `@module-federation/modern-js-v3` registers its
+// browser and server federation plugins.
+const MODULE_FEDERATION_CHAIN_IDS = [
+  'plugin-module-federation',
+  'plugin-module-federation-server',
+];
+
+/**
+ * Framework packages whose subpaths share module state: React contexts and
+ * Effect's request storage. Every exported subpath under `prefix` is shared,
+ * and each subpath reaches that state through a package self-reference (for
+ * example `@modern-js/runtime/context`), so a remote never evaluates its own
+ * copy. Subpaths are listed from the package's `exports` rather than shared by
+ * prefix: the app aliases unexported ones such as `@modern-js/runtime/registry`
+ * to its own generated modules, which must never be shared.
+ * `contexts` matches the files that define that state (React contexts, the
+ * Effect request storage): only a shared module or another of those files may
+ * import them.
+ */
+const FRAMEWORK_SHARES = [
+  {
+    packageName: '@modern-js/runtime',
+    prefix: '@modern-js/runtime/',
+    contextsRequest: '@modern-js/runtime/context',
+    contexts: /[\\/]core[\\/]context[\\/](?:index|runtime)\.[cm]?[jt]sx?$/,
+  },
+  {
+    packageName: '@modern-js/plugin-i18n',
+    prefix: '@modern-js/plugin-i18n/runtime/',
+    contextsRequest: '@modern-js/plugin-i18n/runtime/contexts',
+    contexts: /[\\/]runtime[\\/]contexts\.[cm]?[jt]sx?$/,
+  },
+  {
+    packageName: '@modern-js/bff-effect',
+    prefix: '@modern-js/bff-effect/',
+    contextsRequest: '@modern-js/bff-effect/context',
+    contexts: /[\\/]effect[\\/]context\.[cm]?[jt]sx?$/,
+  },
+] as const;
+
+export type FrameworkSharedPackage = {
+  prefix: string;
+  version: string;
+  /** Exported subpath requests under `prefix` that load code. */
+  requests: string[];
+  /** Real path of the installed package directory. */
+  directory: string;
+  contextsRequest?: string;
+  contexts?: RegExp;
+};
+
+// A types-only export or a wildcard pattern names no module to share.
+const loadsCode = (target: unknown): boolean =>
+  typeof target === 'string'
+    ? !target.endsWith('.d.ts')
+    : Boolean(target) &&
+      typeof target === 'object' &&
+      Object.entries(target as object).some(
+        ([condition, value]) => condition !== 'types' && loadsCode(value),
+      );
+
+const exportedRequests = (
+  packageName: string,
+  prefix: string,
+  exports: unknown,
+) =>
+  Object.entries(
+    exports && typeof exports === 'object' ? (exports as object) : {},
+  )
+    .filter(
+      ([subpath, target]) =>
+        subpath !== './package.json' &&
+        !subpath.includes('*') &&
+        loadsCode(target),
+    )
+    .map(([subpath]) => `${packageName}${subpath.slice(1)}`)
+    .filter(request => request.startsWith(prefix))
+    .sort();
+
+/**
+ * The app's `node_modules` lookup for `packageName`. `NODE_PATH` is ignored:
+ * a package the app does not install is not the app's to share.
+ */
+const findInstalledManifest = (appDirectory: string, packageName: string) => {
+  for (let directory = appDirectory; ; ) {
+    const manifest = path.join(
+      directory,
+      'node_modules',
+      packageName,
+      'package.json',
+    );
+    if (existsSync(manifest)) return manifest;
+    const parent = path.dirname(directory);
+    if (parent === directory) return undefined;
+    directory = parent;
+  }
+};
+
+/** The framework packages the app installs, with their installed versions. */
+export const resolveFrameworkSharedPackages = (
+  appDirectory: string,
+): FrameworkSharedPackage[] =>
+  FRAMEWORK_SHARES.flatMap(share => {
+    const manifest = findInstalledManifest(appDirectory, share.packageName);
+    if (!manifest) return [];
+    const { version, exports } = JSON.parse(readFileSync(manifest, 'utf8')) as {
+      version: string;
+      exports?: unknown;
+    };
+    return [
+      {
+        ...share,
+        version,
+        requests: exportedRequests(share.packageName, share.prefix, exports),
+        directory: realpathSync(path.dirname(manifest)),
+      },
+    ];
+  });
+
+const findShared = (
+  entries: Array<string | SharedRecord>,
+  request: string,
+): SharedConfig | undefined => {
+  for (const entry of entries) {
+    if (entry === request) return {};
+    if (typeof entry === 'object' && Object.hasOwn(entry, request)) {
+      const config = entry[request];
+      return typeof config === 'string' ? { requiredVersion: config } : config;
+    }
+  }
+  return undefined;
+};
+
+const toEntries = (shared: unknown) =>
+  (Array.isArray(shared) ? shared : [shared]) as Array<string | SharedRecord>;
+
+/** Add `missing` to `shared`, keeping every entry the app configured. */
+const withShared = <T>(shared: T, missing: SharedRecord): T => {
+  const entries = toEntries(shared);
+  const added = Object.fromEntries(
+    Object.entries(missing).filter(
+      ([request]) => !findShared(entries, request),
+    ),
+  );
+  if (Object.keys(added).length === 0) return shared;
+  if (!shared) return added as T;
+  return (
+    Array.isArray(shared) ? [...shared, added] : { ...shared, ...added }
+  ) as T;
+};
+
+/**
+ * Share `react/jsx-runtime` and `react/jsx-dev-runtime` as singletons at the
+ * shared `react` version whenever `react` itself is shared. Entries the app
+ * configured explicitly are kept as written.
+ */
+export const withReactJsxRuntimeShared = <T>(shared: T): T => {
+  if (!shared || typeof shared !== 'object') return shared;
+  const react = findShared(toEntries(shared), 'react');
+  if (!react) return shared;
+  return withShared(
+    shared,
+    Object.fromEntries(
+      REACT_JSX_RUNTIMES.map(request => [
+        request,
+        {
+          ...(react.requiredVersion === undefined
+            ? {}
+            : { requiredVersion: react.requiredVersion }),
+          singleton: true,
+          treeShaking: false,
+        },
+      ]),
+    ),
+  );
+};
+
+/**
+ * Share every exported subpath of the framework packages as a singleton at
+ * the installed version. Entries the app configured explicitly are kept.
+ */
+export const withFrameworkShared = <T>(
+  shared: T,
+  packages: FrameworkSharedPackage[],
+): T =>
+  withShared(
+    shared,
+    Object.fromEntries(
+      packages.flatMap(({ requests, version }) =>
+        requests.map(request => [
+          request,
+          { requiredVersion: version, singleton: true, treeShaking: false },
+        ]),
+      ),
+    ),
+  );
+
+type FederationPluginOptions = {
+  shared?: Shared;
+  exposes?: unknown;
+  mfConfig?: unknown;
+};
+
+// `secondarySharedTreeShaking` wraps the federation config in `mfConfig`.
+const federationConfig = (
+  options: FederationPluginOptions,
+): FederationPluginOptions =>
+  options.mfConfig && typeof options.mfConfig === 'object'
+    ? federationConfig(options.mfConfig as FederationPluginOptions)
+    : options;
+
+const withDefaults = (
+  options: FederationPluginOptions,
+  packages: FrameworkSharedPackage[],
+): FederationPluginOptions =>
+  options.mfConfig && typeof options.mfConfig === 'object'
+    ? {
+        ...options,
+        mfConfig: withDefaults(
+          options.mfConfig as FederationPluginOptions,
+          packages,
+        ),
+      }
+    : {
+        ...options,
+        shared: withFrameworkShared(
+          withReactJsxRuntimeShared(options.shared),
+          packages,
+        ),
+      };
+
+const hasExposes = (options: FederationPluginOptions) => {
+  const { exposes } = federationConfig(options);
+  return Array.isArray(exposes)
+    ? exposes.length > 0
+    : Boolean(exposes) && Object.keys(exposes as object).length > 0;
+};
+
+const SHARED_MODULE_TYPES = new Set([
+  'consume-shared-module',
+  'provide-module',
+]);
+
+// Only normal modules carry a file resource.
+const resourceOf = (module: Rspack.Module | null) =>
+  module && 'resource' in module && typeof module.resource === 'string'
+    ? module.resource
+    : undefined;
+
+const describeModule = (module: Rspack.Module | null) =>
+  module ? (resourceOf(module) ?? module.identifier()) : 'an entry';
+
+// The dependency type of a Module Federation container entry, the same in
+// Rspack and webpack.
+const CONTAINER_ENTRY_DEPENDENCY = 'container entry';
+
+const buildsContainer = (compilation: Rspack.Compilation) =>
+  [...compilation.entries.values()].some(({ dependencies }) =>
+    dependencies.some(({ type }) => type === CONTAINER_ENTRY_DEPENDENCY),
+  );
+
+/**
+ * Fails a federation build that exposes modules when a framework context file
+ * is imported other than through its shared request. That remote would run
+ * with its own contexts and never see the host's request state.
+ *
+ * The check runs only when the compilation really builds a container: an
+ * environment may drop the federation plugin after the chain was configured
+ * (the Cloudflare workerd SSR graph does), and a graph with no container has
+ * no host to share contexts with.
+ */
+export class FederationPrivateContextsPlugin {
+  constructor(private readonly packages: FrameworkSharedPackage[]) {}
+
+  apply(compiler: Rspack.Compiler) {
+    const name = 'FederationPrivateContextsPlugin';
+    const definitionOf = (module: Rspack.Module | null) => {
+      const resource = resourceOf(module);
+      return resource === undefined
+        ? undefined
+        : this.packages.find(
+            ({ contexts, directory }) =>
+              contexts?.test(resource) &&
+              resource.startsWith(directory + path.sep),
+          );
+    };
+    compiler.hooks.compilation.tap(name, compilation => {
+      compilation.hooks.finishModules.tap(name, modules => {
+        if (!buildsContainer(compilation)) return;
+        for (const module of modules) {
+          const share = definitionOf(module);
+          if (!share) continue;
+          const importer = compilation.moduleGraph
+            .getIncomingConnections(module)
+            .map(connection => connection.originModule)
+            .find(
+              origin =>
+                !(origin && SHARED_MODULE_TYPES.has(origin.type)) &&
+                definitionOf(origin) !== share,
+            );
+          if (importer === undefined) continue;
+          compilation.errors.push(
+            new compiler.webpack.WebpackError(
+              `[ultramodern] This Module Federation build bundles a private copy of ${share.contextsRequest}: ${describeModule(importer)} imports ${describeModule(module)} directly. It would not see the host's request state. Share the "${share.prefix}" subpaths and import the contexts through "${share.contextsRequest}".`,
+            ),
+          );
+        }
+      });
+    });
+  }
+}
+
+/**
+ * Apply UltraModern's Module Federation share defaults to the federation
+ * plugins that `@module-federation/modern-js-v3` registered on the chain.
+ */
+export const ultramodernModuleFederationSharedPlugin =
+  (): CliPlugin<AppTools> => ({
+    name: '@modern-js/ultramodern-module-federation-shared',
+    pre: [
+      '@modern-js/plugin-module-federation',
+      '@modern-js/plugin-module-federation-ssr',
+    ],
+    setup(api) {
+      api.modifyBundlerChain(chain => {
+        const ids = MODULE_FEDERATION_CHAIN_IDS.filter(id =>
+          chain.plugins.has(id),
+        );
+        if (ids.length === 0) return;
+        const packages = resolveFrameworkSharedPackages(
+          api.getAppContext().appDirectory,
+        );
+        let exposes = false;
+        for (const id of ids) {
+          const [options] = chain.plugin(id).get('args') as [
+            FederationPluginOptions,
+          ];
+          exposes ||= hasExposes(options);
+          chain
+            .plugin(id)
+            .tap(([options, ...rest]) => [
+              withDefaults(options, packages),
+              ...rest,
+            ]);
+        }
+        if (exposes) {
+          chain
+            .plugin('ultramodern-federation-private-contexts')
+            .use(FederationPrivateContextsPlugin, [packages]);
+        }
+      });
+    },
+  });

package/src/native-composition/preset.ts

@@ -7,6 +7,7 @@ import { resolveUltramodernReleaseIdentity } from '@modern-js/app-tools-extensio
 import { findHostingModuleDirectory } from '@modern-js/app-tools-extensions/runtime-package-resolution';
 import { mergeConfig } from '@modern-js/plugin/cli';
 import { type RspackChain, rspack } from '@rsbuild/core';
+import { ultramodernModuleFederationSharedPlugin } from './module-federation-shared-plugin';
 import type { AppUserConfig } from './types';
 
 const DEFAULT_OTLP_ENDPOINT = 'http://127.0.0.1:4318/v1/logs';
@@ -214,8 +215,11 @@ export const createPresetUltramodernConfig = (
       // Keep build artifacts predictable across apps.
       precompress: true,
     },
+    plugins: [ultramodernModuleFederationSharedPlugin()],
     server,
     source: {
+      // Client code only: the builder applies React Compiler to `web`
+      // environments and never to node/workerSSR/BFF graphs.
       reactCompiler: true,
       ...(deliveryUnit
         ? {