@module-federation/vite 1.20.8 → 1.21.0

package/README.md

@@ -351,20 +351,29 @@ federation({
 `provideExternalRuntime` injects a local runtime plugin that publishes `runtime-core` on `globalThis._FEDERATION_RUNTIME_CORE`. `externalRuntime` rewrites imports of `@module-federation/runtime-core` to read that global. Using `provideExternalRuntime` together with `exposes` throws — only pure consumers may provide the runtime.
 The `externalRuntime` rewrite applies to the browser remote graph; SSR remote entries continue to resolve `@module-federation/runtime-core` from Node so they do not depend on the browser global.
 
-## ⚠️ `codeSplitting` settings are controlled by the plugin
+## ⚠️ `codeSplitting` is managed by the plugin
 
-Do not set either `build.rollupOptions.output.codeSplitting` or
-`build.rolldownOptions.output.codeSplitting` to `false` with this plugin — it will be **automatically ignored**.
+Do not set `build.rollupOptions.output.codeSplitting` or
+`build.rolldownOptions.output.codeSplitting` to `false` — it will be **ignored** (with a warning).
+Module Federation requires chunk splitting so `loadShare` and `runtimeInitStatus` stay isolated for correct bootstrap order.
 
-`codeSplitting.groups` is also ignored because grouping shared-runtime chunks can break MF init order.
-Module Federation needs `loadShare` and `runtimeInitStatus` isolated into separate chunks for correct bootstrap behavior.
+### `codeSplitting.groups` (Vite 8+ / Rolldown)
 
-## ⚠️ `manualChunks` is not supported
+User groups are now **preserved**. The plugin installs its own federation groups at the highest priority and appends your groups below them, so your groups can only claim modules the federation groups didn't.
 
-Do not use `build.rollupOptions.output.manualChunks` or
-`build.rolldownOptions.output.manualChunks` with this plugin — it will be **automatically ignored**.
-The plugin manages the runtime chunk graph itself, and forcing custom chunk grouping can break Module Federation bootstrap order.
-The plugin injects the splits it needs so `runtimeInitStatus` and `loadShare` stay isolated.
+- No warning is emitted just for keeping your groups.
+- If one of your existing groups sets a `priority` high enough to outrank the federation groups, it is **clamped** below them and the plugin warns once. This prevents those groups from capturing a `runtimeInit`/`loadShare` wrapper or the preload helper.
+
+## ⚠️ `manualChunks` behavior depends on your Vite version
+
+| Setting | Vite 5–7 (Rollup) | Vite 8+ (Rolldown) |
+| --- | --- | --- |
+| `manualChunks` (function) | **Composed as a fallback** — federation modules are claimed first, everything else falls through to your function | **Ignored** (warns) — move grouping to `codeSplitting.groups` |
+| `manualChunks` (object) | **Ignored** (warns) — use the function form to compose | **Ignored** (warns) — move grouping to `codeSplitting.groups` |
+
+On Vite 5–7, Rollup doesn't support `codeSplitting`, so the plugin isolates `runtimeInitStatus`, `loadShare`, and the preload helper via `manualChunks`. A user-provided **function** is called for any module the plugin doesn't claim; the **object** form isn't composed by the plugin and is ignored.
+
+On Vite 8+, chunking is managed through `codeSplitting.groups` (see above), so `manualChunks` is removed — express your grouping as `codeSplitting.groups` instead, where user groups are preserved below the federation groups.
 
 ### So far so good 🎉
 

package/lib/index.js

@@ -5378,7 +5378,7 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
     }`;
 	const realRemoteInit = `__mfRemotePending = __mfStartRemoteLoad().then(__mfAssignRemoteModule);`;
 	const deferredClientInit = `exportModule = __mfCreateDeferredRemoteProxy();`;
-	const eagerLoadClientRemote = shouldEagerLoadClientRemoteInDev(command, enableSsrInit);
+	const eagerLoadClientRemote = id === remoteRegistration?.alias || shouldEagerLoadClientRemoteInDev(command, enableSsrInit);
 	const eagerClientInit = eagerLoadClientRemote ? getEagerDeferredClientInit() : deferredClientInit;
 	const loadedFirstClientInit = eagerLoadClientRemote ? getEagerDeferredClientInit() : deferredClientInit;
 	const environmentSplitInit = (clientInit, serverInit) => consumer === "client" ? clientInit : consumer === "server" ? serverInit : `if (${SERVER_ENV_GUARD}) {
@@ -5515,20 +5515,25 @@ function resolveDevHashEntryFileName$1(fileName) {
 function getBuildInput(config) {
 	return config.build?.rollupOptions?.input ?? config.build?.rolldownOptions?.input;
 }
-function patchHashEntryFileName(output, entryName, fileName) {
-	const originalEntryFileNames = output.entryFileNames;
-	output.entryFileNames = (chunkInfo, ...args) => {
-		if (chunkInfo?.name === entryName) return fileName;
-		if (typeof originalEntryFileNames === "function") return originalEntryFileNames(chunkInfo, ...args);
-		return originalEntryFileNames || "assets/[name]-[hash].js";
-	};
+function patchHashEntryFileName(output, entryName, fileName, defaultFileNames) {
+	for (const option of ["entryFileNames", "chunkFileNames"]) {
+		const originalFileNames = output[option];
+		output[option] = (chunkInfo, ...args) => {
+			if (chunkInfo?.name === entryName) return fileName;
+			if (typeof originalFileNames === "function") return originalFileNames(chunkInfo, ...args);
+			return originalFileNames || defaultFileNames;
+		};
+	}
 }
 function patchHashEntryFileNames(config, entryName, fileName) {
 	if (!fileName?.includes?.("[hash")) return;
+	fileName = fileName.replace(/(\[hash(?::\d+)?\])$/, "$1.js");
 	config.build ??= {};
 	config.build.rollupOptions ??= {};
 	config.build.rolldownOptions ??= {};
-	const patchOutput = (output) => patchHashEntryFileName(output, entryName, fileName);
+	const assetsDir = config.build.assetsDir ?? "assets";
+	const defaultFileNames = `${assetsDir ? `${assetsDir}/` : ""}[name]-[hash].js`;
+	const patchOutput = (output) => patchHashEntryFileName(output, entryName, fileName, defaultFileNames);
 	const patchBundlerOutput = (bundlerOptions) => {
 		const output = bundlerOptions.output;
 		if (Array.isArray(output)) {
@@ -5539,6 +5544,7 @@ function patchHashEntryFileNames(config, entryName, fileName) {
 	};
 	patchBundlerOutput(config.build.rollupOptions);
 	patchBundlerOutput(config.build.rolldownOptions);
+	Object.values(config.environments ?? {}).forEach((environment) => patchHashEntryFileNames(environment, entryName, fileName));
 }
 const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClientInjected, skipTransformFor = [], federationOptions }) => {
 	const DEV_HTML_PROXY_PREFIX = "virtual:mf-html-entry-proxy?";
@@ -6099,6 +6105,7 @@ const REACT_REFRESH_PROXY_MODULE = [
 	`const __rt = await import(__target);`,
 	`export const injectIntoGlobalHook = __rt.injectIntoGlobalHook;`,
 	`export const register = __rt.register;`,
+	`export const getRefreshReg = __rt.getRefreshReg;`,
 	`export const createSignatureFunctionForTransform = __rt.createSignatureFunctionForTransform;`,
 	`export const registerExportsForReactRefresh = __rt.registerExportsForReactRefresh;`,
 	`export const validateRefreshBoundaryAndEnqueueUpdate = __rt.validateRefreshBoundaryAndEnqueueUpdate;`,
@@ -7742,12 +7749,18 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		return Object.keys(options.remotes).some((name) => source === name || source.startsWith(name + "/"));
 	}
 	function collectImportSources(code) {
-		const sources = /* @__PURE__ */ new Set();
+		const sources = /* @__PURE__ */ new Map();
 		for (const match of code.matchAll(/(?:^|[;\n\r])\s*import\s+(?:[\s\S]*?\s+from\s+)?["']([^"']+)["']|import\(\s*["']([^"']+)["']\s*\)/g)) {
 			const source = match[1] || match[2];
-			if (source) sources.add(source);
+			if (source) {
+				const dynamic = !match[1];
+				sources.set(source, (sources.get(source) ?? true) && dynamic);
+			}
 		}
-		return Array.from(sources).sort();
+		return Array.from(sources, ([source, dynamic]) => ({
+			source,
+			dynamic
+		})).sort((a, b) => a.source.localeCompare(b.source));
 	}
 	function shouldScanResolvedImport(id) {
 		if (!id || id.includes("\0")) return false;
@@ -7764,9 +7777,9 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 			return [];
 		}
 		const dependencies = /* @__PURE__ */ new Set();
-		for (const source of collectImportSources(code)) {
+		for (const { source, dynamic } of collectImportSources(code)) {
 			if (isRemoteImport(source)) {
-				dependencies.add(source);
+				if (!dynamic) dependencies.add(source);
 				continue;
 			}
 			const resolved = await ctx.resolve(source, id);
@@ -8430,8 +8443,10 @@ function applyRewrites(code, imports, id) {
 				importParts.push(`__mf_remote_pending as ${pendingId}`);
 				let rewrite = `import { ${importParts.join(", ")} } from ${src};`;
 				if (imp.named.length > 0) {
-					const destructParts = imp.named.map((s) => `${s.imported}: ${s.local}`);
-					rewrite += `\nconst { ${destructParts.join(", ")} } = ${nsId};`;
+					const declarations = imp.named.map((s) => `let ${s.local};`).join("\n");
+					const initializers = imp.named.map((s) => `if (${JSON.stringify(s.imported)} in ${nsId}) {\n${s.local} = ${nsId}[${JSON.stringify(s.imported)}];\n}`).join("\n");
+					const assignments = imp.named.map((s) => `${s.local} = ${nsId}[${JSON.stringify(s.imported)}];`).join("\n");
+					rewrite += `\n${declarations}\n${initializers}\n${pendingId}.then(() => {\n${assignments}\n});`;
 				}
 				ms.overwrite(imp.start, imp.end, rewrite);
 			}
@@ -8451,10 +8466,11 @@ function applyRewrites(code, imports, id) {
 				};
 			});
 			const importLine = `import { __moduleExports as ${nsId}, __mf_remote_pending as ${pendingId} } from ${src};`;
-			const varLines = vars.map((v) => `let ${v.tmp} = ${nsId}[${JSON.stringify(v.local)}];`).join("\n");
+			const varLines = vars.map((v) => `let ${v.tmp};`).join("\n");
+			const initializers = vars.map((v) => `if (${JSON.stringify(v.local)} in ${nsId}) {\n${v.tmp} = ${nsId}[${JSON.stringify(v.local)}];\n}`).join("\n");
 			const syncLine = `${pendingId}.then(() => {\n${vars.map((v) => `${v.tmp} = ${nsId}[${JSON.stringify(v.local)}];`).join("\n")}\n});`;
 			const exportLine = `export { ${vars.map((v) => `${v.tmp} as ${v.exported}`).join(", ")} };`;
-			ms.overwrite(imp.start, imp.end, `${importLine}\n${varLines}\n${syncLine}\n${exportLine}`);
+			ms.overwrite(imp.start, imp.end, `${importLine}\n${varLines}\n${initializers}\n${syncLine}\n${exportLine}`);
 			changed = true;
 			break;
 		}
@@ -9264,8 +9280,11 @@ function getRuntimeCapabilityConfigurationWarnings(options) {
 //#endregion
 //#region src/index.ts
 const patchedManualChunks = /* @__PURE__ */ new WeakSet();
+const federationGroups = /* @__PURE__ */ new WeakSet();
 const PRELOAD_HELPER_CHUNK = "vite-preload-helper";
 const PRELOAD_HELPER_TEST = /\0?vite\/preload-helper/;
+const MF_GROUP_PRIORITY = 1e6;
+const USER_GROUP_MAX_PRIORITY = MF_GROUP_PRIORITY - 1;
 function normalizeVinextRscPreloadHints(code) {
 	return code.replace(/(:HL\[[^\]\n]*?,)"stylesheet"/g, "$1\"style\"").replace(/(:HL\[[^\]\n]*?,)\\"stylesheet\\"/g, "$1\\\"style\\\"");
 }
@@ -9422,6 +9441,14 @@ function includeLinkedSharedEntries(optimizeDeps, shared, projectRoot, exposes,
 	]);
 	for (const [packageName, share] of Object.entries(shared ?? {})) {
 		if (share?.shareConfig?.import === false) continue;
+		const configuredImport = share?.shareConfig?.import;
+		if (typeof configuredImport === "string") {
+			const entry = path$1.isAbsolute(configuredImport) ? configuredImport : path$1.resolve(projectRoot, configuredImport);
+			if (existsSync(entry) && !entry.replaceAll("\\", "/").includes("/node_modules/")) {
+				additions.add(entry);
+				continue;
+			}
+		}
 		const installed = getInstalledPackageJson(packageName, { cwd: projectRoot });
 		if (!installed || installed.dir.replaceAll("\\", "/").includes("/node_modules/")) continue;
 		const entry = getInstalledPackageEntry(packageName, { cwd: projectRoot });
@@ -9604,9 +9631,20 @@ function createEarlyVirtualModulesPlugin(options) {
 									if (args.kind === "entry-point") return;
 									if (!args.importer || args.namespace === "mf-shared") return;
 									if (isSharedResolverInternalImporter(args.importer)) return;
-									if (!findSharedKey(args.path, shared) || isAssetLikeImport(args.path)) return;
+									const key = findSharedKey(args.path, shared);
+									if (!key || isAssetLikeImport(args.path)) return;
 									if (getPackageNameFromNodeModulePath(args.importer) === getPackageName(args.path) && !isReactDomSelfReference(args.path, args.importer)) return;
 									addUsedShares(args.path, options);
+									if (args.kind === "import-statement" || args.kind === "dynamic-import") {
+										const shareItem = shared[key];
+										const loadSharePath = getLoadShareModulePath(args.path, isRolldown, options);
+										writeLoadShareModule(args.path, shareItem, _command, isRolldown, options);
+										if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(args.path, shareItem, options);
+										return {
+											path: loadSharePath,
+											external: true
+										};
+									}
 									return {
 										path: args.path,
 										namespace: "mf-shared"
@@ -9663,7 +9701,7 @@ export default __mfShared.default ?? __mfShared;`
 						optimizeDeps.exclude ??= [];
 						const shouldBypassOptimizeDep = isLitShare(key) || !canResolveSharedSubpath(key, root);
 						if (optimizeDeps.include.includes(key)) optimizeDeps.exclude = optimizeDeps.exclude.filter((dep) => dep !== key);
-						else if (shouldBypassOptimizeDep) optimizeDeps.exclude.push(key);
+						else if (shouldBypassOptimizeDep || optimizeDeps.exclude.includes(key)) optimizeDeps.exclude.push(key);
 						else optimizeDeps.include.push(key);
 						for (const subpath of getCommonSharedSubpaths(key)) {
 							const canResolveSubpath = canResolveSharedSubpath(subpath, root);
@@ -9990,33 +10028,33 @@ function federation(mfUserOptions) {
 					};
 				}
 				let warnedAboutCodeSplitting = false;
-				let warnedAboutCodeSplittingGroups = false;
 				const ensureCodeSplitting = (output) => {
-					if (output?.codeSplitting === false) {
-						delete output.codeSplitting;
-						if (warnedAboutCodeSplitting) return;
-						warnedAboutCodeSplitting = true;
-						mfWarn("Ignoring `output.codeSplitting = false` because module federation requires chunk splitting.");
-						return;
+					if (output?.codeSplitting !== false) return;
+					delete output.codeSplitting;
+					if (warnedAboutCodeSplitting) return;
+					warnedAboutCodeSplitting = true;
+					mfWarn("Ignoring `output.codeSplitting = false` because module federation requires chunk splitting.");
+				};
+				const isFederationGroup = (group) => typeof group === "object" && group !== null && federationGroups.has(group);
+				let warnedAboutGroupPriority = false;
+				const clampUserGroup = (group) => {
+					const candidate = group;
+					if (typeof candidate?.priority !== "number") return group;
+					if (candidate.priority <= USER_GROUP_MAX_PRIORITY) return group;
+					if (!warnedAboutGroupPriority) {
+						warnedAboutGroupPriority = true;
+						mfWarn(`Clamping \`output.codeSplitting.groups\` priority to ${USER_GROUP_MAX_PRIORITY} — module federation groups must keep the highest priority so shared dependency init wrappers stay isolated in their own chunks.`);
 					}
-					if (!output?.codeSplitting || typeof output.codeSplitting !== "object") return;
-					if (!("groups" in output.codeSplitting)) return;
-					const groups = output.codeSplitting.groups;
-					if (Array.isArray(groups) && groups.some((group) => typeof group?.name === "function" && patchedManualChunks.has(group.name))) return;
-					delete output.codeSplitting.groups;
-					if (Object.keys(output.codeSplitting).length === 0) delete output.codeSplitting;
-					if (warnedAboutCodeSplittingGroups) return;
-					warnedAboutCodeSplittingGroups = true;
-					mfWarn("Ignoring `output.codeSplitting.groups` because it conflicts with module federation. Grouping shared dependency init wrappers with their dependent modules can break runtime init order and cause standalone remotes to fail before mount.");
+					return {
+						...candidate,
+						priority: USER_GROUP_MAX_PRIORITY
+					};
 				};
 				let warnedAboutManualChunks = false;
+				let warnedAboutObjectManualChunks = false;
 				const applyManualChunks = (output, useCodeSplitting) => {
 					ensureCodeSplitting(output);
 					const isPatchedByPlugin = typeof output.manualChunks === "function" && patchedManualChunks.has(output.manualChunks);
-					if (output.manualChunks && !isPatchedByPlugin && !warnedAboutManualChunks) {
-						warnedAboutManualChunks = true;
-						mfWarn("Ignoring `output.manualChunks` because it conflicts with module federation. Module federation transforms shared dependency imports with async init wrappers, and grouping these transformed modules into a single chunk creates circular async dependencies that cause the application to silently hang.");
-					}
 					const mfChunkName = function(id) {
 						if (id.includes(runtimeInitId) || id.includes("__mf_v__runtimeInit__mf_v__")) return "runtimeInit";
 						if (id.includes("__loadShare__")) {
@@ -10027,19 +10065,44 @@ function federation(mfUserOptions) {
 					};
 					patchedManualChunks.add(mfChunkName);
 					if (!useCodeSplitting) {
-						const mfManualChunks = function(id) {
+						if (isPatchedByPlugin) return;
+						const userManualChunks = output.manualChunks;
+						if (userManualChunks && typeof userManualChunks !== "function" && !warnedAboutObjectManualChunks) {
+							warnedAboutObjectManualChunks = true;
+							mfWarn("Ignoring the object form of `output.manualChunks` because module federation cannot safely compose with it. Use the function form instead: federation modules are claimed first and your function runs for everything else.");
+						}
+						const mfManualChunks = function(id, ...rest) {
 							if (PRELOAD_HELPER_TEST.test(id)) return PRELOAD_HELPER_CHUNK;
-							return mfChunkName(id) ?? void 0;
+							const mfChunk = mfChunkName(id);
+							if (mfChunk) return mfChunk;
+							if (typeof userManualChunks === "function") return userManualChunks(id, ...rest) ?? void 0;
 						};
 						patchedManualChunks.add(mfManualChunks);
 						output.manualChunks = mfManualChunks;
 						return;
 					}
-					const groups = [{
+					if (output.manualChunks && !isPatchedByPlugin && !warnedAboutManualChunks) {
+						warnedAboutManualChunks = true;
+						mfWarn("Ignoring `output.manualChunks` for the Rolldown build because module federation manages chunking with `output.codeSplitting.groups`. Move your grouping there — user groups are kept below the federation groups.");
+					}
+					const existingGroups = output.codeSplitting && typeof output.codeSplitting === "object" ? output.codeSplitting.groups : void 0;
+					const userGroups = Array.isArray(existingGroups) ? existingGroups.filter((group) => !isFederationGroup(group)).map(clampUserGroup) : [];
+					const mfPreloadGroup = {
 						name: PRELOAD_HELPER_CHUNK,
 						test: PRELOAD_HELPER_TEST,
-						priority: 100
-					}, { name: mfChunkName }];
+						priority: 1000001
+					};
+					const mfNameGroup = {
+						name: mfChunkName,
+						priority: MF_GROUP_PRIORITY
+					};
+					federationGroups.add(mfPreloadGroup);
+					federationGroups.add(mfNameGroup);
+					const groups = [
+						mfPreloadGroup,
+						mfNameGroup,
+						...userGroups
+					];
 					output.codeSplitting = {
 						...output.codeSplitting || {},
 						groups

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/vite",
-  "version": "1.20.8",
+  "version": "1.21.0",
   "description": "Vite plugin for Module Federation",
   "type": "module",
   "main": "./lib/index.js",
@@ -77,9 +77,9 @@
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
   },
   "dependencies": {
-    "@module-federation/dts-plugin": "2.8.2",
-    "@module-federation/runtime": "2.8.2",
-    "@module-federation/sdk": "2.8.2"
+    "@module-federation/dts-plugin": "2.9.0",
+    "@module-federation/runtime": "2.9.0",
+    "@module-federation/sdk": "2.9.0"
   },
   "devDependencies": {
     "@playwright/test": "1.62.0",
@@ -93,4 +93,4 @@
     "vite": "8.2.0",
     "vitest": "4.1.10"
   }
-}
+}