@module-federation/vite 1.23.3 → 1.23.4

package/lib/index.js

@@ -3807,7 +3807,7 @@ function generateLocalSharedImportMap(options) {
             return pkg;`}
         }
       `;
-	}).join(",")}
+	}).filter(Boolean).join(",")}
     }
       const usedShared = {
       ${orderedShares.map((key) => {
@@ -4408,7 +4408,14 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy, options, command = "b
             );
             return;
           }
-          if (typeof isWebpackProvider === 'function' && isWebpackProvider(externalProvider)) return;
+          // Leave an unloaded webpack provider to the late bridge, which only takes a
+          // non-singleton of this share's own version; any other version seeds locally.
+          if (
+            typeof isWebpackProvider === 'function' &&
+            isWebpackProvider(externalProvider) &&
+            (share.shareConfig?.singleton ||
+              __mfFindSharedProviderEntry(initialShared[pkg], externalProvider)?.version === share.version)
+          ) return;
         }
         const providerKey = cacheDescriptor.canonical;
         const resolved = await __mfInitializeProviderOnce(providerKey, async () => {
@@ -5784,7 +5791,8 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
               const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
               if (
                 __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined &&
-                ${_command === "serve" ? `__mfReadSharedCacheOwner(__mfModuleCache.share, cacheDescriptor) !== undefined` : `(
+                ${_command === "serve" ? `__mfReadSharedCacheOwner(__mfModuleCache.share, cacheDescriptor) !== undefined &&
+                      !(share.shareConfig?.singleton && __mfHasAlternativeSharedVersion(pkg, share))` : `(
                         (!share.shareConfig?.singleton && __mfReadSharedCacheOwner(__mfModuleCache.share, cacheDescriptor) === ${cacheOwner}) ||
                         (share.shareConfig?.singleton && !__mfHasAlternativeSharedVersion(pkg, share))
                       )`}
@@ -6496,6 +6504,27 @@ function patchHashEntryFileNames(config, entryName, fileName) {
 	patchBundlerOutput(config.build.rolldownOptions);
 	Object.values(config.environments ?? {}).forEach((environment) => patchHashEntryFileNames(environment, entryName, fileName));
 }
+const ROLLDOWN_RUNTIME_GLOBAL = "__rolldown_runtime__";
+/**
+* Rolldown's dev runtime lives on `globalThis.__rolldown_runtime__`, and its
+* module registry is keyed by cwd-relative ids (`src/App.jsx`). A bundledDev
+* remote loaded into a bundledDev host would share the host's runtime, so the
+* remote's modules, hot contexts and HMR factories would collide with the
+* host's. Give each remote its own same-length global (sourcemaps stay valid)
+* in every chunk and HMR patch it serves.
+*/
+function renameBundledDevRuntime(req, res, remoteName) {
+	if (!req.url || !stripQueryAndHash(req.url).endsWith(".js")) return;
+	const runtimeGlobal = `__mf_rt_${createHash("sha256").update(remoteName).digest("hex").slice(0, 10)}__`;
+	const end = res.end;
+	res.end = function(chunk, ...args) {
+		if (typeof chunk === "string" || chunk instanceof Uint8Array) {
+			const code = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+			if (code.includes(ROLLDOWN_RUNTIME_GLOBAL)) chunk = code.replace(/\b__rolldown_runtime__\b/g, runtimeGlobal);
+		}
+		return end.call(this, chunk, ...args);
+	};
+}
 const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClientInjected, skipTransformFor = [], federationOptions }) => {
 	const DEV_HTML_PROXY_PREFIX = "virtual:mf-html-entry-proxy?";
 	const ENTRY_BOOTSTRAP_PARAM = "mf-entry-bootstrap";
@@ -6518,6 +6547,9 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 	const virtualEntryCode = /* @__PURE__ */ new Map();
 	const ignoredHtmlScriptSources = /* @__PURE__ */ new Set();
 	let bootstrapDir = "";
+	let isBundledDevRemote = false;
+	let bundledDevRemoteEntryCode;
+	let resolveBundledDevRemoteEntryCode;
 	function skipSvelteKitSsrBuild() {
 		return (_command === "build" || viteConfig?.command === "build") && viteConfig?.build?.ssr && hasPackageDependency("@sveltejs/kit");
 	}
@@ -6616,7 +6648,7 @@ const __mfCurrentScript = document.currentScript;
     : import(src);
 ` : "";
 		const importExpression = (src) => useSystemImportFallback ? `__mfImport(${JSON.stringify(src)})` : `import(${JSON.stringify(src)})`;
-		const isEncodedVirtualEntry = entrySrc.startsWith(VITE_ENCODED_NULL_BYTE_PREFIX);
+		const isEncodedVirtualEntry = !options?.isBundled && entrySrc.startsWith(VITE_ENCODED_NULL_BYTE_PREFIX);
 		const entryImportDeclaration = isEncodedVirtualEntry ? `const __mfEntryUrl = ${JSON.stringify(entrySrc)};
 ` : "";
 		const entryImportExpression = isEncodedVirtualEntry ? "import(/* @vite-ignore */ __mfEntryUrl)" : importExpression(entrySrc);
@@ -6638,10 +6670,11 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			const shareItem = getNormalizeShareItem(pkg, federationOptions);
 			const isExplicitShare = Object.hasOwn(federationOptions.shared, pkg);
 			return shareItem?.shareConfig?.singleton === true && shareItem?.shareConfig?.import !== false && !shareItem?.shareConfig?.treeShaking && (isExplicitShare || typeof shareItem?.shareConfig?.import === "string" || Boolean(getProjectResolvedImportPath(pkg)));
-		}).map((pkg) => toViteEncodedId(getLoadShareModulePath(pkg, false, federationOptions))) : [];
-		const sharedPreloadBlock = sharedPreloadSources.length > 0 ? `
-  const __mfSharedPreloadUrls = ${JSON.stringify(sharedPreloadSources)};
-  await Promise.all(__mfSharedPreloadUrls.map((src) => import(/* @vite-ignore */ src).catch((err) => console.warn("[module-federation] shared preload failed:", src, err))));` : "";
+		}).map((pkg) => getLoadShareModulePath(pkg, false, federationOptions)) : [];
+		const sharedPreloadBlock = sharedPreloadSources.length === 0 ? "" : options?.isBundled ? `
+  await Promise.all([${sharedPreloadSources.map((src) => `[${JSON.stringify(src)}, import(${JSON.stringify(src)})]`).join(", ")}].map(([src, load]) => load.catch((err) => console.warn("[module-federation] shared preload failed:", src, err))));` : `
+  const __mfSharedPreloadUrls = ${JSON.stringify(sharedPreloadSources.map(toViteEncodedId))};
+  await Promise.all(__mfSharedPreloadUrls.map((src) => import(/* @vite-ignore */ src).catch((err) => console.warn("[module-federation] shared preload failed:", src, err))));`;
 		const remoteCachePrefix = getRuntimeRemoteCachePrefix(federationOptions);
 		const preloadBlock = remotePreloads ? `
   const runtime = await initHost();
@@ -6768,19 +6801,6 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 		apply: "serve",
 		config(_config, { command }) {
 			_command = command;
-			const isRemoteEntry = entryName === "remoteEntry" && federationOptions !== void 0 && isRemoteContainer(federationOptions);
-			if (command === "serve" && _config.experimental?.bundledDev && isRemoteEntry) {
-				_config.experimental = {
-					..._config.experimental,
-					bundledDev: false
-				};
-				_config.environments ??= {};
-				_config.environments.client ??= {};
-				if (_config.environments.client.isBundled !== false) {
-					_config.environments.client.isBundled = false;
-					mfWarn("Vite bundledDev is disabled for the client environment of a Module Federation remote container so its remoteEntry keeps the standard init/get contract.");
-				}
-			}
 		},
 		configResolved(config) {
 			viteConfig = config;
@@ -6793,6 +6813,10 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 				devEntryPath = config.base + relativePath.replace(/^\//, "");
 			}
 			skipTransformIds = new Set(skipTransformFor.map(resolveProjectId));
+			isBundledDevRemote = config.command === "serve" && entryName === "remoteEntry" && federationOptions !== void 0 && isRemoteContainer(federationOptions) && (config.environments?.client)?.isBundled === true;
+			if (isBundledDevRemote) bundledDevRemoteEntryCode = new Promise((resolve) => {
+				resolveBundledDevRemoteEntryCode = resolve;
+			});
 		},
 		configureServer(server) {
 			devServer = server;
@@ -6820,7 +6844,18 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 				}
 				const devFileName = resolveHashPlaceholderFileName(fileName);
 				if (devFileName !== fileName && req.url?.startsWith((viteConfig.base + devFileName).replace(/^\/?/, "/"))) req.url = req.url.replace(devFileName, fileName);
+				if (isBundledDevRemote) renameBundledDevRuntime(req, res, federationOptions.name);
 				if (req.url && req.url.startsWith((viteConfig.base + fileName).replace(/^\/?/, "/"))) {
+					if (isBundledDevRemote) {
+						const bundledDev = (server.environments?.client)?.bundledDev;
+						Promise.all([bundledDevRemoteEntryCode, bundledDev?.waitForInitialBuildFinish?.()]).then(([code]) => {
+							if (code === void 0) return next();
+							res.setHeader("Content-Type", "text/javascript");
+							res.setHeader("Cache-Control", "no-cache");
+							res.end(code);
+						}, next);
+						return;
+					}
 					req.url = devEntryPath;
 					req.headers["sec-fetch-dest"] = "script";
 				}
@@ -6858,7 +6893,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			const initSrc = params.get("init");
 			const entrySrc = params.get("entry");
 			if (!initSrc || !entrySrc) return;
-			const source = getBootstrapSource(initSrc, entrySrc);
+			const source = getBootstrapSource(initSrc, entrySrc, false, { isBundled: this.environment?.config?.isBundled === true });
 			return warmupDevEntryGraph(entrySrc).then(() => source);
 		},
 		transform(code, id) {
@@ -6901,6 +6936,24 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			}
 			if (htmlFilePath) addHtmlScriptEntries(htmlFilePath);
 		},
+		options(inputOptions) {
+			if (!isBundledDevRemote || !isClientEnvironment(this)) return;
+			const input = inputOptions.input;
+			if (typeof input === "object" && input !== null && !Array.isArray(input)) return {
+				...inputOptions,
+				input: {
+					...input,
+					[entryName]: getEntryPath()
+				}
+			};
+			return {
+				...inputOptions,
+				input: [...input === void 0 ? [] : [input].flat(), getEntryPath()]
+			};
+		},
+		buildEnd(error) {
+			if (error && isBundledDevRemote) resolveBundledDevRemoteEntryCode?.(void 0);
+		},
 		async buildStart() {
 			if (inject === "entry" && waitsForInit && isClientEnvironment(this)) for (const entry of [...entryFiles]) {
 				if (path$1.isAbsolute(entry)) continue;
@@ -6928,6 +6981,15 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			if (htmlFilePath) addHtmlScriptEntries(htmlFilePath);
 		},
 		generateBundle(_options, bundle) {
+			if (isBundledDevRemote && _command === "serve") {
+				const remoteEntryChunk = Object.values(bundle).find((output) => output.type === "chunk" && output.isEntry && output.facadeModuleId === getEntryPath());
+				if (remoteEntryChunk?.type === "chunk") {
+					const code = `export { ${remoteEntryChunk.exports.join(", ")} } from ${JSON.stringify(`./${remoteEntryChunk.fileName}`)};\n`;
+					bundledDevRemoteEntryCode = Promise.resolve(code);
+					resolveBundledDevRemoteEntryCode?.(code);
+				}
+				return;
+			}
 			if (skipSvelteKitSsrBuild()) return;
 			if (entryName === "remoteEntry" && emitFileId && fileName && !viteConfig?.build?.ssr && _options?.format === "es" && viteConfig?.build?.modulePreload !== false) {
 				const remoteEntryFile = findRemoteEntryFile(fileName, bundle);
@@ -7062,7 +7124,10 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 					virtualEntryCode.set(entrySrc, code);
 					entrySrc = toViteEncodedId(entrySrc.slice(1));
 				}
-				return mapCodeToCodeWithSourcemap(getBootstrapSource(getEntryPath(), entrySrc, false, { skipRemotePreload: _command === "serve" && isNuxtEntryAsyncModule }));
+				return mapCodeToCodeWithSourcemap(getBootstrapSource(getEntryPath(), entrySrc, false, {
+					skipRemotePreload: _command === "serve" && isNuxtEntryAsyncModule,
+					isBundled: _command === "serve" && this.environment?.config?.isBundled === true
+				}));
 			}
 		}
 	}];
@@ -7124,6 +7189,16 @@ function checkAliasConflicts(options) {
 const REACT_REFRESH_PATH = "/@react-refresh";
 const LOCAL_REACT_REFRESH_PATH = "/@mf-react-refresh-local";
 const HOST_REACT_REFRESH_URL = "__MF_REACT_REFRESH_URL__";
+const HOST_REACT_REFRESH_RUNTIME = "__MF_REACT_REFRESH_RUNTIME__";
+const LOCAL_REACT_REFRESH_ID = "virtual:mf-react-refresh-local";
+const REACT_REFRESH_EXPORTS = [
+	"injectIntoGlobalHook",
+	"register",
+	"getRefreshReg",
+	"createSignatureFunctionForTransform",
+	"registerExportsForReactRefresh",
+	"validateRefreshBoundaryAndEnqueueUpdate"
+];
 function stripQuery(url) {
 	return url?.replace(/\?.*$/, "");
 }
@@ -7149,8 +7224,9 @@ function resolveReactRefreshRuntime(root) {
 */
 const REACT_REFRESH_PROXY_MODULE = [
 	`const __remoteUrl = new URL(import.meta.url);`,
-	`const __target = window.location.origin === __remoteUrl.origin ? new URL('.${LOCAL_REACT_REFRESH_PATH}', __remoteUrl).href : globalThis.${HOST_REACT_REFRESH_URL} || window.location.origin + '${REACT_REFRESH_PATH}';`,
-	`const __rt = await import(__target);`,
+	`const __isHost = window.location.origin !== __remoteUrl.origin;`,
+	`const __target = __isHost ? globalThis.${HOST_REACT_REFRESH_URL} || window.location.origin + '${REACT_REFRESH_PATH}' : new URL('.${LOCAL_REACT_REFRESH_PATH}', __remoteUrl).href;`,
+	`const __rt = (__isHost && globalThis.${HOST_REACT_REFRESH_RUNTIME}) || await import(__target);`,
 	`export const injectIntoGlobalHook = __rt.injectIntoGlobalHook;`,
 	`export const register = __rt.register;`,
 	`export const getRefreshReg = __rt.getRefreshReg;`,
@@ -7160,34 +7236,64 @@ const REACT_REFRESH_PROXY_MODULE = [
 	`export const __hmr_import = __rt.__hmr_import;`,
 	`export default __rt.default || __rt;`
 ].join("\n");
+/**
+* `/@react-refresh` for a bundledDev remote. The bundle cannot fetch the
+* host's runtime by URL, so it binds lazily to the runtime the host page
+* publishes on a global and falls back to its own copy when opened directly.
+* Both share one component registry with the host's React.
+*/
+const BUNDLED_REACT_REFRESH_MODULE = [
+	`import * as __local from '${LOCAL_REACT_REFRESH_ID}';`,
+	`const __rt = () => globalThis.${HOST_REACT_REFRESH_RUNTIME} || __local;`,
+	...REACT_REFRESH_EXPORTS.map((name) => `export function ${name}(...args) { return __rt().${name}(...args); }`),
+	`export const __hmr_import = __local.__hmr_import;`,
+	`export const __mfLocalRuntime = __local;`,
+	`export default { injectIntoGlobalHook };`
+].join("\n");
 const reactAdapter = {
 	name: "react",
 	pluginNames: ["vite:react-refresh", "vite:react-swc"],
 	host: { transformIndexHtml({ server }) {
 		const refreshPath = `${server.config.base.replace(/\/$/, "")}${REACT_REFRESH_PATH}`;
+		const isBundled = server.config.experimental?.bundledDev === true;
 		return [{
 			tag: "script",
 			children: `globalThis.${HOST_REACT_REFRESH_URL} = new URL(${JSON.stringify(refreshPath)}, window.location.origin).href;`,
 			injectTo: "head-prepend"
+		}, {
+			tag: "script",
+			attrs: { type: "module" },
+			children: `import * as rt from ${JSON.stringify(isBundled ? REACT_REFRESH_PATH : refreshPath)};\nglobalThis.${HOST_REACT_REFRESH_RUNTIME} ??= rt.__mfLocalRuntime || rt;`,
+			injectTo: "head-prepend"
 		}];
 	} },
-	remote: { configureServer({ server }) {
-		let reactRefreshRuntime;
-		server.middlewares.use((req, res, next) => {
-			const url = stripQuery(req.url);
-			if (url?.endsWith(LOCAL_REACT_REFRESH_PATH)) {
-				reactRefreshRuntime ??= resolveReactRefreshRuntime(server.config.root);
+	remote: {
+		configureServer({ server }) {
+			let reactRefreshRuntime;
+			server.middlewares.use((req, res, next) => {
+				const url = stripQuery(req.url);
+				if (url?.endsWith(LOCAL_REACT_REFRESH_PATH)) {
+					reactRefreshRuntime ??= resolveReactRefreshRuntime(server.config.root);
+					res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+					res.setHeader("Access-Control-Allow-Origin", "*");
+					res.end(reactRefreshRuntime);
+					return;
+				}
+				if (!url?.endsWith(REACT_REFRESH_PATH)) return next();
 				res.setHeader("Content-Type", "application/javascript; charset=utf-8");
 				res.setHeader("Access-Control-Allow-Origin", "*");
-				res.end(reactRefreshRuntime);
-				return;
-			}
-			if (!url?.endsWith(REACT_REFRESH_PATH)) return next();
-			res.setHeader("Content-Type", "application/javascript; charset=utf-8");
-			res.setHeader("Access-Control-Allow-Origin", "*");
-			res.end(REACT_REFRESH_PROXY_MODULE);
-		});
-	} }
+				res.end(REACT_REFRESH_PROXY_MODULE);
+			});
+		},
+		resolveId(id) {
+			if (id === LOCAL_REACT_REFRESH_ID) return `\0${LOCAL_REACT_REFRESH_ID}`;
+		},
+		load(id, { root, isBundled }) {
+			if (!isBundled) return;
+			if (id === REACT_REFRESH_PATH) return BUNDLED_REACT_REFRESH_MODULE;
+			if (id === `\0${LOCAL_REACT_REFRESH_ID}`) return resolveReactRefreshRuntime(root);
+		}
+	}
 };
 //#endregion
 //#region src/plugins/hmr/vue.ts
@@ -7574,14 +7680,18 @@ function pluginDevRemoteHmr(options) {
 	const isRemote = Object.keys(options.exposes).length > 0;
 	let adapters = [];
 	let strategy = "full-reload";
+	let root;
+	let devServer;
 	return {
 		name: "module-federation-dev-remote-hmr",
 		apply: "serve",
 		configResolved(config) {
+			root = config.root;
 			adapters = resolveAdapters(config.plugins);
 			strategy = resolveHmrStrategy(options.dev, config.plugins);
 		},
 		configureServer(server) {
+			devServer = server;
 			if (!isRemoteHmrEnabled(options.dev)) return;
 			if (isRemote) {
 				for (const adapter of adapters) adapter.remote?.configureServer?.({
@@ -7599,6 +7709,27 @@ function pluginDevRemoteHmr(options) {
 				if (strategy === "full-reload") setupHostFullReloadRelay(server, options);
 			}
 		},
+		resolveId(id) {
+			if (!isRemote || !isRemoteHmrEnabled(options.dev)) return;
+			for (const adapter of adapters) {
+				const resolved = adapter.remote?.resolveId?.(id);
+				if (resolved) return resolved;
+			}
+		},
+		load: {
+			order: "pre",
+			handler(id) {
+				if (!isRemote || !isRemoteHmrEnabled(options.dev) || !root) return;
+				const isBundled = this.environment?.config?.isBundled === true;
+				for (const adapter of adapters) {
+					const code = adapter.remote?.load?.(id, {
+						root,
+						isBundled
+					});
+					if (code !== void 0) return code;
+				}
+			}
+		},
 		transform: {
 			order: "post",
 			handler(code, id) {
@@ -7617,8 +7748,9 @@ function pluginDevRemoteHmr(options) {
 			order: "pre",
 			handler(_html, ctx) {
 				if (!isRemoteHmrEnabled(options.dev)) return;
-				if (!isHost || !ctx.server) return;
-				return collectHostTags(ctx.server, options, adapters);
+				const server = ctx.server ?? devServer;
+				if (!isHost || !server) return;
+				return collectHostTags(server, options, adapters);
 			}
 		}
 	};
@@ -8134,7 +8266,7 @@ function ${helperName}(names) {
 }
 //#endregion
 //#region package.json
-var version$1 = "1.23.3";
+var version$1 = "1.23.4";
 //#endregion
 //#region src/virtualModules/virtualExposesSSR.ts
 /**
@@ -10806,6 +10938,7 @@ const VarRemoteEntry = (providedOptions) => {
 		*/
 		async generateBundle(_options, bundle) {
 			if (!varFilename) return;
+			if (viteConfig?.command === "serve") return;
 			if (!isValidVarName(name)) mfWarn(`Provided remote name "${name}" is not valid for "var" remoteEntry type, thus it's placed in globalThis['${name}'].\nIt may cause problems, so you would better want to use valid var name (see https://www.w3schools.com/js/js_variables.asp).`);
 			const remoteEntryFile = findRemoteEntryFile(mfOptions.filename, bundle);
 			if (!remoteEntryFile) throw createModuleFederationError(`Couldn't find a remoteEntry chunk file for ${mfOptions.filename}, can't generate varRemoteEntry file`);
@@ -11429,6 +11562,15 @@ 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 getBundledDevHtmlPreambleChunk(id, ctx) {
+	let importers;
+	try {
+		importers = ctx.getModuleInfo(id)?.importers;
+	} catch {
+		return null;
+	}
+	return importers?.some((importer) => importer.includes("?html-proxy")) ? "mf-html-preamble" : null;
+}
 function normalizeVinextRscPreloadHints(code) {
 	return code.replace(/(:HL\[[^\]\n]*?,)"stylesheet"/g, "$1\"style\"").replace(/(:HL\[[^\]\n]*?,)\\"stylesheet\\"/g, "$1\\\"style\\\"");
 }
@@ -12100,6 +12242,124 @@ function federation(mfUserOptions) {
 			return getSharedExportUsage(pkg, shared[key], key, options);
 		});
 	};
