@module-federation/rsbuild-plugin 2.0.0 → 2.1.0

package/README.md

@@ -11,7 +11,8 @@ npm install @module-federation/enhanced
 ```
 
 ### Rsbuild App
-``` js
+
+```js
 import { pluginModuleFederation } from '@module-federation/rsbuild-plugin';
 import { defineConfig } from '@rsbuild/core';
 import { pluginReact } from '@rsbuild/plugin-react';
@@ -33,8 +34,56 @@ export default defineConfig({
 });
 ```
 
+### Rsbuild App SSR (Node target with custom environment)
+
+Use `target: 'node'` with an explicit `environment` to apply federation to a
+specific Rsbuild app environment (for example `ssr`).
+
+```ts
+import { pluginModuleFederation } from '@module-federation/rsbuild-plugin';
+import { defineConfig } from '@rsbuild/core';
+
+export default defineConfig({
+  environments: {
+    client: {},
+    ssr: {},
+  },
+  plugins: [
+    pluginModuleFederation(
+      {
+        name: 'host',
+        remotes: {
+          remote: 'remote@http://localhost:3001/mf-manifest.json',
+        },
+      },
+      {
+        target: 'node',
+        environment: 'ssr',
+      },
+    ),
+  ],
+});
+```
+
+`target: 'dual'` support remains scoped to Rslib/Rspress workflows.
+
+### Default environment detection
+
+If `environment` is omitted, the plugin will choose a default per tool:
+
+- **Rslib**: `mf`
+- **Rsbuild app**:
+  - `target: 'web'` → `web`
+  - `target: 'node'` → `node`
+- **Rspress**:
+  - `target: 'web'` → `web`
+  - `target: 'node'` → `node`
+
+You can still override with `environment` when your project uses custom names.
+
 ### Rslib Module
-``` js
+
+```js
 import { pluginModuleFederation } from '@module-federation/rsbuild-plugin';
 import { defineConfig } from '@rslib/core';
 
