@module-federation/vite 1.20.9 → 1.21.1

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

@@ -707,9 +707,26 @@ function normalizeShareItem(key, shareItem) {
 		}
 	};
 }
+/**
+* Trailing-slash keys are package namespace prefixes (`lodash/`, `@scope/ui/`).
+*
+* Packages in COMMON_SHARED_SUBPATHS historically collapsed `pkg/` → `pkg` so
+* Vite would not resolve the invalid `pkg/` specifier, while still auto-mapping
+* known subpaths when a local provider exists.
+*
+* `react/` is different: consumer-only shares need true namespace coverage for
+* any actually-imported subpath, not a hardcoded export list. Keep `react/` as
+* a prefix; concrete subpaths materialize on import via the generic matcher.
+*
+* `react-dom/` must keep collapsing. A browser-wide `react-dom/` prefix would
+* also capture `react-dom/server*`, which is unsafe without environment-aware
+* filtering. Browser-safe entries such as `react-dom/client` stay explicit via
+* COMMON_SHARED_SUBPATHS (local provider) or an exact shared key.
+*/
 function normalizeSharedKey(key) {
 	if (!key.endsWith("/")) return key;
 	const baseKey = key.slice(0, -1);
+	if (baseKey === "react") return key;
 	return getCommonSharedSubpaths(baseKey).length > 0 ? baseKey : key;
 }
 function normalizeShared(shared) {
@@ -1982,6 +1999,10 @@ function getPackageEsmEntryPath(pkg) {
 	}) || resolvePackageEntryFromProjectRoot(pkg);
 }
 const packageNamedExportsCache = /* @__PURE__ */ new Map();
+const sharedExportInspectionCache = /* @__PURE__ */ new Map();
+function invalidateSharedExportInspectionCache(filePath) {
+	if (!/(?:^|[/\\])node_modules(?:[/\\]|$)/.test(filePath)) sharedExportInspectionCache.clear();
+}
 const DEFAULT_SHARED_EXPORT_CONDITIONS = [
 	"browser",
 	"import",
@@ -2009,17 +2030,22 @@ function hasCommonJsExports(source) {
 	return false;
 }
 function inspectSharedExportsFromFile(entryPath, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
+	if (!entryPath) return void 0;
+	const cacheKey = `${entryPath}\0${exportConditions.join("\0")}`;
+	if (sharedExportInspectionCache.has(cacheKey)) return sharedExportInspectionCache.get(cacheKey);
 	try {
-		if (!entryPath) return void 0;
 		const source = readFileSync(entryPath, "utf-8");
 		const scanState = { complete: true };
 		const namedExports = getNamedExportsViaRegex(source, entryPath, void 0, scanState, exportConditions);
 		const commonJs = hasCommonJsExports(source);
-		return {
+		const inspection = {
 			namedExports: scanState.complete && !commonJs ? namedExports : void 0,
 			commonJs
 		};
+		sharedExportInspectionCache.set(cacheKey, inspection);
+		return inspection;
 	} catch {
+		sharedExportInspectionCache.set(cacheKey, void 0);
 		return;
 	}
 }
@@ -3616,7 +3642,9 @@ const externalSharedProviderSelectionHelperCode = `const __mfSelectExternalShare
           ) => {
             const isLocalProvider = (provider) => __mfMatchesSharedProvider(provider, localShare);
             const candidates = Object.fromEntries(
-              Object.entries(versions || {}).filter(([, provider]) => !isLocalProvider(provider))
+              Object.entries(versions || {}).filter(([, provider]) =>
+                !isLocalProvider(provider) && provider?.shareConfig?.import !== false
+              )
             );
             if (localShare?.version && localShare.shareConfig?.import !== false) {
               const sameVersionProvider = candidates[localShare.version];
@@ -4019,6 +4047,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
 	const needsSharedProviderSelectionHelper = Object.keys(options.shared ?? {}).length > 0;
 	const hasTreeShakingShared = Object.values(options.shared ?? {}).some((share) => !!share?.shareConfig.treeShaking);
 	const hasMultipleShareScopes = Array.isArray(options.shareScope);
+	const guardHostAutoInit = command === "build" && Object.keys(options.exposes ?? {}).length > 0 && Object.keys(options.remotes ?? {}).length > 0;
 	const materializedShareBatches = toSafeJsLiteral(getShareBatches(options, false));
 	const runtimeImports = [
 		"init as runtimeInit",
@@ -4925,10 +4954,13 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
     }
     return (exposesMap[moduleName])().then(res => () => res)
   }
-  export {
-      init,
-      getExposes as get
+  ${guardHostAutoInit ? `let __mfInitPromise;
+  function __mfGuardedInit(shared, initScope) {
+    if (shared === undefined && __mfInitPromise) return __mfInitPromise;
+    __mfInitPromise = init(shared, initScope);
+    return __mfInitPromise;
   }
+  export { __mfGuardedInit as init, getExposes as get }` : `export { init, getExposes as get }`}
   `;
 }
 /**
@@ -5563,6 +5595,7 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 	let emittedFileName;
 	let skipTransformIds = /* @__PURE__ */ new Set();
 	let injectedTransformIds = /* @__PURE__ */ new Set();
+	const ignoredHtmlScriptSources = /* @__PURE__ */ new Set();
 	let bootstrapDir = "";
 	function skipSvelteKitSsrBuild() {
 		return (_command === "build" || viteConfig?.command === "build") && viteConfig?.build?.ssr && hasPackageDependency("@sveltejs/kit");
@@ -5764,6 +5797,10 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 		const scriptRegex = /<script\b(?=[^>]*\btype=["']module["'])(?=[^>]*\bsrc=["']([^"']+)["'])[^>]*>/gi;
 		let match;
 		while ((match = scriptRegex.exec(htmlContent)) !== null) {
+			if (/\svite-ignore(?:\s|=|\/?>)/i.test(match[0])) {
+				ignoredHtmlScriptSources.add(match[1]);
+				continue;
+			}
 			const scriptSrc = stripQueryAndHash$1(match[1]);
 			if (/^(?:[a-z]+:)?\/\//i.test(scriptSrc)) continue;
 			addEntryFile(scriptSrc);
@@ -5945,6 +5982,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 				const scriptRegex = /<script\b(?=[^>]*\btype=["']module["'])(?=[^>]*\bsrc=["']([^"']+)["'])[^>]*>\s*<\/script>/gi;
 				let rewritten = false;
 				htmlContent = htmlContent.replace(scriptRegex, (scriptTag, entrySrc) => {
+					if (ignoredHtmlScriptSources.has(entrySrc)) return scriptTag;
 					rewritten = true;
 					const strippedInit = stripBase(initPath);
 					const strippedEntry = stripBase(entrySrc);
@@ -9280,8 +9318,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\\\"");
 }
@@ -9771,7 +9812,7 @@ function applyBuildTimeRuntimeDefines(define, options, { target, isAstro, defaul
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-BNCg4Gri.js").then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-sJeW2nss.js").then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {
@@ -9882,6 +9923,11 @@ function federation(mfUserOptions) {
 		{
 			name: "vite:module-federation-virtual-modules",
 			enforce: "pre",
+			configureServer(server) {
+				server.watcher.on("change", invalidateSharedExportInspectionCache);
+				server.watcher.on("add", invalidateSharedExportInspectionCache);
+				server.watcher.on("unlink", invalidateSharedExportInspectionCache);
+			},
 			resolveId(id) {
 				if (id === "@module-federation/vite/ssrEntryLoader") return resolveImportPath(id);
 				let virtualModule = VirtualModule.findById(id);
@@ -10025,33 +10071,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__")) {
@@ -10062,19 +10108,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
@@ -10127,6 +10198,10 @@ function federation(mfUserOptions) {
 				}
 			},
 			load(id, loadOptions) {
+				if (id.includes("__loadShare__") && id.endsWith("?commonjs-proxy")) {
+					const target = id.slice(id.startsWith("\0") ? 1 : 0, -15);
+					return `export { __moduleExports as default } from ${JSON.stringify(target)};`;
+				}
 				const loadVirtualModule = (importFalseExportUsage) => {
 					if (!id.includes("__loadShare__") && !id.includes("__loadRemote__")) return;
 					if (id.includes("__loadRemote__") && !refreshLoadRemoteModuleForEnvironment(id, this, loadOptions)) return;

package/lib/{pluginDts-BNCg4Gri.js → pluginDts-sJeW2nss.js}

@@ -2,6 +2,7 @@ import { n as normalizePathForImport } from "./buildPaths-BkaQHrd2.js";
 import { _ as mfError, g as createModuleFederationError, l as hasPackageDependency, p as resolveImportPath } from "./dtsConstants-DyJrx8ah.js";
 import fs from "fs";
 import * as path$1 from "node:path";
+import os from "os";
 import { normalizeOptions } from "@module-federation/sdk";
 import { consumeTypesAPI, generateTypesAPI, isTSProject, normalizeConsumeTypesOptions, normalizeDtsOptions, normalizeGenerateTypesOptions } from "@module-federation/dts-plugin";
 import { rpc } from "@module-federation/dts-plugin/core";
@@ -12,7 +13,26 @@ const DEFAULT_DEV_OPTIONS = {
 	disableDynamicRemoteTypeHints: false
 };
 const DYNAMIC_HINTS_PLUGIN = "@module-federation/dts-plugin/dynamic-remote-type-hints-plugin";
-const getIPv4 = () => process.env["FEDERATION_IPV4"] || "127.0.0.1";
+const localIpv4 = "127.0.0.1";
+const getIpv4Interfaces = () => {
+	try {
+		const interfaces = os.networkInterfaces();
+		const ipv4Interfaces = [];
+		Object.values(interfaces).forEach((detail) => {
+			detail?.forEach((detail) => {
+				const familyV4Value = typeof detail.family === "string" ? "IPv4" : 4;
+				if (detail.family === familyV4Value && detail.address !== localIpv4) ipv4Interfaces.push(detail);
+			});
+		});
+		return ipv4Interfaces;
+	} catch (_err) {
+		return [];
+	}
+};
+const getIPv4 = () => {
+	if (process.env["FEDERATION_IPV4"]) return process.env["FEDERATION_IPV4"];
+	return (getIpv4Interfaces()[0] || { address: localIpv4 }).address;
+};
 const DEV_TYPES_FOLDER = ".dev-server";
 const forkDevWorkerPath = (() => {
 	return resolveImportPath("@module-federation/dts-plugin/dist/fork-dev-worker.js");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/vite",
-  "version": "1.20.9",
+  "version": "1.21.1",
   "description": "Vite plugin for Module Federation",
   "type": "module",
   "main": "./lib/index.js",