+	function applyFederationChunking(config, ctx, snapshotOutput) {
+		const runtimeInitId = getRuntimeInitStatusImportId(options);
+		config.build = config.build || {};
+		let warnedAboutCodeSplitting = false;
+		const ensureCodeSplitting = (output) => {
+			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.`);
+			}
+			return {
+				...candidate,
+				priority: USER_GROUP_MAX_PRIORITY
+			};
+		};
+		const federationGroupDebugName = supportsCodeSplittingGroupDebugName(ctx) ? { debugName: "module-federation" } : {};
+		let warnedAboutManualChunks = false;
+		let warnedAboutObjectManualChunks = false;
+		const applyManualChunks = (output, useCodeSplitting) => {
+			ensureCodeSplitting(output);
+			const isPatchedByPlugin = typeof output.manualChunks === "function" && patchedManualChunks.has(output.manualChunks);
+			const mfChunkName = function(id) {
+				if (id.includes(runtimeInitId) || id.includes("__mf_v__runtimeInit__mf_v__")) return "runtimeInit";
+				if (isSharedCacheHelpersId(id)) return getSharedChunkName(id);
+				if (id.includes("__loadShare__")) {
+					const pkg = getCachedLoadSharePkg(id);
+					const key = pkg && findSharedKey(pkg, shared);
+					if (key && shared[key].shareConfig.eager === true) return "loadShare-eager";
+					if (key && shared[key].shareConfig.import === false) return null;
+					if (pkg && !id.includes("commonjs-proxy") && isCoalescableLoadShareWrapper(pkg, options, id)) return getSharedChunkName(id);
+					const match = id.match(/([^/\\]+__loadShare__[^/\\]+)/);
+					return match ? match[1] : "loadShare";
+				}
+				return null;
+			};
+			patchedManualChunks.add(mfChunkName);
+			if (!useCodeSplitting) {
+				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;
+					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;
+			}
+			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: 1000001
+			};
+			const mfNameGroup = {
+				name: mfChunkName,
+				priority: MF_GROUP_PRIORITY,
+				...federationGroupDebugName
+			};
+			federationGroups.add(mfPreloadGroup);
+			federationGroups.add(mfNameGroup);
+			const groups = [mfPreloadGroup, mfNameGroup];
+			if (!snapshotOutput) {
+				const htmlPreambleGroup = {
+					name: getBundledDevHtmlPreambleChunk,
+					priority: 1000002
+				};
+				federationGroups.add(htmlPreambleGroup);
+				groups.push(htmlPreambleGroup);
+			}
+			groups.push(...userGroups);
+			output.codeSplitting = {
+				...output.codeSplitting || {},
+				groups
+			};
+			delete output.manualChunks;
+		};
+		config.build.rollupOptions = config.build.rollupOptions || {};
+		const rollupOutput = config.build.rollupOptions.output;
+		if (Array.isArray(rollupOutput)) rollupOutput.forEach((output) => applyManualChunks(output, false));
+		else applyManualChunks(config.build.rollupOptions.output ||= {}, false);
+		const buildWithRolldown = config.build;
+		buildWithRolldown.rolldownOptions = buildWithRolldown.rolldownOptions || {};
+		const rolldownOutput = buildWithRolldown.rolldownOptions.output;
+		const snapshotRolldownOutput = (output) => ({
+			entryFileNames: output.entryFileNames,
+			chunkFileNames: output.chunkFileNames,
+			assetFileNames: output.assetFileNames
+		});
+		if (Array.isArray(rolldownOutput)) {
+			rolldownOutput.forEach((output) => applyManualChunks(output, true));
+			if (snapshotOutput) desiredRolldownOutput = rolldownOutput.map((output) => snapshotRolldownOutput(output));
+		} else {
+			applyManualChunks(buildWithRolldown.rolldownOptions.output ||= {}, true);
+			if (snapshotOutput) desiredRolldownOutput = [snapshotRolldownOutput(buildWithRolldown.rolldownOptions.output)];
+		}
+	}
 	return [
 		{
 			name: "vite:module-federation-virtual-modules",
@@ -12229,13 +12489,20 @@ function federation(mfUserOptions) {
 			getParsePromise: () => moduleParseController.parsePromise
 		}),
 		pluginLazyConsumeOnlyShares(options),
+		{
+			name: "module-federation-bundled-dev-chunks",
+			apply: "serve",
+			config(config) {
+				if (!config.experimental?.bundledDev) return;
+				applyFederationChunking(config, this, false);
+			}
+		},
 		{
 			name: "module-federation-esm-shims",
 			enforce: "pre",
 			apply: "build",
 			config(config) {
 				isSsrBuild = Boolean(config.build?.ssr);
-				const runtimeInitId = getRuntimeInitStatusImportId(options);
 				config.build = config.build || {};
 				if (config.build.modulePreload !== false) {
 					const remoteEntryBasename = path$1.posix.basename(options.filename);
@@ -12257,115 +12524,7 @@ function federation(mfUserOptions) {
 						}
 					};
 				}
-				let warnedAboutCodeSplitting = false;
-				const ensureCodeSplitting = (output) => {
-					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.`);
-					}
-					return {
-						...candidate,
-						priority: USER_GROUP_MAX_PRIORITY
-					};
-				};
-				const federationGroupDebugName = supportsCodeSplittingGroupDebugName(this) ? { debugName: "module-federation" } : {};
-				let warnedAboutManualChunks = false;
-				let warnedAboutObjectManualChunks = false;
-				const applyManualChunks = (output, useCodeSplitting) => {
-					ensureCodeSplitting(output);
-					const isPatchedByPlugin = typeof output.manualChunks === "function" && patchedManualChunks.has(output.manualChunks);
-					const mfChunkName = function(id) {
-						if (id.includes(runtimeInitId) || id.includes("__mf_v__runtimeInit__mf_v__")) return "runtimeInit";
-						if (isSharedCacheHelpersId(id)) return getSharedChunkName(id);
-						if (id.includes("__loadShare__")) {
-							const pkg = getCachedLoadSharePkg(id);
-							const key = pkg && findSharedKey(pkg, shared);
-							if (key && shared[key].shareConfig.eager === true) return "loadShare-eager";
-							if (key && shared[key].shareConfig.import === false) return null;
-							if (pkg && !id.includes("commonjs-proxy") && isCoalescableLoadShareWrapper(pkg, options, id)) return getSharedChunkName(id);
-							const match = id.match(/([^/\\]+__loadShare__[^/\\]+)/);
-							return match ? match[1] : "loadShare";
-						}
-						return null;
-					};
-					patchedManualChunks.add(mfChunkName);
-					if (!useCodeSplitting) {
-						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;
-							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;
-					}
-					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: 1000001
-					};
-					const mfNameGroup = {
-						name: mfChunkName,
-						priority: MF_GROUP_PRIORITY,
-						...federationGroupDebugName
-					};
-					federationGroups.add(mfPreloadGroup);
-					federationGroups.add(mfNameGroup);
-					const groups = [
-						mfPreloadGroup,
-						mfNameGroup,
-						...userGroups
-					];
-					output.codeSplitting = {
-						...output.codeSplitting || {},
-						groups
-					};
-					delete output.manualChunks;
-				};
-				config.build.rollupOptions = config.build.rollupOptions || {};
-				const rollupOutput = config.build.rollupOptions.output;
-				if (Array.isArray(rollupOutput)) rollupOutput.forEach((output) => applyManualChunks(output, false));
-				else applyManualChunks(config.build.rollupOptions.output ||= {}, false);
-				const buildWithRolldown = config.build;
-				buildWithRolldown.rolldownOptions = buildWithRolldown.rolldownOptions || {};
-				const rolldownOutput = buildWithRolldown.rolldownOptions.output;
-				const snapshotRolldownOutput = (output) => ({
-					entryFileNames: output.entryFileNames,
-					chunkFileNames: output.chunkFileNames,
-					assetFileNames: output.assetFileNames
-				});
-				if (Array.isArray(rolldownOutput)) {
-					rolldownOutput.forEach((output) => applyManualChunks(output, true));
-					desiredRolldownOutput = rolldownOutput.map((output) => snapshotRolldownOutput(output));
-				} else {
-					applyManualChunks(buildWithRolldown.rolldownOptions.output ||= {}, true);
-					desiredRolldownOutput = [snapshotRolldownOutput(buildWithRolldown.rolldownOptions.output)];
-				}
+				applyFederationChunking(config, this, true);
 			},
 			async buildApp(builder) {
 				const desiredOutput = desiredRolldownOutput;

package/package.json

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