@@ -70,3 +119,7 @@ export default defineConfig({
   ],
 });
 ```
+
+## Documentation
+
+See [https://module-federation.io/guide/build-plugins/plugins-rsbuild.html](https://module-federation.io/guide/build-plugins/plugins-rsbuild.html) fordetails.

package/dist/cli/index.d.ts

@@ -27,7 +27,7 @@ declare const RSBUILD_PLUGIN_MODULE_FEDERATION_NAME = "rsbuild:module-federation
 export { RSBUILD_PLUGIN_MODULE_FEDERATION_NAME, PLUGIN_NAME, SSR_DIR };
 export declare function isMFFormat(bundlerConfig: Rspack.Configuration): boolean;
 declare const isSSRConfig: (bundlerConfigName?: string) => boolean;
-declare const isRspressSSGConfig: (bundlerConfigName?: string) => bundlerConfigName is "node";
+declare const isRspressSSGConfig: (bundlerConfigName?: string) => boolean;
 export declare const pluginModuleFederation: (moduleFederationOptions: ModuleFederationOptions, rsbuildOptions?: RSBUILD_PLUGIN_OPTIONS) => RsbuildPlugin;
 export { createModuleFederationConfig } from '@module-federation/sdk';
 export { TreeShakingSharedPlugin };

package/dist/cli/index.js

@@ -0,0 +1,475 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+// The require scope
+var __webpack_require__ = {};
+
+/************************************************************************/
+// webpack/runtime/compat_get_default_export
+(() => {
+// getDefaultExport function for compatibility with non-ESM modules
+__webpack_require__.n = (module) => {
+	var getter = module && module.__esModule ?
+		() => (module['default']) :
+		() => (module);
+	__webpack_require__.d(getter, { a: getter });
+	return getter;
+};
+
+})();
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+/************************************************************************/
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  pluginModuleFederation: () => (/* binding */ pluginModuleFederation),
+  RSBUILD_PLUGIN_MODULE_FEDERATION_NAME: () => (/* binding */ RSBUILD_PLUGIN_MODULE_FEDERATION_NAME),
+  PLUGIN_NAME: () => (/* reexport */ rspack_namespaceObject.PLUGIN_NAME),
+  SSR_DIR: () => (/* reexport */ external_utils_js_namespaceObject.SSR_DIR),
+  isMFFormat: () => (/* binding */ isMFFormat),
+  TreeShakingSharedPlugin: () => (/* reexport */ rspack_namespaceObject.TreeShakingSharedPlugin),
+  createModuleFederationConfig: () => (/* reexport */ sdk_namespaceObject.createModuleFederationConfig)
+});
+
+;// CONCATENATED MODULE: external "@module-federation/enhanced"
+const enhanced_namespaceObject = require("@module-federation/enhanced");
+;// CONCATENATED MODULE: external "@module-federation/enhanced/rspack"
+const rspack_namespaceObject = require("@module-federation/enhanced/rspack");
+;// CONCATENATED MODULE: external "@module-federation/sdk"
+const sdk_namespaceObject = require("@module-federation/sdk");
+;// CONCATENATED MODULE: external "../../package.json"
+const external_package_json_namespaceObject = require("../../package.json");
+var external_package_json_default = /*#__PURE__*/__webpack_require__.n(external_package_json_namespaceObject);
+;// CONCATENATED MODULE: external "../logger.js"
+const external_logger_js_namespaceObject = require("../logger.js");
+var external_logger_js_default = /*#__PURE__*/__webpack_require__.n(external_logger_js_namespaceObject);
+;// CONCATENATED MODULE: external "../utils.js"
+const external_utils_js_namespaceObject = require("../utils.js");
+;// CONCATENATED MODULE: external "../constant.js"
+const external_constant_js_namespaceObject = require("../constant.js");
+;// CONCATENATED MODULE: external "../utils/ssr.js"
+const ssr_js_namespaceObject = require("../utils/ssr.js");
+;// CONCATENATED MODULE: ./src/cli/index.ts
+
+
+
+
+
+
+
+
+const RSBUILD_PLUGIN_MODULE_FEDERATION_NAME = 'rsbuild:module-federation-enhanced';
+const RSBUILD_PLUGIN_NAME = '@module-federation/rsbuild-plugin';
+
+const LIB_FORMAT = [
+    'umd',
+    'modern-module'
+];
+const DEFAULT_MF_ENVIRONMENT_NAME = 'mf';
+const DEFAULT_WEB_ENVIRONMENT_NAME = 'web';
+const DEFAULT_NODE_ENVIRONMENT_NAME = 'node';
+const resolveDefaultEnvironmentName = ({ callerName, target })=>{
+    if (callerName === external_constant_js_namespaceObject.CALL_NAME_MAP.RSLIB) {
+        return DEFAULT_MF_ENVIRONMENT_NAME;
+    }
+    if (callerName === external_constant_js_namespaceObject.CALL_NAME_MAP.RSPRESS) {
+        if (target === 'node') {
+            return DEFAULT_NODE_ENVIRONMENT_NAME;
+        }
+        return DEFAULT_WEB_ENVIRONMENT_NAME;
+    }
+    if (target === 'node') {
+        return DEFAULT_NODE_ENVIRONMENT_NAME;
+    }
+    return DEFAULT_WEB_ENVIRONMENT_NAME;
+};
+function isStoryBook(rsbuildConfig) {
+    var _rsbuildConfig_plugins;
+    if ((_rsbuildConfig_plugins = rsbuildConfig.plugins) === null || _rsbuildConfig_plugins === void 0 ? void 0 : _rsbuildConfig_plugins.find((p)=>p && 'name' in p && p.name === 'module-federation-storybook-plugin')) {
+        return true;
+    }
+    return false;
+}
+function isMFFormat(bundlerConfig) {
+    var _bundlerConfig_output;
+    const library = (_bundlerConfig_output = bundlerConfig.output) === null || _bundlerConfig_output === void 0 ? void 0 : _bundlerConfig_output.library;
+    if (bundlerConfig.name === external_utils_js_namespaceObject.SSR_ENV_NAME) {
+        return true;
+    }
+    return !(typeof library === 'object' && !Array.isArray(library) && 'type' in library && //  if the type is umd/modern-module or commonjs*, means this is a normal library , not mf
+    (LIB_FORMAT.includes(library.type) || /commonjs/.test(library.type)));
+}
+const isSSRConfig = (bundlerConfigName)=>Boolean(bundlerConfigName === external_utils_js_namespaceObject.SSR_ENV_NAME);
+const isRspressSSGConfig = (bundlerConfigName)=>{
+    return [
+        external_constant_js_namespaceObject.RSPRESS_BUNDLER_CONFIG_NAME,
+        external_constant_js_namespaceObject.RSPRESS_SSG_MD_ENV_NAME
+    ].includes(bundlerConfigName || '');
+};
+const pluginModuleFederation = (moduleFederationOptions, rsbuildOptions)=>({
+        name: RSBUILD_PLUGIN_MODULE_FEDERATION_NAME,
+        setup: (api)=>{
+            if (!(moduleFederationOptions === null || moduleFederationOptions === void 0 ? void 0 : moduleFederationOptions.name)) {
+                throw new Error('The module federation option "name" is required in @module-federation/rsbuild-plugin.');
+            }
+            const { target = 'web', ssr = undefined, ssrDir = external_utils_js_namespaceObject.SSR_DIR, environment: configuredEnvironment } = rsbuildOptions || {};
+            if (ssr) {
+                throw new Error("The `ssr` option is deprecated. If you want to enable SSR, please use `target: 'dual'` instead.");
+            }
+            const { callerName } = api.context;
+            const originalRsbuildConfig = api.getRsbuildConfig();
+            if (!callerName) {
+                throw new Error('`callerName` is undefined. Please ensure the @rsbuild/core version is higher than 1.3.21 .');
+            }
+            const isRslib = callerName === external_constant_js_namespaceObject.CALL_NAME_MAP.RSLIB;
+            const isRspress = callerName === external_constant_js_namespaceObject.CALL_NAME_MAP.RSPRESS;
+            const isSSR = target === 'dual';
+            const environment = configuredEnvironment ?? resolveDefaultEnvironmentName({
+                callerName,
+                target
+            });
+            if (isSSR && !isStoryBook(originalRsbuildConfig)) {
+                var _rsbuildConfig_environments;
+                if (!isRslib && !isRspress) {
+                    throw new Error(`'target' option is only supported in Rslib.`);
+                }
+                const rsbuildConfig = api.getRsbuildConfig();
+                if (!isRspress && (!((_rsbuildConfig_environments = rsbuildConfig.environments) === null || _rsbuildConfig_environments === void 0 ? void 0 : _rsbuildConfig_environments[environment]) || Object.keys(rsbuildConfig.environments).some((key)=>key.startsWith(environment) && key !== environment))) {
+                    throw new Error(`Please set ${RSBUILD_PLUGIN_NAME} as global plugin in rslib.config.ts if you set 'target: "dual"'.`);
+                }
+                (0,external_utils_js_namespaceObject.setSSREnv)();
+            }
+            const sharedOptions = (0,enhanced_namespaceObject.parseOptions)(moduleFederationOptions.shared || [], (item, key)=>{
+                if (typeof item !== 'string') throw new Error('Unexpected array in shared');
+                const config = item === key || !(0,sdk_namespaceObject.isRequiredVersion)(item) ? {
+                    import: item
+                } : {
+                    import: key,
+                    requiredVersion: item
+                };
+                return config;
+            }, (item)=>item);
+            // shared[0] is the shared name
+            const shared = sharedOptions.map((shared)=>shared[0].endsWith('/') ? shared[0].slice(0, -1) : shared[0]);
+            api.modifyRsbuildConfig((config)=>{
+                // skip storybook
+                if (isStoryBook(config)) {
+                    return;
+                }
+                // Change some default configs for remote modules
+                if (moduleFederationOptions.exposes) {
+                    var _userConfig_server, _config_server, _config_dev_client, _originalConfig_dev, _config_server1;
+                    config.dev ||= {};
+                    config.server ||= {};
+                    const userConfig = api.getRsbuildConfig('original');
+                    // Allow remote modules to be loaded by setting CORS headers
+                    // This is required for MF to work properly across different origins
+                    config.server.headers ||= {};
+                    if (!config.server.headers['Access-Control-Allow-Origin'] && !(typeof ((_userConfig_server = userConfig.server) === null || _userConfig_server === void 0 ? void 0 : _userConfig_server.cors) === 'object' && userConfig.server.cors.origin)) {
+                        const corsWarnMsgs = [
+                            'Detect that CORS options are not set, mf Rsbuild plugin will add default cors header: server.headers["Access-Control-Allow-Headers"] = "*". It is recommended to specify an allowlist of trusted origins in "server.cors" instead.',
+                            'View https://module-federation.io/guide/troubleshooting/other.html#cors-warn for more details.'
+                        ];
+                        !isRslib && !isRspress && external_logger_js_default().warn(corsWarnMsgs.join('\n'));
+                        config.server.headers['Access-Control-Allow-Origin'] = '*';
+                    }
+                    // For remote modules, Rsbuild should send the ws request to the provider's dev server.
+                    // This allows the provider to do HMR when the provider module is loaded in the consumer's page.
+                    if (((_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.port) && !((_config_dev_client = config.dev.client) === null || _config_dev_client === void 0 ? void 0 : _config_dev_client.port)) {
+                        config.dev.client ||= {};
+                        config.dev.client.port = config.server.port;
+                    }
+                    // Change the default assetPrefix to `true` for remote modules.
+                    // This ensures that the remote module's assets can be requested by consumer apps with the correct URL.
+                    const originalConfig = api.getRsbuildConfig('original');
+                    if (((_originalConfig_dev = originalConfig.dev) === null || _originalConfig_dev === void 0 ? void 0 : _originalConfig_dev.assetPrefix) === undefined && config.dev.assetPrefix === ((_config_server1 = config.server) === null || _config_server1 === void 0 ? void 0 : _config_server1.base)) {
+                        config.dev.assetPrefix = true;
+                    }
+                }
+                if (isSSR) {
+                    var _config_environments, _config_environments1;
+                    if ((_config_environments = config.environments) === null || _config_environments === void 0 ? void 0 : _config_environments[external_utils_js_namespaceObject.SSR_ENV_NAME]) {
+                        throw new Error(`'${external_utils_js_namespaceObject.SSR_ENV_NAME}' environment is already defined.Please use another name.`);
+                    }
+                    config.environments[external_utils_js_namespaceObject.SSR_ENV_NAME] = (0,external_utils_js_namespaceObject.createSSRREnvConfig)((_config_environments1 = config.environments) === null || _config_environments1 === void 0 ? void 0 : _config_environments1[environment], moduleFederationOptions, ssrDir, config, callerName);
+                    const ssgMDEnv = config.environments[external_constant_js_namespaceObject.RSPRESS_SSG_MD_ENV_NAME];
+                    if (isRspress && ssgMDEnv) {
+                        (0,ssr_js_namespaceObject.patchToolsTspack)(ssgMDEnv, (config, { environment })=>{
+                            config.target = 'async-node';
+                        });
+                    }
+                } else if (target === 'node') {
+                    var _config_environments2;
+                    const nodeTargetEnv = (_config_environments2 = config.environments) === null || _config_environments2 === void 0 ? void 0 : _config_environments2[environment];
+                    if (!nodeTargetEnv) {
+                        const availableEnvironments = Object.keys(config.environments || {});
+                        const availableEnvironmentsLabel = availableEnvironments.length > 0 ? availableEnvironments.join(', ') : '(none)';
+                        throw new Error(`Can not find environment '${environment}' when using target: 'node'. Available environments: ${availableEnvironmentsLabel}.`);
+                    }
+                    (0,ssr_js_namespaceObject.patchToolsTspack)(nodeTargetEnv, (config, { environment })=>{
+                        config.target = 'async-node';
+                    });
+                }
+            });
+            api.modifyEnvironmentConfig((config)=>{
+                // Module Federation runtime uses ES6+ syntax,
+                // adding to include and let SWC transform it
+                config.source.include = [
+                    ...config.source.include || [],
+                    /@module-federation[\\/]/
+                ];
+                return config;
+            });
+            const generateMergedStatsAndManifestOptions = {
+                options: {
+                    nodePlugin: undefined,
+                    browserPlugin: undefined,
+                    rspressSSGPlugin: undefined,
+                    distOutputDir: undefined,
+                    browserEnvironmentName: undefined,
+                    nodeEnvironmentName: undefined
+                },
+                assetResources: {},
+                isSSRConfig,
+                isRspressSSGConfig
+            };
+            api.expose(RSBUILD_PLUGIN_MODULE_FEDERATION_NAME, generateMergedStatsAndManifestOptions);
+            const defaultBrowserEnvironmentName = environment;
+            const assetFileNames = (0,sdk_namespaceObject.getManifestFileName)(moduleFederationOptions.manifest);
+            if (moduleFederationOptions.manifest !== false) {
+                api.processAssets({
+                    stage: 'report'
+                }, ({ assets, environment: envContext })=>{
+                    const expectedBrowserEnv = generateMergedStatsAndManifestOptions.options.browserEnvironmentName ?? defaultBrowserEnvironmentName;
+                    const expectedNodeEnv = generateMergedStatsAndManifestOptions.options.nodeEnvironmentName ?? external_utils_js_namespaceObject.SSR_ENV_NAME;
+                    const envName = envContext.name;
+                    if (envName !== expectedBrowserEnv && envName !== expectedNodeEnv) {
+                        return;
+                    }
+                    const assetResources = generateMergedStatsAndManifestOptions.assetResources;
+                    const targetResources = assetResources[envName] || (assetResources[envName] = {});
+                    const statsAsset = assets[assetFileNames.statsFileName];
+                    if (statsAsset) {
+                        try {
+                            const raw = statsAsset.source();
+                            const content = typeof raw === 'string' ? raw : raw.toString();
+                            targetResources.stats = {
+                                data: JSON.parse(content),
+                                filename: assetFileNames.statsFileName
+                            };
+                        } catch (err) {
+                            const message = err instanceof Error ? err.message : String(err);
+                            external_logger_js_default().error(`Failed to parse stats asset "${assetFileNames.statsFileName}" for environment "${envName}": ${message} `);
+                        }
+                    }
+                    const manifestAsset = assets[assetFileNames.manifestFileName];
+                    if (manifestAsset) {
+                        try {
+                            const raw = manifestAsset.source();
+                            const content = typeof raw === 'string' ? raw : raw.toString();
+                            targetResources.manifest = {
+                                data: JSON.parse(content),
+                                filename: assetFileNames.manifestFileName
+                            };
+                        } catch (err) {
+                            const message = err instanceof Error ? err.message : String(err);
+                            external_logger_js_default().error(`Failed to parse manifest asset "${assetFileNames.manifestFileName}" for environment "${envName}": ${message} `);
+                        }
+                    }
+                });
+            }
+            api.onBeforeCreateCompiler(({ bundlerConfigs })=>{
+                if (!bundlerConfigs) {
+                    throw new Error('Can not get bundlerConfigs!');
+                }
+                bundlerConfigs.forEach((bundlerConfig)=>{
+                    const bundlerConfigName = bundlerConfig.name || '';
+                    const isConfiguredEnvironmentConfig = bundlerConfigName === environment;
+                    const isNodeTargetEnvironmentConfig = target === 'node' && bundlerConfigName === environment;
+                    const isRspressSSGEnvironmentConfig = isRspressSSGConfig(bundlerConfig.name);
+                    const isActiveRspressSSGEnvironmentConfig = isRspress && isRspressSSGEnvironmentConfig;
+                    const shouldUseSSRPluginConfig = isSSRConfig(bundlerConfig.name) || isNodeTargetEnvironmentConfig;
+                    if (target === 'node' && !isNodeTargetEnvironmentConfig && !isActiveRspressSSGEnvironmentConfig) {
+                        return;
+                    }
+                    // For non-node targets, scope each plugin instance to its configured
+                    // environment plus explicit SSR/SSG environments. This prevents a
+                    // browser-targeted instance from mutating SSR configs.
+                    if (target !== 'node' && !isConfiguredEnvironmentConfig && !shouldUseSSRPluginConfig && !isActiveRspressSSGEnvironmentConfig) {
+                        return;
+                    }
+                    if (!isMFFormat(bundlerConfig) && !isRspress && !isNodeTargetEnvironmentConfig) {
+                        return;
+                    } else if (isStoryBook(originalRsbuildConfig)) {
+                        bundlerConfig.output.uniqueName = `${moduleFederationOptions.name} -storybook - host`;
+                    } else {
+                        var _bundlerConfig_optimization, _bundlerConfig_optimization1, _bundlerConfig_output, _bundlerConfig_output1, _bundlerConfig_output2;
+                        // mf
+                        (0,external_utils_js_namespaceObject.autoDeleteSplitChunkCacheGroups)(moduleFederationOptions, bundlerConfig === null || bundlerConfig === void 0 ? void 0 : (_bundlerConfig_optimization = bundlerConfig.optimization) === null || _bundlerConfig_optimization === void 0 ? void 0 : _bundlerConfig_optimization.splitChunks);
+                        (0,external_utils_js_namespaceObject.addDataFetchExposes)(moduleFederationOptions.exposes, shouldUseSSRPluginConfig);
+                        const ssrModuleFederationOptions = shouldUseSSRPluginConfig ? (0,external_utils_js_namespaceObject.createSSRMFConfig)(moduleFederationOptions) : undefined;
+                        (_bundlerConfig_optimization1 = bundlerConfig.optimization) === null || _bundlerConfig_optimization1 === void 0 ? true : delete _bundlerConfig_optimization1.runtimeChunk;
+                        const externals = bundlerConfig.externals;
+                        if (Array.isArray(externals)) {
+                            const sharedModules = new Set();
+                            bundlerConfig.externals = externals.filter((ext)=>{
+                                let sharedModule;
+                                if ((0,external_utils_js_namespaceObject.isRegExp)(ext)) {
+                                    const match = shared.some((dep)=>{
+                                        if (ext.test(dep) || ext.test((external_package_json_default()).name)) {
+                                            sharedModule = dep;
+                                            return true;
+                                        }
+                                        return false;
+                                    });
+                                    match && sharedModule && sharedModules.add(sharedModule);
+                                    return !match;
+                                }
+                                if (typeof ext === 'string') {
+                                    if (ext === (external_package_json_default()).name) {
+                                        return false;
+                                    }
+                                    const match = shared.some((dep)=>{
+                                        if (dep === ext) {
+                                            sharedModule = dep;
+                                        }
+                                        return dep === ext;
+                                    });
+                                    if (match) {
+                                        sharedModule && sharedModules.add(sharedModule);
+                                        return false;
+                                    }
+                                    return true;
+                                }
+                                return true;
+                            });
+                            if (sharedModules.size > 0) {
+                                for (const sharedModule of sharedModules){
+                                    external_logger_js_default().log(`${sharedModule} is removed from externals because it is a shared module.`);
+                                }
+                            }
+                        }
+                        if (!((_bundlerConfig_output = bundlerConfig.output) === null || _bundlerConfig_output === void 0 ? void 0 : _bundlerConfig_output.chunkLoadingGlobal) && !shouldUseSSRPluginConfig && !isActiveRspressSSGEnvironmentConfig && target !== 'node') {
+                            bundlerConfig.output.chunkLoading = 'jsonp';
+                            bundlerConfig.output.chunkLoadingGlobal = `chunk_${moduleFederationOptions.name} `;
+                        }
+                        if (isNodeTargetEnvironmentConfig) {
+                            (0,ssr_js_namespaceObject.patchNodeConfig)(bundlerConfig, ssrModuleFederationOptions ?? moduleFederationOptions);
+                        }
+                        // `uniqueName` is required for react refresh to work
+                        if (!((_bundlerConfig_output1 = bundlerConfig.output) === null || _bundlerConfig_output1 === void 0 ? void 0 : _bundlerConfig_output1.uniqueName)) {
+                            bundlerConfig.output.uniqueName = moduleFederationOptions.name;
+                        }
+                        // Set default publicPath to 'auto' if not explicitly configured
+                        // This allows remote chunks to load from the same origin as the remote application's manifest
+                        if (((_bundlerConfig_output2 = bundlerConfig.output) === null || _bundlerConfig_output2 === void 0 ? void 0 : _bundlerConfig_output2.publicPath) === undefined && !shouldUseSSRPluginConfig && !isActiveRspressSSGEnvironmentConfig) {
+                            bundlerConfig.output.publicPath = 'auto';
+                        }
+                        if (!bundlerConfig.plugins.find((p)=>p && p.name === rspack_namespaceObject.PLUGIN_NAME)) {
+                            var _bundlerConfig_output3;
+                            if (shouldUseSSRPluginConfig) {
+                                const ssrMFConfig = ssrModuleFederationOptions ?? (0,external_utils_js_namespaceObject.createSSRMFConfig)(moduleFederationOptions);
+                                generateMergedStatsAndManifestOptions.options.nodePlugin = new rspack_namespaceObject.ModuleFederationPlugin(ssrMFConfig);
+                                generateMergedStatsAndManifestOptions.options.nodeEnvironmentName = bundlerConfig.name || external_utils_js_namespaceObject.SSR_ENV_NAME;
+                                bundlerConfig.plugins.push(generateMergedStatsAndManifestOptions.options.nodePlugin);
+                                return;
+                            } else if (isActiveRspressSSGEnvironmentConfig) {
+                                const mfConfig = {
+                                    ...(0,external_utils_js_namespaceObject.createSSRMFConfig)(moduleFederationOptions),
+                                    // expose in mf-ssg env
+                                    exposes: {},
+                                    manifest: false,
+                                    library: undefined
+                                };
+                                (0,external_utils_js_namespaceObject.patchSSRRspackConfig)(bundlerConfig, mfConfig, external_constant_js_namespaceObject.RSPRESS_SSR_DIR, callerName, false, false);
+                                bundlerConfig.output ||= {};
+                                bundlerConfig.output.publicPath = '/';
+                                // MF depend on asyncChunks
+                                bundlerConfig.output.asyncChunks = undefined;
+                                const p = new rspack_namespaceObject.ModuleFederationPlugin(mfConfig);
+                                if (bundlerConfig.name === external_constant_js_namespaceObject.RSPRESS_BUNDLER_CONFIG_NAME) {
+                                    generateMergedStatsAndManifestOptions.options.rspressSSGPlugin = p;
+                                }
+                                bundlerConfig.plugins.push(p);
+                                return;
+                            }
+                            generateMergedStatsAndManifestOptions.options.browserPlugin = new rspack_namespaceObject.ModuleFederationPlugin(moduleFederationOptions);
+                            generateMergedStatsAndManifestOptions.options.distOutputDir = ((_bundlerConfig_output3 = bundlerConfig.output) === null || _bundlerConfig_output3 === void 0 ? void 0 : _bundlerConfig_output3.path) || '';
+                            generateMergedStatsAndManifestOptions.options.browserEnvironmentName = bundlerConfig.name || defaultBrowserEnvironmentName;
+                            bundlerConfig.plugins.push(generateMergedStatsAndManifestOptions.options.browserPlugin);
+                        }
+                    }
+                });
+            });
+            const generateMergedStatsAndManifest = ()=>{
+                const { distOutputDir, browserEnvironmentName, nodeEnvironmentName } = generateMergedStatsAndManifestOptions.options;
+                if (!distOutputDir || !browserEnvironmentName || !nodeEnvironmentName) {
+                    return;
+                }
+                const assetResources = generateMergedStatsAndManifestOptions.assetResources;
+                const browserAssets = assetResources[browserEnvironmentName];
+                const nodeAssets = assetResources[nodeEnvironmentName];
+                if (!browserAssets || !nodeAssets) {
+                    return;
+                }
+                try {
+                    (0,external_utils_js_namespaceObject.updateStatsAndManifest)(nodeAssets, browserAssets, distOutputDir);
+                } catch (err) {
+                    external_logger_js_default().error(err);
+                }
+            };
+            api.onDevCompileDone(()=>{
+                generateMergedStatsAndManifest();
+            });
+            api.onAfterBuild(()=>{
+                generateMergedStatsAndManifest();
+            });
+        }
+    });
+
+
+
+exports.PLUGIN_NAME = __webpack_exports__.PLUGIN_NAME;
+exports.RSBUILD_PLUGIN_MODULE_FEDERATION_NAME = __webpack_exports__.RSBUILD_PLUGIN_MODULE_FEDERATION_NAME;
+exports.SSR_DIR = __webpack_exports__.SSR_DIR;
+exports.TreeShakingSharedPlugin = __webpack_exports__.TreeShakingSharedPlugin;
+exports.createModuleFederationConfig = __webpack_exports__.createModuleFederationConfig;
+exports.isMFFormat = __webpack_exports__.isMFFormat;
+exports.pluginModuleFederation = __webpack_exports__.pluginModuleFederation;
+for(var __webpack_i__ in __webpack_exports__) {
+  if(["PLUGIN_NAME","RSBUILD_PLUGIN_MODULE_FEDERATION_NAME","SSR_DIR","TreeShakingSharedPlugin","createModuleFederationConfig","isMFFormat","pluginModuleFederation"].indexOf(__webpack_i__) === -1) {
+    exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });