@module-federation/vite 1.23.3 → 1.23.5

package/lib/index.js

@@ -1,6 +1,6 @@
-import { _ as resolvePublicPath, a as matchesSharedSource, c as filterId, d as getNodeModulesSuffix, f as isAssetLikeImport, g as normalizeNodeModulePath, h as isViteOptimizableEntry, i as invalidateSharedKeyMatcher, l as getBasePath$1, m as isNuxtClientBase, n as getSharedRequest, p as isNodeModulePath, r as getSharedRuntimeKey, s as ensureTrailingSlash, t as findSharedKey, u as getCommonSharedSubpaths, v as stripQueryAndHash, y as stripViteFsPrefix } from "./sharedKeyMatcher-Od_nYxJA.js";
+import { _ as removeTrailingSlash, a as matchesSharedSource, b as stripViteFsPrefix, c as filterId, d as getNodeModulesSuffix, f as isAssetLikeImport, g as normalizeNodeModulePath, h as isViteOptimizableEntry, i as invalidateSharedKeyMatcher, l as getBasePath$1, m as isNuxtClientBase, n as getSharedRequest, p as isNodeModulePath, r as getSharedRuntimeKey, s as ensureTrailingSlash, t as findSharedKey, u as getCommonSharedSubpaths, v as resolvePublicPath, y as stripQueryAndHash } from "./sharedKeyMatcher-CHp4QRNq.js";
 import { a as CodeRewriter, c as isAbsoluteUrl, d as resolveHashPlaceholderFileName, i as createCodePositionMap, l as normalizePathForImport, o as createSourceMap, r as mfWarn, t as createModuleFederationError, u as rebaseImport } from "./logger-DOwfTlw5.js";
-import { C as isReactCoreShare, S as REACT_DOM_CLIENT_SHARE, _ as resolveModulePath, a as getIsRolldown, b as supportsCodeSplittingGroupDebugName, c as getPackageNameFromNodeModulePath, d as isNuxtProjectRoot, f as isPackageExportAvailable, g as resolveImportPath, h as packageNameEncode, i as getInstalledPackageJson, l as getSharedCacheDescriptor, m as packageNameDecode, n as getDependencyNames, o as getPackageDetectionCwd, p as isPackageInstalled, r as getInstalledPackageEntry, s as getPackageName, u as hasPackageDependency, v as setPackageDetectionCwd, x as REACT_CLIENT_INTERNALS_KEY, y as sharedCacheHelperCode } from "./dtsConstants-DSTzyKSG.js";
+import { C as REACT_DOM_CLIENT_SHARE, S as REACT_CLIENT_INTERNALS_KEY, _ as resolveImportPath, a as getIsRolldown, b as sharedCacheHelperCode, c as getPackageName, d as hasPackageDependency, f as isNuxtProjectRoot, g as packageNameEncode, h as packageNameDecode, i as getInstalledPackageJson, l as getPackageNameFromNodeModulePath, m as isPackageInstalled, n as getDependencyNames, o as getPackageDetectionCwd, p as isPackageExportAvailable, r as getInstalledPackageEntry, s as getPackageExportSpecifiersForFile, u as getSharedCacheDescriptor, v as resolveModulePath, w as isReactCoreShare, x as supportsCodeSplittingGroupDebugName, y as setPackageDetectionCwd } from "./dtsConstants-BQdFpgKb.js";
 import { createRequire } from "node:module";
 import * as fs$2 from "fs";
 import { existsSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "fs";
@@ -977,6 +977,16 @@ function getSsrCapabilities(viteMajor, command, hasRemotes, isSsr = false) {
 	};
 }
 //#endregion
+//#region src/utils/runtimePluginSpecifier.ts
+function getRuntimePluginSpecifier(plugin) {
+	return typeof plugin === "string" ? plugin : plugin[0];
+}
+/** Drop SSR-only plugins from a client graph; a server graph keeps them all. */
+function filterRuntimePluginsForTarget(runtimePlugins, ssrOnlySpecifiers, isServer) {
+	if (isServer) return [...runtimePlugins];
+	return runtimePlugins.filter((plugin) => !ssrOnlySpecifiers.has(getRuntimePluginSpecifier(plugin)));
+}
+//#endregion
 //#region src/utils/serializeRuntimeOptions.ts
 const UNSAFE_JS_CHAR_MAP = {
 	"<": "\\u003C",
@@ -1074,16 +1084,6 @@ function isParsableExpression(source) {
 	}
 }
 //#endregion
-//#region src/utils/runtimePluginSpecifier.ts
-function getRuntimePluginSpecifier(plugin) {
-	return typeof plugin === "string" ? plugin : plugin[0];
-}
-/** Drop SSR-only plugins from a client graph; a server graph keeps them all. */
-function filterRuntimePluginsForTarget(runtimePlugins, ssrOnlySpecifiers, isServer) {
-	if (isServer) return [...runtimePlugins];
-	return runtimePlugins.filter((plugin) => !ssrOnlySpecifiers.has(getRuntimePluginSpecifier(plugin)));
-}
-//#endregion
 //#region src/utils/importAnalysis.ts
 const analysisByBuild = /* @__PURE__ */ new WeakMap();
 /**
@@ -2281,8 +2281,37 @@ function hasCodeMatch(source, regex, codePositions) {
 	while ((match = regex.exec(source)) !== null) if (codePositions[match.index]) return true;
 	return false;
 }
+/**
+* True when the file contains a top-level static `import`/`export` declaration.
+* Local identifiers named `module` or `exports` (webpack/rspack helpers,
+* function parameters, etc.) must not override that module format.
+*/
+function hasEsmModuleSyntax(source, codePositions) {
+	const keywordRegex = /(?<![$\w])(?:import|export)\b/g;
+	let match;
+	let braceDepth = 0;
+	let braceScanIndex = 0;
+	while ((match = keywordRegex.exec(source)) !== null) {
+		for (; braceScanIndex < match.index; braceScanIndex++) {
+			if (!codePositions[braceScanIndex]) continue;
+			if (source[braceScanIndex] === "{") braceDepth++;
+			else if (source[braceScanIndex] === "}") braceDepth--;
+		}
+		if (!codePositions[match.index]) continue;
+		if (braceDepth !== 0) continue;
+		let previousCodeIndex = match.index - 1;
+		while (previousCodeIndex >= 0 && (/\s/.test(source[previousCodeIndex]) || !codePositions[previousCodeIndex])) previousCodeIndex--;
+		if (source[previousCodeIndex] === ".") continue;
+		let nextCodeIndex = match.index + match[0].length;
+		while (nextCodeIndex < source.length && (/\s/.test(source[nextCodeIndex]) || !codePositions[nextCodeIndex])) nextCodeIndex++;
+		if (source[nextCodeIndex] === "(") continue;
+		return true;
+	}
+	return false;
+}
 function hasCommonJsExports(source) {
 	const codePositions = createCodePositionMap(source);
+	if (hasEsmModuleSyntax(source, codePositions)) return false;
 	if (hasCodeMatch(source, /\bmodule\s*(?:\.exports|\[\s*['"]exports['"]\s*\])/g, codePositions)) return true;
 	const exportsRegex = /\bexports\s*(?:\.|\[|[,)]|=(?!=|>))/g;
 	let match;
@@ -2895,7 +2924,15 @@ function getWorkspacePackageJson(pkg) {
 		fromResolvedEntry: resolved
 	})?.packageJson;
 }
+const sharedDependencyGraphPackageJsonCache = /* @__PURE__ */ new Map();
 function getSharedDependencyGraphPackageJson(pkg) {
+	const cacheKey = `${getPackageDetectionCwd()}\0${pkg}`;
+	if (sharedDependencyGraphPackageJsonCache.has(cacheKey)) return sharedDependencyGraphPackageJsonCache.get(cacheKey);
+	const packageJson = resolveSharedDependencyGraphPackageJson(pkg);
+	sharedDependencyGraphPackageJsonCache.set(cacheKey, packageJson);
+	return packageJson;
+}
+function resolveSharedDependencyGraphPackageJson(pkg) {
 	const installedPackageJson = getInstalledPackageJson(pkg, { packageName: getPackageName(pkg) })?.packageJson;
 	if (installedPackageJson) return installedPackageJson;
 	try {
@@ -2904,7 +2941,16 @@ function getSharedDependencyGraphPackageJson(pkg) {
 	} catch {}
 	return getWorkspacePackageJson(pkg);
 }
+const sharedSingletonConsumedByPeerCache = /* @__PURE__ */ new WeakMap();
 function isSharedSingletonConsumedByPeer(pkg, options = getNormalizeModuleFederationOptions(), requireFederationRuntimeDependency = false) {
+	if (!options) return computeSharedSingletonConsumedByPeer(pkg, options, requireFederationRuntimeDependency);
+	let cache = sharedSingletonConsumedByPeerCache.get(options);
+	if (!cache) sharedSingletonConsumedByPeerCache.set(options, cache = /* @__PURE__ */ new Map());
+	const cacheKey = `${getPackageDetectionCwd()}\0${pkg}\0${requireFederationRuntimeDependency}`;
+	if (!cache.has(cacheKey)) cache.set(cacheKey, computeSharedSingletonConsumedByPeer(pkg, options, requireFederationRuntimeDependency));
+	return cache.get(cacheKey);
+}
+function computeSharedSingletonConsumedByPeer(pkg, options, requireFederationRuntimeDependency) {
 	const shared = options?.shared || {};
 	if (!requireFederationRuntimeDependency && Object.entries(shared).some(([key, item]) => key !== pkg && key.startsWith(`${pkg}/`) && item.shareConfig.singleton === true)) return true;
 	const sharedKeyByPackageName = /* @__PURE__ */ new Map();
@@ -3356,6 +3402,7 @@ function generateLazyWorkspaceSingletonExports(edges, namedExports, importSource
 	const trackPendingLoad = `__mfTrackPendingShareLoad(${deferredEntryFallback ? deferredEntryLoad : deferredInitLoad});`;
 	return `${declarations}
     const __mfApplyLazyShareExports = (mod) => {
+      exportModule = mod;
       ${assignments}
     };
     __mfSubscribeSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfApplyLazyShareExports);
@@ -3369,7 +3416,7 @@ function generateLazyWorkspaceSingletonExports(edges, namedExports, importSource
     } else {
       __mfApplyLazyShareExports(exportModule);
     }
-    export { __mf_default as default };${namedExportLine}${mutableExportLine}`;
+    export { __mf_default as default, exportModule as __moduleExports };${namedExportLine}${mutableExportLine}`;
 }
 const WORKSPACE_SINGLETON_SSR_LOCAL_SHARE = "__mfNormalizeShareModule(__mfLocalShare)";
 function prependWorkspaceSingletonSsrImport(code) {
@@ -3769,7 +3816,24 @@ function generateLocalSharedImportMap(options) {
         // A host seed from an older React family is not coherent with the newer cached react
         const cachedVersion = cached?.version ?? cached?.default?.version;
         if (cachedVersion !== undefined && isOlder(cachedVersion)) continue;
-        if (!requiredExport || typeof cached?.[requiredExport] === 'function' || typeof cached?.default?.[requiredExport] === 'function') return cached;
+        if (!requiredExport || typeof cached?.[requiredExport] === 'function' || typeof cached?.default?.[requiredExport] === 'function') {
+          const dom = typeof cached?.[requiredExport] === 'function' ? cached : cached?.default;
+          const internals = dom?.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+          if (!requiredExport || key.endsWith('/client') || !internals) return cached;
+          // React 18 root: mirror react-dom/client.js, or createRoot warns it was imported from "react-dom"
+          const client = {};
+          for (const name of ['createRoot', 'hydrateRoot']) {
+            client[name] = (...args) => {
+              internals.usingClientEntryPoint = true;
+              try {
+                return dom[name](...args);
+              } finally {
+                internals.usingClientEntryPoint = false;
+              }
+            };
+          }
+          return { ...client, default: client };
+        }
       }
       return undefined;
     };
@@ -3807,7 +3871,7 @@ function generateLocalSharedImportMap(options) {
             return pkg;`}
         }
       `;
-	}).join(",")}
+	}).filter(Boolean).join(",")}
     }
       const usedShared = {
       ${orderedShares.map((key) => {
@@ -3992,7 +4056,8 @@ function getMaterializedShares(options) {
 		const dependencies = {
 			...packageJson?.dependencies || {},
 			...packageJson?.peerDependencies || {},
-			...packageJson?.optionalDependencies || {}
+			...packageJson?.optionalDependencies || {},
+			...packageJson?.peerDependenciesMeta || {}
 		};
 		for (const dependency of Object.keys(dependencies)) {
 			const sharedDependency = configured.get(dependency);
@@ -4028,7 +4093,8 @@ function getSharePrerequisites(ordered) {
 		const dependencies = {
 			...packageJson?.dependencies || {},
 			...packageJson?.peerDependencies || {},
-			...packageJson?.optionalDependencies || {}
+			...packageJson?.optionalDependencies || {},
+			...packageJson?.peerDependenciesMeta || {}
 		};
 		const prerequisites = Object.keys(dependencies).map((dependency) => roots.get(dependency)).filter((dependency) => Boolean(dependency));
 		if (pkg !== packageName && (packageName === "react" || packageName === "react-dom")) {
@@ -4072,7 +4138,8 @@ function orderSharedDependenciesFirst(sharedPackages) {
 		const dependencies = {
 			...packageJson?.dependencies || {},
 			...packageJson?.peerDependencies || {},
-			...packageJson?.optionalDependencies || {}
+			...packageJson?.optionalDependencies || {},
+			...packageJson?.peerDependenciesMeta || {}
 		};
 		Object.keys(dependencies).forEach((dependency) => {
 			const sharedDependency = sharedKeyByPackageName.get(dependency);
@@ -4312,21 +4379,33 @@ const externalSharedProviderSelectionHelperCode = `const __mfSelectExternalShare
 /**
 * A consume-only stub never outranks a provider: when registering this container's
 * `import: false` share replaces an unloaded provider of the same version (#1311),
-* the `afterRegisterShare` hook restores the provider. Registered once per instance.
+* the `afterRegisterShare` hook restores the provider, and a provider kept out by an
+* unloaded stub takes its slot. Registered once per instance.
 */
 function generateKeepProvidersOverStubsCode(runtimeVar) {
 	return `if (!${runtimeVar}.__mfKeepAdoptedProviders) {
       ${runtimeVar}.__mfKeepAdoptedProviders = true;
       ${runtimeVar}.sharedHandler?.hooks?.lifecycle?.afterRegisterShare?.on?.((args) => {
         const { shared, previousShared, registeredShared } = args || {};
+        const versions = ${runtimeVar}.shareScopeMap?.[args.scope]?.[args.pkgName];
+        if (!shared || !versions) return;
+        // The reverse: a stub already in the slot (e.g. a loaded-first parent's) keeps a provider
+        // out, and a webpack consumer reading the scope then falls back to its own copy.
+        if (shared.shareConfig?.import !== false) {
+          if (
+            registeredShared !== shared &&
+            registeredShared?.shareConfig?.import === false &&
+            !registeredShared.loaded &&
+            versions[shared.version] === registeredShared
+          ) versions[shared.version] = shared;
+          return;
+        }
         if (
-          shared?.shareConfig?.import !== false ||
           registeredShared !== shared ||
           !previousShared ||
           previousShared.shareConfig?.import === false
         ) return;
-        const versions = ${runtimeVar}.shareScopeMap?.[args.scope]?.[args.pkgName];
-        if (versions && versions[shared.version] === shared) versions[shared.version] = previousShared;
+        if (versions[shared.version] === shared) versions[shared.version] = previousShared;
       });
     }`;
 }
@@ -4408,7 +4487,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 () => {
@@ -4503,7 +4589,7 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy, options, command = "b
     var __mfDeferredSeedKeys = __mfSeedKeys.filter(
       (pkg) => __mfPreInitBlockedSeedKeys.has(__mfSeedIndex.get(pkg))
     );
-    await __mfSeedLocalShared(__mfImmediateSeedKeys);`;
+    await __mfSeedLocalShared(__mfImmediateSeedKeys).catch(__mfRejectInit);`;
 }
 function getBrowserImportPath(importPath) {
 	if (/^(?:[a-zA-Z]:[\\/]|\/)/.test(importPath) && !importPath.startsWith("/@")) return `/@fs/${importPath}`;
@@ -4754,7 +4840,12 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   ${runtimeHelperImports.length ? `import {${runtimeHelperImports.join(", ")}} from "@module-federation/runtime/helpers";` : ""}
   ${pluginImportNames.filter((item) => !isSsrOnlyPlugin(item[1])).map((item) => item[1]).join("\n")}
   import __mfExposesMap from "${virtualExposesId}"
-  ${command === "build" ? getRuntimeInitResolveBootstrapCode(false, getRuntimeInitStatusImportId(options)) : getRuntimeInitBootstrapCode(false, getRuntimeInitStatusImportId(options), void 0, void 0, exportConditions) + "\n  const { initResolve } = globalThis[globalKey];"}
+  ${command === "build" ? getRuntimeInitResolveBootstrapCode(false, getRuntimeInitStatusImportId(options)) + "\n  const { initReject } = __mfResolveState;" : getRuntimeInitBootstrapCode(false, getRuntimeInitStatusImportId(options), void 0, void 0, exportConditions) + "\n  const { initResolve, initReject } = globalThis[globalKey];"}
+  // A failed seed must settle initPromise, or every pending share load hangs forever.
+  const __mfRejectInit = (err) => {
+    initReject(err);
+    throw err;
+  };
   ${getRuntimeModuleCacheBootstrapCode(exportConditions)}
   const initTokens = {}
   const shareScopeNames = Array.isArray(${toSafeJsLiteral(options.shareScope)}) ? ${toSafeJsLiteral(options.shareScope)} : [${toSafeJsLiteral(options.shareScope)}]
@@ -5648,7 +5739,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
     __mfReadyDeferredSeedKeys.push(...__mfDeferredSeedKeys.filter(
       (pkg) => !__mfBlockedSeedKeys.has(__mfSeedIndex.get(pkg))
     ));
-    await __mfSeedLocalShared(__mfReadyDeferredSeedKeys);
+    await __mfSeedLocalShared(__mfReadyDeferredSeedKeys).catch(__mfRejectInit);
     ${command === "build" ? `// A consume-only share reached only through import() is bridged when that import runs
     // (see pluginLazyConsumeOnlyShares), through the same provider selection init() uses.
     const __mfLazyShareLoads = new Map();
@@ -5784,7 +5875,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 +6588,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 +6631,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 +6732,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 +6754,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 +6885,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 +6897,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 +6928,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 +6977,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 +7020,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 +7065,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 +7208,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 +7273,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 +7308,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 +7320,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 +7764,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 +7793,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 +7832,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 +8350,7 @@ function ${helperName}(names) {
 }
 //#endregion
 //#region package.json
-var version$1 = "1.23.3";
+var version$1 = "1.23.5";
 //#endregion
 //#region src/virtualModules/virtualExposesSSR.ts
 /**
@@ -8856,43 +9072,89 @@ function getStatsFileName(manifestFileName) {
 //#endregion
 //#region src/utils/sharedSource.ts
 const pendingEntryLookups = /* @__PURE__ */ new Map();
+const pendingLookupImporters = /* @__PURE__ */ new Map();
+const increment = (map, key) => map.set(key, (map.get(key) ?? 0) + 1);
+const decrement = (map, key) => {
+	const remaining = map.get(key) - 1;
+	if (remaining) map.set(key, remaining);
+	else map.delete(key);
+};
 const getEntryLookupKey = (source, importer) => `${source}\0${importer}`;
+/**
+* Rolldown saves each this.resolve() call's options under the map's current size and deletes the
+* entry when the call settles, so an overlapping call can receive the wrong `custom` metadata.
+* Taking the first free key keeps every in-flight entry intact. A no-op when the internals differ.
+*/
+function patchRolldownResolveOptionKeys(context) {
+	const data = context?.data;
+	const map = data?.resolveOptionsMap;
+	if (!data || !(map instanceof Map) || typeof data.saveResolveOptions !== "function") return;
+	if (data.__mfFreeKeyPatch) return;
+	data.saveResolveOptions = (options) => {
+		let index = map.size;
+		while (map.has(index)) index++;
+		map.set(index, options);
+		return index;
+	};
+	data.__mfFreeKeyPatch = true;
+}
 /** Whether a resolveId call is one of the shared source resolver's own entry lookups. */
 function isSharedEntryLookup(source, importer, options) {
-	return options.custom?.__mfSharedEntryLookup === true || pendingEntryLookups.has(getEntryLookupKey(source, importer));
+	if (pendingEntryLookups.has(getEntryLookupKey(source, importer))) return true;
+	return options?.custom?.__mfSharedEntryLookupImporter === importer && pendingLookupImporters.has(importer);
 }
 /**
 * Runs one of the plugin's own `this.resolve()` calls (a shared entry lookup, a
-* parse-barrier external probe), marked so `isSharedEntryLookup` recognizes it
+* parse-barrier external probe), tracked so `isSharedEntryLookup` recognizes it
 * and the share hooks neither proxy it nor register a used share for it.
 */
 async function resolveInternally(context, source, importer, options = {}) {
 	const lookupKey = getEntryLookupKey(source, importer);
-	pendingEntryLookups.set(lookupKey, (pendingEntryLookups.get(lookupKey) ?? 0) + 1);
+	increment(pendingEntryLookups, lookupKey);
+	increment(pendingLookupImporters, importer);
 	try {
 		return await context.resolve(source, importer, {
 			...options,
-			skipSelf: true,
 			custom: {
 				...options.custom,
-				__mfSharedEntryLookup: true
-			}
+				__mfSharedEntryLookupImporter: importer
+			},
+			skipSelf: true
 		});
 	} finally {
-		const remaining = pendingEntryLookups.get(lookupKey) - 1;
-		if (remaining) pendingEntryLookups.set(lookupKey, remaining);
-		else pendingEntryLookups.delete(lookupKey);
+		decrement(pendingEntryLookups, lookupKey);
+		decrement(pendingLookupImporters, importer);
 	}
 }
 /** Identify shared entries through Vite, with a cache scoped to this federation instance. */
 function createSharedSourceResolver(shared, getResolutionConfig) {
 	const caches = /* @__PURE__ */ new Map();
-	async function matchEntry(source, suffix, resolveEntry) {
+	const wildcardSubpathCaches = /* @__PURE__ */ new Map();
+	async function resolveEntry(context, request, options, { root, conditions }) {
+		if (!path$1.isAbsolute(request) && !isPackageExportAvailable(request, {
+			cwd: root,
+			conditions
+		})) return void 0;
+		const importer = path$1.join(root, "package.json");
+		try {
+			const resolved = await resolveInternally(context, request, importer, options);
+			return resolved && !resolved.external ? resolved.id : void 0;
+		} catch {
+			return;
+		}
+	}
+	async function matchEntry(source, suffix, entryOptions, resolveEntry) {
 		const packageName = getPackageNameFromNodeModulePath(source);
 		if (!packageName) return;
 		const candidates = /* @__PURE__ */ new Set();
 		if (findSharedKey(packageName, shared)) candidates.add(packageName);
-		if (findSharedKey(suffix, shared)) candidates.add(suffix);
+		const packageSubpath = suffix.slice(packageName.length + 1);
+		if (packageSubpath) {
+			for (const specifier of getPackageExportSpecifiersForFile(packageName, packageSubpath, {
+				...entryOptions,
+				fromResolvedEntry: source
+			})) if (findSharedKey(specifier, shared)) candidates.add(specifier);
+		}
 		for (const key of Object.keys(shared)) {
 			const request = getSharedRequest(key, shared[key]);
 			if (getPackageName(request) !== packageName) continue;
@@ -8912,6 +9174,7 @@ function createSharedSourceResolver(shared, getResolutionConfig) {
 	return {
 		clear() {
 			caches.clear();
+			wildcardSubpathCaches.clear();
 		},
 		async resolve(context, source, options = {}) {
 			if (source.startsWith("\0") || source.includes("#")) return;
@@ -8922,32 +9185,39 @@ function createSharedSourceResolver(shared, getResolutionConfig) {
 				"t",
 				"import"
 			].includes(key))) return;
-			if (findSharedKey(source, shared)) return source;
-			const suffix = getNodeModulesSuffix(source);
-			if (!suffix) return;
-			const normalizedSource = stripViteFsPrefix(normalizeNodeModulePath(source));
 			const environment = context.environment ?? !!options.ssr;
 			const cacheable = !options.isEntry && !options.scan && (!options.kind || options.kind === "import-statement") && Object.keys(options.attributes ?? {}).length === 0 && Object.keys(options.custom ?? {}).length === 0;
-			let cache = cacheable ? caches.get(environment) : void 0;
-			if (cacheable && !cache) {
-				cache = /* @__PURE__ */ new Map();
-				caches.set(environment, cache);
+			const getCache = (byEnvironment) => {
+				if (!cacheable) return;
+				let cache = byEnvironment.get(environment);
+				if (!cache) {
+					cache = /* @__PURE__ */ new Map();
+					byEnvironment.set(environment, cache);
+				}
+				return cache;
+			};
+			const directKey = findSharedKey(source, shared);
+			if (directKey) {
+				const request = getSharedRequest(directKey, shared[directKey]);
+				if (!(request.endsWith("/") && source !== removeTrailingSlash(request) && !getCommonSharedSubpaths(request).includes(source))) return source;
+				const cache = getCache(wildcardSubpathCaches);
+				let resolvable = cache?.get(source);
+				if (resolvable === void 0) {
+					resolvable = await resolveEntry(context, source, options, getResolutionConfig(context, options)) !== void 0;
+					cache?.set(source, resolvable);
+				}
+				return resolvable ? source : void 0;
 			}
+			const suffix = getNodeModulesSuffix(source);
+			if (!suffix) return;
+			const normalizedSource = stripViteFsPrefix(normalizeNodeModulePath(source));
+			const cache = getCache(caches);
 			if (cache?.has(normalizedSource)) return cache.get(normalizedSource);
-			const { root, conditions } = getResolutionConfig(context, options);
-			const result = await matchEntry(normalizedSource, suffix, async (request) => {
-				if (!path$1.isAbsolute(request) && !isPackageExportAvailable(request, {
-					cwd: root,
-					conditions
-				})) return void 0;
-				const importer = path$1.join(root, "package.json");
-				try {
-					const resolved = await resolveInternally(context, request, importer, options);
-					return resolved && !resolved.external ? resolved.id : void 0;
-				} catch {
-					return;
-				}
-			});
+			const config = getResolutionConfig(context, options);
+			const result = await matchEntry(normalizedSource, suffix, {
+				cwd: config.root,
+				conditions: config.conditions
+			}, (request) => resolveEntry(context, request, options, config));
 			cache?.set(normalizedSource, result);
 			return result;
 		}
@@ -9063,8 +9333,7 @@ function pluginModuleParseEnd_default(excludeFn, options, controller = createMod
 		},
 		async buildStart() {
 			resetParseState(controller);
-			if (idleTimeout) resetIdleTimeout(controller, idleTimeout);
-			else if (options.moduleParseTimeout) setParseTimeout(controller, options.moduleParseTimeout);
+			if (!idleTimeout && options.moduleParseTimeout) setParseTimeout(controller, options.moduleParseTimeout);
 			const entryImports = /* @__PURE__ */ new Set([...options.exposedModuleImports || [], ...configuredInputImports]);
 			for (const importSource of entryImports) {
 				const resolved = await this.resolve(importSource);
@@ -9947,6 +10216,7 @@ function proxySharedModule(options) {
 			},
 			buildStart() {
 				sharedSourceResolver.clear();
+				patchRolldownResolveOptionKeys(this);
 				if (_command !== "build") return;
 				if (hasAnalyzableShares) getBuildImportAnalysis(this.environment).clear();
 				resetTreeShakingExports(federationOptions);
@@ -10347,8 +10617,15 @@ function pluginRemoteNamedExports(options) {
 			if (id.includes("__loadRemote__") || id.includes("__loadShare__")) return;
 			if (!JS_EXTENSIONS_RE.test(id)) return;
 			if (!remoteNames.some((name) => code.includes(name))) return;
-			const matchesRemoteImport = (source) => isRemoteImport(source, id);
-			for (const { kind, source, typeOnly } of findModuleImportDescriptors(code)) if (kind === "static" && !typeOnly && matchesRemoteImport(source)) markStaticRemote(source, options);
+			const descriptors = findModuleImportDescriptors(code);
+			const resolvedElsewhere = /* @__PURE__ */ new Set();
+			for (const source of new Set(descriptors.map((d) => d.source))) {
+				if (source.includes("__loadRemote__") || !isRemoteImport(source, id)) continue;
+				const resolved = await this.resolve(source, id);
+				if (resolved && !resolved.id.includes("__loadRemote__")) resolvedElsewhere.add(source);
+			}
+			const matchesRemoteImport = (source) => !resolvedElsewhere.has(source) && isRemoteImport(source, id);
+			for (const { kind, source, typeOnly } of descriptors) if (kind === "static" && !typeOnly && matchesRemoteImport(source)) markStaticRemote(source, options);
 			let imports;
 			try {
 				imports = await collectFromAST(this.parse(code), code, matchesRemoteImport);
@@ -10806,6 +11083,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 +11707,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\\\"");
 }
@@ -11990,7 +12277,7 @@ function withoutDynamicRemoteTypeHints(options) {
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-CVyHPAEq.js").then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-DShMdjzR.js").then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {
@@ -12100,6 +12387,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 +12634,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 +12669,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;