@module-federation/vite 1.20.1 → 1.20.3

package/lib/index.js

@@ -1,3 +1,5 @@
+import { n as normalizePathForImport, r as rebaseImport } from "./buildPaths-BkaQHrd2.js";
+import { a as getMatchingNodeModuleSubpath, c as isNuxtClientBase, d as resolvePublicPath, i as getCommonSharedSubpaths, l as isViteOptimizableEntry, n as getBasePath$2, o as isAssetLikeImport, r as getCommonSharedSubpathFromNodeModulePath, s as isNodeModulePath, t as filterId, u as normalizeNodeModulePath } from "./pathNormalization-CLDIcf9-.js";
 import { createRequire } from "node:module";
 import * as fs$2 from "fs";
 import fs, { existsSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "fs";
@@ -25,52 +27,6 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
-//#region src/utils/buildPaths.ts
-/**
-* Rebase an import path for a bootstrap file that moved from root into `dir`.
-*
-* When entryFileNames places entries in a subdirectory (e.g. `static/js/`),
-* the bootstrap file moves there too. Paths that resolved from the HTML root
-* must resolve from the new directory instead.
-*
-* Cases: `/static/js/hostInit.js` → `./hostInit.js` (strip dir prefix)
-*        `./src/main.tsx`          → `../../src/main.tsx` (climb back up for each dir level)
-*        `https://cdn.example.com` → unchanged         (absolute URL)
-*/
-function rebaseImport(importSrc, dir) {
-	if (!dir) return importSrc;
-	if (isAbsoluteUrl(importSrc)) return importSrc;
-	const normalizedDir = dir.replace(/^\/+|\/+$/g, "");
-	if (!normalizedDir) return importSrc;
-	const stripDirPrefix = (src, prefix) => {
-		if (src === prefix) return "";
-		if (src.startsWith(prefix + "/")) return src.slice(prefix.length);
-	};
-	const absoluteRemainder = stripDirPrefix(importSrc, "/" + normalizedDir);
-	if (absoluteRemainder !== void 0) {
-		const remainder = absoluteRemainder.replace(/^\/+/, "");
-		return remainder ? "./" + remainder : "./";
-	}
-	const relativeRemainder = stripDirPrefix(importSrc, normalizedDir);
-	if (relativeRemainder !== void 0) {
-		const remainder = relativeRemainder.replace(/^\/+/, "");
-		return remainder ? "./" + remainder : "./";
-	}
-	const upLevels = normalizedDir.split("/").filter(Boolean).length;
-	const prefix = upLevels > 0 ? "../".repeat(upLevels) : "./";
-	if (importSrc.startsWith("./")) return prefix + importSrc.slice(2);
-	if (importSrc.startsWith("/")) return prefix + importSrc.slice(1);
-	return prefix + importSrc;
-}
-function normalizePathForImport(path) {
-	return path.replace(/\\/g, "/");
-}
-const EXTERNAL_URL_RE = /^(?:[a-z]+:|\/\/)/i;
-function isAbsoluteUrl(src) {
-	if (/^[a-z]:[\\/]/i.test(src)) return false;
-	return EXTERNAL_URL_RE.test(src);
-}
-//#endregion
 //#region src/utils/codeRewriter.ts
 const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var CodeRewriter = class {
@@ -851,123 +807,6 @@ function hasPackageDependency(dependencyName, cwd = packageDetectionCwd || proce
 	}
 }
 //#endregion
-//#region src/utils/pathNormalization.ts
-const COMMON_SHARED_SUBPATHS = {
-	react: [
-		"react/jsx-runtime",
-		"react/jsx-dev-runtime",
-		"react/compiler-runtime"
-	],
-	"react-dom": [
-		"react-dom/client",
-		"react-dom/server",
-		"react-dom/server.browser"
-	],
-	"solid-js": [
-		"solid-js/web",
-		"solid-js/store",
-		"solid-js/html",
-		"solid-js/h"
-	],
-	zustand: ["zustand/vanilla", "zustand/react"]
-};
-const VITE_DEFAULT_ASSET_TYPES = [
-	"apng",
-	"bmp",
-	"png",
-	"jpe?g",
-	"jfif",
-	"pjpeg",
-	"pjp",
-	"gif",
-	"svg",
-	"ico",
-	"webp",
-	"avif",
-	"cur",
-	"jxl",
-	"mp4",
-	"webm",
-	"ogg",
-	"mp3",
-	"wav",
-	"flac",
-	"aac",
-	"opus",
-	"mov",
-	"m4a",
-	"vtt",
-	"woff2?",
-	"eot",
-	"ttf",
-	"otf",
-	"webmanifest",
-	"pdf",
-	"txt"
-];
-const ASSET_LIKE_IMPORT_RE = new RegExp(`\\.(${[...[
-	"css",
-	"scss",
-	"sass",
-	"less",
-	"styl",
-	"stylus"
-], ...VITE_DEFAULT_ASSET_TYPES].join("|")})(?:[?#].*)?$`, "i");
-function isAssetLikeImport(source) {
-	return ASSET_LIKE_IMPORT_RE.test(source);
-}
-const VITE_OPTIMIZABLE_ENTRY_RE = /\.[cm]?[jt]s$/;
-function isViteOptimizableEntry(resolvedPath) {
-	return VITE_OPTIMIZABLE_ENTRY_RE.test(resolvedPath);
-}
-function removeTrailingSlash(value) {
-	return value.endsWith("/") ? value.slice(0, -1) : value;
-}
-function ensureTrailingSlash(value) {
-	return `${removeTrailingSlash(value)}/`;
-}
-function getBasePath$2(base) {
-	return removeTrailingSlash(base || "/");
-}
-function isNuxtClientBase(base) {
-	return getBasePath$2(base).endsWith("/_nuxt");
-}
-function normalizeNodeModulePath(source) {
-	return source.replace(/\\/g, "/").replace(/\?.*$/, "");
-}
-function isNodeModulePath(source) {
-	return source.includes("/node_modules/") || source.includes("\\node_modules\\");
-}
-function filterId(id) {
-	return typeof id === "string" && !id.includes("\0");
-}
-function getMatchingNodeModuleSubpath(source, candidates) {
-	const normalized = normalizeNodeModulePath(source);
-	return [...candidates].sort((a, b) => b.length - a.length).find((candidate) => normalized.includes(`/node_modules/${candidate}/`) || normalized.includes(`/node_modules/${candidate}.`));
-}
-function getCommonSharedSubpaths(sharedKey) {
-	return COMMON_SHARED_SUBPATHS[removeTrailingSlash(sharedKey)] || [];
-}
-function getCommonSharedSubpathFromNodeModulePath(source, sharedKey) {
-	return getMatchingNodeModuleSubpath(source, getCommonSharedSubpaths(removeTrailingSlash(sharedKey)));
-}
-/**
-* Resolves the public path for remote entries
-* @param options - Module Federation options
-* @param viteBase - Vite's base config value
-* @param originalBase - Original base config before any transformations
-* @returns The resolved public path
-*/
-function resolvePublicPath(options, viteBase, originalBase) {
-	if (options.publicPath && options.publicPath !== "auto") return options.publicPath;
-	if (!originalBase) return "auto";
-	if (viteBase) {
-		if (viteBase === "./") return "auto";
-		return ensureTrailingSlash(viteBase);
-	}
-	return "auto";
-}
-//#endregion
 //#region src/utils/normalizeModuleFederationOptions.ts
 const INTERNAL_NAME_PREFIX = "__mfe_internal__";
 function toInternalModuleFederationName(name) {
@@ -1914,6 +1753,9 @@ ${exportStatement}
 }
 //#endregion
 //#region src/utils/treeShaking.ts
+function shouldAnalyzeSharedExports(shareItem) {
+	return !!(shareItem && (shareItem.shareConfig.treeShaking || shareItem.shareConfig.import === false));
+}
 const legacyTreeShakingState = {
 	inferredUsage: /* @__PURE__ */ new Map(),
 	buildMode: false
@@ -1987,12 +1829,12 @@ function getExportRecords(sharedKey, request, options) {
 * fallback lookup across keys keeps aliases/backwards-compatible callers
 * working, while still keeping each concrete request's exports isolated.
 */
-function getTreeShakingExportUsage(request, shareItem, sharedKey, options) {
+function getSharedExportUsage(request, shareItem, sharedKey, options) {
 	const treeShaking = shareItem?.shareConfig.treeShaking;
-	if (!treeShaking || !getTreeShakingState(options).buildMode) return void 0;
+	if (!shouldAnalyzeSharedExports(shareItem) || !getTreeShakingState(options).buildMode) return;
 	const records = getExportRecords(sharedKey, request, options);
 	if (records.some((record) => record.requiresFullBundle)) return { kind: "full" };
-	const configured = treeShaking.usedExports ?? [];
+	const configured = treeShaking?.usedExports ?? [];
 	const result = new Set(configured);
 	records.forEach((record) => record.usedExports.forEach((name) => result.add(name)));
 	if (result.size > 0) return {
@@ -2004,6 +1846,10 @@ function getTreeShakingExportUsage(request, shareItem, sharedKey, options) {
 		usedExports: []
 	} : { kind: "unknown" };
 }
+function getTreeShakingExportUsage(request, shareItem, sharedKey, options) {
+	if (!shareItem?.shareConfig.treeShaking) return void 0;
+	return getSharedExportUsage(request, shareItem, sharedKey, options);
+}
 function getModuleSource(node) {
 	if (!node || typeof node !== "object") return void 0;
 	const source = node;
@@ -2118,8 +1964,8 @@ function collectReExport(node, source, record, markUnsafe) {
 *
 * Parsing the module avoids treating import-looking text in comments, strings,
 * templates, or regular expressions as real dependencies. If parsing fails,
-* every configured tree-shaken share is conservatively marked as requiring its
-* full bundle instead of guessing from source text.
+* every configured share whose exports are analyzed is conservatively marked
+* as requiring its full export surface instead of guessing from source text.
 *
 * Generated federation wrappers are excluded because their imports describe
 * the wrapper implementation, not the consumer's requirements.
@@ -2132,13 +1978,13 @@ function collectTreeShakingImports(code, id, shared, findSharedKey, record, mark
 		ast = parseAst(code);
 	} catch {
 		Object.entries(shared).forEach(([sharedKey, shareItem]) => {
-			if (shareItem.shareConfig.treeShaking) markUnsafe(sharedKey, "*");
+			if (shouldAnalyzeSharedExports(shareItem)) markUnsafe(sharedKey, "*");
 		});
 		return;
 	}
 	const matchShared = (source) => {
 		const sharedKey = findSharedKey(source, shared);
-		return sharedKey && shared[sharedKey]?.shareConfig.treeShaking ? sharedKey : void 0;
+		return sharedKey && shouldAnalyzeSharedExports(shared[sharedKey]) ? sharedKey : void 0;
 	};
 	const recordSource = (names, source) => {
 		const sharedKey = matchShared(source);
@@ -2468,32 +2314,55 @@ function resolveReExportModule(filePath, specifier, exportConditions) {
 		return;
 	}
 }
-function hasTopLevelDeclaratorComma(source, start, codePositions) {
+/** Marks a template-literal frame whose text (not its interpolation) is being scanned. */
+const TEMPLATE_TEXT = Symbol("templateText");
+function getAdditionalTopLevelDeclaratorNames(source, start, codePositions) {
+	const names = [];
 	let depth = 0;
 	let quote;
 	let escaped = false;
 	let canStartRegex = true;
+	const templateFrames = [];
+	const inTemplateText = () => templateFrames[templateFrames.length - 1] === TEMPLATE_TEXT;
 	for (let index = start; index < source.length; index++) {
 		const char = source[index];
+		if (inTemplateText()) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === "$" && source[index + 1] === "{") {
+				templateFrames.push(depth);
+				index++;
+				canStartRegex = true;
+			} else if (char === "`") {
+				templateFrames.pop();
+				canStartRegex = false;
+			}
+			continue;
+		}
 		if (quote) {
 			if (escaped) escaped = false;
 			else if (char === "\\") escaped = true;
 			else if (char === quote) quote = void 0;
 			continue;
 		}
-		if (char === "\"" || char === "'" || char === "`") {
+		if (char === "`") {
+			templateFrames.push(TEMPLATE_TEXT);
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
 			quote = char;
 			canStartRegex = false;
 			continue;
 		}
 		if (char === "/" && source[index + 1] === "/") {
 			index = source.indexOf("\n", index + 2);
-			if (index === -1) return false;
+			if (index === -1) return names;
 			continue;
 		}
 		if (char === "/" && source[index + 1] === "*") {
 			const commentEnd = source.indexOf("*/", index + 2);
-			if (commentEnd === -1) return true;
+			if (commentEnd === -1) return void 0;
 			index = commentEnd + 1;
 			continue;
 		}
@@ -2524,9 +2393,9 @@ function hasTopLevelDeclaratorComma(source, start, codePositions) {
 					while (/[$_\p{ID_Continue}]/u.test(source[index + 1] || "")) index++;
 					break;
 				}
-				if (regexChar === "\n" || regexChar === "\r") return true;
+				if (regexChar === "\n" || regexChar === "\r") return void 0;
 			}
-			if (!closed) return true;
+			if (!closed) return void 0;
 			canStartRegex = false;
 			continue;
 		}
@@ -2565,15 +2434,29 @@ function hasTopLevelDeclaratorComma(source, start, codePositions) {
 			continue;
 		}
 		if (char === ")" || char === "]" || char === "}") {
+			if (char === "}" && templateFrames.length > 0 && templateFrames[templateFrames.length - 1] === depth) {
+				templateFrames.pop();
+				canStartRegex = false;
+				continue;
+			}
 			depth = Math.max(0, depth - 1);
 			canStartRegex = false;
 			continue;
 		}
-		if (depth === 0 && char === ",") return true;
-		if (depth === 0 && char === ";") return false;
+		if (templateFrames.length === 0 && depth === 0 && char === ",") {
+			let bindingStart = index + 1;
+			while (/\s/.test(source[bindingStart] || "")) bindingStart++;
+			const binding = source.slice(bindingStart).match(new RegExp(`^(${JS_IDENTIFIER_PATTERN})`, "u"));
+			if (!binding || !isValidEsmExportName(binding[1])) return void 0;
+			names.push(binding[1]);
+			index = bindingStart + binding[1].length - 1;
+			canStartRegex = false;
+			continue;
+		}
+		if (templateFrames.length === 0 && depth === 0 && char === ";") return names;
 		if (!/\s/.test(char)) canStartRegex = char !== ".";
 	}
-	return false;
+	return names;
 }
 function hasUnsupportedBindingPattern(source, start) {
 	const opening = source[start];
@@ -2616,7 +2499,9 @@ function getNamedExportsViaRegex(source, filePath, visited, scanState = { comple
 	const exportedVariableDeclarationRegex = /export\s+(?:const|let|var)\s+/g;
 	while ((match = exportedVariableDeclarationRegex.exec(source)) !== null) {
 		if (!codePositions[match.index]) continue;
-		if (hasTopLevelDeclaratorComma(source, exportedVariableDeclarationRegex.lastIndex, codePositions)) scanState.complete = false;
+		const additionalNames = getAdditionalTopLevelDeclaratorNames(source, exportedVariableDeclarationRegex.lastIndex, codePositions);
+		if (additionalNames === void 0) scanState.complete = false;
+		else for (const name of additionalNames) names.add(name);
 		if (hasUnsupportedBindingPattern(source, exportedVariableDeclarationRegex.lastIndex)) scanState.complete = false;
 	}
 	if (hasCodeMatch(source, /export\s+import\s+/g, codePositions) || hasCodeMatch(source, /export\s*=/g, codePositions)) scanState.complete = false;
@@ -2709,7 +2594,22 @@ function getNamedExportsViaRegex(source, filePath, visited, scanState = { comple
 	}
 	return Array.from(names);
 }
+/**
+* Reading a module's export names runs its top-level code inside the build
+* process, and getPackageNamedExports deliberately resolves the browser entry.
+* A browser entry may open a handle Node never closes — react-dom/server.browser
+* holds a module-scope MessageChannel — and one ref'd handle keeps the event loop
+* alive forever, so `vite build` writes a correct bundle and then never exits.
+*
+* Unref'ing whatever the require created is safe here because the module is
+* loaded purely to read Object.keys off it and is never used afterwards. The
+* handle list is undocumented, so its absence degrades to the previous behaviour
+* rather than failing the build. Side effects that are not handles (an exit
+* listener, a global mutation) are still not contained.
+*/
 function getRequiredNamedExports(specifier) {
+	const getActiveHandles = process._getActiveHandles;
+	const handlesBeforeRequire = typeof getActiveHandles === "function" ? new Set(getActiveHandles.call(process)) : void 0;
 	try {
 		const mod = createRequire$1(pathToFileURL(path$1.join(getPackageDetectionCwd(), "package.json")))(specifier);
 		const runtimeNamedKeys = Object.keys(mod).filter((key) => key !== "default" && key !== "__esModule");
@@ -2717,6 +2617,12 @@ function getRequiredNamedExports(specifier) {
 		return runtimeNamedKeys;
 	} catch {
 		return;
+	} finally {
+		if (handlesBeforeRequire && typeof getActiveHandles === "function") for (const handle of getActiveHandles.call(process)) {
+			if (handlesBeforeRequire.has(handle)) continue;
+			const unref = handle?.unref;
+			if (typeof unref === "function") unref.call(handle);
+		}
 	}
 }
 function getPackageNamedExports(pkg, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
@@ -3272,6 +3178,12 @@ function generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor,
     }
     export { __mf_default as default };${namedExportLine}`;
 }
+function selectImportFalseNamedExports(detectedNamedExports, usage) {
+	if (!detectedNamedExports || usage?.kind !== "exports") return detectedNamedExports ?? [];
+	const usedNamedExports = new Set(usage.usedExports.filter((name) => name !== "default"));
+	if ([...usedNamedExports].some((name) => !detectedNamedExports.includes(name))) return detectedNamedExports;
+	return detectedNamedExports.filter((name) => usedNamedExports.has(name));
+}
 function generateShareModuleUnwrapCode({ source, preserveNamedExports, stopWithReturn }) {
 	return `let current = ${source};
       for (let i = 0; i < 5; i++) {
@@ -3294,7 +3206,7 @@ const normalizeLocalShareModuleCode = `const __mfNormalizeShareModule = (mod) =>
         ? Object.assign({}, normalized)
         : normalized;
     };`;
-function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exportConditions) {
+function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exportConditions, importFalseExportUsage) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const { loadShareCacheMap } = getSharedVirtualModuleState(options);
 	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = createScopedSharedVirtualModule(pkg, LOAD_SHARE_TAG, options);
@@ -3305,7 +3217,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	const treeShakingConsumer = command === "build" && shareItem.shareConfig.treeShaking ? resolvedOptions.name : void 0;
 	if (shareItem.shareConfig.import === false) {
 		const detectedNamedExports = getPackageNamedExports(pkg, exportConditions);
-		const namedExports = detectedNamedExports ?? [];
+		const namedExports = selectImportFalseNamedExports(detectedNamedExports, importFalseExportUsage);
 		let exportLine;
 		if (namedExports.length > 0) exportLine = generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor, treeShakingConsumer);
 		else {
@@ -3592,7 +3504,7 @@ function generateLocalSharedImportMap(options) {
 		if (!remote) return null;
 		return `
                 {
-                  alias: ${JSON.stringify(getRuntimeRemoteAlias(key, options))},
+                  alias: ${JSON.stringify(key)},
                   entryGlobalName: ${JSON.stringify(remote.entryGlobalName)},
                   name: ${JSON.stringify(options ? getRuntimeRemoteAlias(key, options) : remote.name)},
                   type: ${JSON.stringify(remote.type)},
@@ -4158,7 +4070,6 @@ function generateTreeShakingSnapshotPluginCode(enabled) {
 function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(options), command = "build") {
 	const needsSharedProviderSelectionHelper = Object.keys(options.shared ?? {}).length > 0;
 	const hasTreeShakingShared = Object.values(options.shared ?? {}).some((share) => !!share?.shareConfig.treeShaking);
-	const hasEagerShared = Object.values(options.shared ?? {}).some((share) => share?.shareConfig.eager === true && share.shareConfig.import !== false);
 	const hasMultipleShareScopes = Array.isArray(options.shareScope);
 	const runtimeImports = [
 		"init as runtimeInit",
@@ -4211,7 +4122,6 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
     globalThis.__VUE_HMR_RUNTIME__ = { createRecord() {}, rerender() {}, reload() {} };
   }
   import {${runtimeImports}} from "@module-federation/runtime";
-  ${hasEagerShared ? `import * as __mfLocalSharedImportMap from "${getLocalSharedImportMapPath(options)}";` : ""}
   ${runtimeHelperImports.length ? `import {${runtimeHelperImports.join(", ")}} from "@module-federation/runtime/helpers";` : ""}
   ${pluginImportNames.filter((item) => !isSsrOnlyPlugin(item[1])).map((item) => item[1]).join("\n")}
   ${command === "build" ? getRuntimeInitResolveBootstrapCode(false, options ? getRuntimeInitStatusImportId(options) : void 0) : getRuntimeInitBootstrapCode(false, options ? getRuntimeInitStatusImportId(options) : void 0) + "\n  const { initResolve } = globalThis[globalKey];"}
@@ -4246,12 +4156,11 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   ${needsSharedProviderSelectionHelper ? externalSharedProviderSelectionHelperCode : ""}
 
   async function getLocalSharedImportMap() {
-    ${hasEagerShared ? "return __mfLocalSharedImportMap;" : ""}
-    ${hasEagerShared ? "" : `if (!localSharedImportMapPromise) {
+    if (!localSharedImportMapPromise) {
       localSharedImportMapPromise = retrySharedInit(() => import("${getLocalSharedImportMapPath(options)}"))
         .catch((e) => { localSharedImportMapPromise = undefined; throw e; });
     }
-    return localSharedImportMapPromise`}
+    return localSharedImportMapPromise
   }
 
   async function getExposesMap() {
@@ -5074,6 +4983,8 @@ function getRemoteVirtualModule(remote, command, enableSsrInit = false, consumer
 }
 const usedRemotesMap = {};
 const usedRemotesByOptions = /* @__PURE__ */ new WeakMap();
+const dynamicRemotesByOptions = /* @__PURE__ */ new WeakMap();
+const staticRemotesByOptions = /* @__PURE__ */ new WeakMap();
 function getScopedUsedRemotesMap(options) {
 	let scoped = usedRemotesByOptions.get(options);
 	if (!scoped) {
@@ -5094,6 +5005,25 @@ function getUsedRemotesMap(options) {
 	if (options) return getScopedUsedRemotesMap(options);
 	return usedRemotesMap;
 }
+function markDynamicRemote(remote, options) {
+	let remotes = dynamicRemotesByOptions.get(options);
+	if (!remotes) {
+		remotes = /* @__PURE__ */ new Set();
+		dynamicRemotesByOptions.set(options, remotes);
+	}
+	remotes.add(remote);
+}
+function markStaticRemote(remote, options) {
+	let remotes = staticRemotesByOptions.get(options);
+	if (!remotes) {
+		remotes = /* @__PURE__ */ new Set();
+		staticRemotesByOptions.set(options, remotes);
+	}
+	remotes.add(remote);
+}
+function isDynamicOnlyRemote(remote, options) {
+	return (dynamicRemotesByOptions.get(options)?.has(remote) ?? false) && !(staticRemotesByOptions.get(options)?.has(remote) ?? false);
+}
 function getRemoteAliasFromId(id, remotes) {
 	return Object.keys(remotes).filter((name) => id === name || id.startsWith(name + "/")).sort((a, b) => b.length - a.length)[0];
 }
@@ -5278,7 +5208,7 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
 	const registerRemoteCode = isLoadedFirst && remote ? `runtime.registerRemotes([${JSON.stringify({
 		entryGlobalName: remote.entryGlobalName,
 		name: options ? runtimeRemoteAlias : remote.name,
-		alias: runtimeRemoteAlias,
+		alias: remoteAlias,
 		type: remote.type,
 		entry: remote.entry,
 		shareScope: remote.shareScope ?? "default"
@@ -5516,7 +5446,7 @@ const __mfCurrentScript = document.currentScript;
 		const entryImportDeclaration = isEncodedVirtualEntry ? `const __mfEntryUrl = ${JSON.stringify(entrySrc)};
 ` : "";
 		const entryImportExpression = isEncodedVirtualEntry ? "import(/* @vite-ignore */ __mfEntryUrl)" : importExpression(entrySrc);
-		const remotePreloads = !options?.skipRemotePreload && (federationOptions ?? getNormalizeModuleFederationOptions())?.shareStrategy !== "loaded-first" ? Object.entries(getUsedRemotesMap(federationOptions)).flatMap(([, remotes]) => Array.from(remotes)).sort().map((remote) => `__mfPreloadRemote(${JSON.stringify(getRuntimeRemoteId(remote, (federationOptions ?? getNormalizeModuleFederationOptions()).remotes, federationOptions))}, ${JSON.stringify(remote)})`).join(",") : "";
+		const remotePreloads = !options?.skipRemotePreload && (federationOptions ?? getNormalizeModuleFederationOptions())?.shareStrategy !== "loaded-first" ? Object.entries(getUsedRemotesMap(federationOptions)).flatMap(([, remotes]) => Array.from(remotes)).filter((remote) => !federationOptions || !isDynamicOnlyRemote(remote, federationOptions)).sort().map((remote) => `__mfPreloadRemote(${JSON.stringify(getRuntimeRemoteId(remote, (federationOptions ?? getNormalizeModuleFederationOptions()).remotes, federationOptions))}, ${JSON.stringify(remote)})`).join(",") : "";
 		const remoteCachePrefix = getRuntimeRemoteCachePrefix(federationOptions);
 		const preloadBlock = remotePreloads ? `
   const runtime = await initHost();
@@ -7771,116 +7701,174 @@ function getStatsFileName(manifestFileName) {
 }
 //#endregion
 //#region src/plugins/pluginModuleParseEnd.ts
-let _resolve = null;
-let _parseTimeout = null;
-let _settleTimeout = null;
-let parsePromise = Promise.resolve(1);
-let parseStartSet = /* @__PURE__ */ new Set();
-let parseEndSet = /* @__PURE__ */ new Set();
-let lastLoadedModule = "";
-let lastParsedModule = "";
-function clearParseTimeout() {
-	if (_parseTimeout) {
-		clearTimeout(_parseTimeout);
-		_parseTimeout = null;
-	}
-}
-function clearSettleTimeout() {
-	if (_settleTimeout) {
-		clearTimeout(_settleTimeout);
-		_settleTimeout = null;
-	}
-}
-function resetParseState() {
-	clearParseTimeout();
-	clearSettleTimeout();
-	parseStartSet = /* @__PURE__ */ new Set();
-	parseEndSet = /* @__PURE__ */ new Set();
-	lastLoadedModule = "";
-	lastParsedModule = "";
-	parsePromise = new Promise((resolve) => {
-		_resolve = (v) => {
-			clearParseTimeout();
-			clearSettleTimeout();
-			resolve(v);
+function createModuleParseController() {
+	return {
+		resolve: null,
+		parseTimeout: null,
+		settleTimeout: null,
+		parsePromise: Promise.resolve({
+			complete: false,
+			reason: "initial"
+		}),
+		parseStartSet: /* @__PURE__ */ new Set(),
+		parseEndSet: /* @__PURE__ */ new Set(),
+		discardWarned: false,
+		externalSet: /* @__PURE__ */ new Set(),
+		resolutionProbed: /* @__PURE__ */ new Set(),
+		lastLoadedModule: "",
+		lastParsedModule: ""
+	};
+}
+function clearParseTimeout(controller) {
+	if (controller.parseTimeout) {
+		clearTimeout(controller.parseTimeout);
+		controller.parseTimeout = null;
+	}
+}
+function clearSettleTimeout(controller) {
+	if (controller.settleTimeout) {
+		clearTimeout(controller.settleTimeout);
+		controller.settleTimeout = null;
+	}
+}
+function resetParseState(controller) {
+	clearParseTimeout(controller);
+	clearSettleTimeout(controller);
+	controller.parseStartSet = /* @__PURE__ */ new Set();
+	controller.parseEndSet = /* @__PURE__ */ new Set();
+	controller.externalSet = /* @__PURE__ */ new Set();
+	controller.resolutionProbed = /* @__PURE__ */ new Set();
+	controller.discardWarned = false;
+	controller.lastLoadedModule = "";
+	controller.lastParsedModule = "";
+	controller.parsePromise = new Promise((resolve) => {
+		controller.resolve = (result) => {
+			clearParseTimeout(controller);
+			clearSettleTimeout(controller);
+			resolve(result);
 		};
 	});
 }
-function setParseTimeout(timeout) {
-	if (!_parseTimeout) _parseTimeout = setTimeout(() => {
+function setParseTimeout(controller, timeout) {
+	if (!controller.parseTimeout) controller.parseTimeout = setTimeout(() => {
 		mfWarn(`Parse timeout (${timeout}s) - forcing resolve`);
-		_resolve?.(1);
+		controller.resolve?.({
+			complete: false,
+			reason: "timeout"
+		});
 	}, timeout * 1e3);
 }
-function resetIdleTimeout(timeout) {
-	clearParseTimeout();
-	_parseTimeout = setTimeout(() => {
-		const pendingModules = Array.from(parseStartSet).filter((moduleId) => !parseEndSet.has(moduleId));
-		mfWarn(`moduleParseIdleTimeout: no module activity for ${timeout}s, forcing resolve. Some shared/remote dependencies may be missing. Consider increasing moduleParseIdleTimeout. Tracked modules: ${parseEndSet.size}/${parseStartSet.size}.` + (lastLoadedModule ? ` Last loaded: ${lastLoadedModule}.` : "") + (lastParsedModule ? ` Last parsed: ${lastParsedModule}.` : "") + (pendingModules.length ? ` Pending modules: ${pendingModules.slice(0, 10).join(", ")}` : ""));
-		_resolve?.(1);
+function resetIdleTimeout(controller, timeout) {
+	clearParseTimeout(controller);
+	controller.parseTimeout = setTimeout(() => {
+		const pendingModules = Array.from(controller.parseStartSet).filter((moduleId) => !controller.parseEndSet.has(moduleId));
+		mfWarn(`moduleParseIdleTimeout: no module activity for ${timeout}s, forcing resolve. Some shared/remote dependencies may be missing. Consider increasing moduleParseIdleTimeout. Tracked modules: ${controller.parseEndSet.size}/${controller.parseStartSet.size}.` + (controller.lastLoadedModule ? ` Last loaded: ${controller.lastLoadedModule}.` : "") + (controller.lastParsedModule ? ` Last parsed: ${controller.lastParsedModule}.` : "") + (pendingModules.length ? ` Pending modules: ${pendingModules.slice(0, 10).join(", ")}` : ""));
+		controller.resolve?.({
+			complete: false,
+			reason: "idle-timeout"
+		});
 	}, timeout * 1e3);
 }
-function scheduleParseCompletionCheck() {
-	clearSettleTimeout();
-	_settleTimeout = setTimeout(() => {
-		_settleTimeout = null;
-		if (parseStartSet.size > 0 && Array.from(parseStartSet).every((moduleId) => parseEndSet.has(moduleId))) _resolve?.(1);
+function scheduleParseCompletionCheck(controller) {
+	clearSettleTimeout(controller);
+	controller.settleTimeout = setTimeout(() => {
+		controller.settleTimeout = null;
+		if (controller.parseStartSet.size > 0 && Array.from(controller.parseStartSet).every((moduleId) => controller.parseEndSet.has(moduleId))) controller.resolve?.({
+			complete: true,
+			reason: "graph-complete"
+		});
 	}, 10);
 }
-function pluginModuleParseEnd_default(excludeFn, options) {
+function matchesExternal(external, id, importer) {
+	if (!external) return false;
+	if (typeof external === "function") return external(id, importer, true) === true;
+	return (Array.isArray(external) ? external : [external]).some((entry) => {
+		if (typeof entry === "string") return entry === id;
+		entry.lastIndex = 0;
+		return entry.test(id);
+	});
+}
+function getConfiguredInputImports(input) {
+	if (typeof input === "string") return [input];
+	if (Array.isArray(input)) return input.filter((entry) => typeof entry === "string");
+	if (!input || typeof input !== "object") return [];
+	return Object.values(input).filter((entry) => typeof entry === "string");
+}
+function pluginModuleParseEnd_default(excludeFn, options, controller = createModuleParseController()) {
 	const idleTimeout = options.moduleParseIdleTimeout ?? options.moduleParseTimeout;
-	return [
-		{
-			name: "_",
-			apply: "serve",
-			config() {
-				_resolve?.(1);
+	let configuredInputImports = [];
+	let configuredExternal;
+	return [{
+		enforce: "pre",
+		name: "parseStart",
+		apply: "build",
+		configResolved(config) {
+			const buildOptions = config.build;
+			configuredInputImports = getConfiguredInputImports(buildOptions.rollupOptions.input ?? buildOptions.rolldownOptions?.input);
+			configuredExternal = buildOptions.rollupOptions.external ?? buildOptions.rolldownOptions?.external;
+		},
+		async buildStart() {
+			resetParseState(controller);
+			if (idleTimeout) resetIdleTimeout(controller, idleTimeout);
+			else if (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);
+				if (resolved && !resolved.external && !excludeFn(resolved.id)) controller.parseStartSet.add(resolved.id);
 			}
 		},
-		{
-			enforce: "pre",
-			name: "parseStart",
-			apply: "build",
-			async buildStart() {
-				resetParseState();
-				if (idleTimeout) resetIdleTimeout(idleTimeout);
-				else if (options.moduleParseTimeout) setParseTimeout(options.moduleParseTimeout);
-				for (const importSource of options.exposedModuleImports || []) {
-					const resolved = await this.resolve(importSource);
-					if (resolved && !resolved.external && !excludeFn(resolved.id)) parseStartSet.add(resolved.id);
+		load(id) {
+			controller.lastLoadedModule = id;
+			if (excludeFn(id)) return;
+			clearSettleTimeout(controller);
+			if (idleTimeout) resetIdleTimeout(controller, idleTimeout);
+			controller.parseStartSet.add(id);
+		}
+	}, {
+		enforce: "post",
+		name: "parseEnd",
+		apply: "build",
+		moduleParsed(module) {
+			clearSettleTimeout(controller);
+			const id = module.id;
+			controller.lastParsedModule = id;
+			if (idleTimeout) resetIdleTimeout(controller, idleTimeout);
+			const parsedModule = module;
+			const addPendingResolutions = (resolutions) => {
+				for (const resolution of resolutions || []) if (!resolution.external && !excludeFn(resolution.id)) controller.parseStartSet.add(resolution.id);
+			};
+			const probeExternal = (pendingId) => {
+				if (typeof this.resolve !== "function") return;
+				if (controller.resolutionProbed.has(pendingId)) return;
+				controller.resolutionProbed.add(pendingId);
+				this.resolve(pendingId, id, { skipSelf: true }).then((resolved) => {
+					if (!resolved?.external) return;
+					controller.externalSet.add(pendingId);
+					controller.parseStartSet.delete(pendingId);
+					scheduleParseCompletionCheck(controller);
+				}).catch(() => {});
+			};
+			const addPendingIds = (ids) => {
+				for (const pendingId of ids || []) {
+					if (!this.getModuleInfo(pendingId) || controller.externalSet.has(pendingId) || matchesExternal(configuredExternal, pendingId, id) || excludeFn(pendingId)) continue;
+					controller.parseStartSet.add(pendingId);
+					if (!controller.parseEndSet.has(pendingId)) probeExternal(pendingId);
 				}
-			},
-			load(id) {
-				lastLoadedModule = id;
-				if (excludeFn(id)) return;
-				clearSettleTimeout();
-				if (idleTimeout) resetIdleTimeout(idleTimeout);
-				parseStartSet.add(id);
-			}
+			};
+			addPendingResolutions(parsedModule.importedIdResolutions);
+			addPendingResolutions(parsedModule.dynamicallyImportedIdResolutions);
+			if (parsedModule.importedIdResolutions === void 0) addPendingIds(module.importedIds);
+			if (parsedModule.dynamicallyImportedIdResolutions === void 0) addPendingIds(module.dynamicallyImportedIds);
+			if (!excludeFn(id)) controller.parseEndSet.add(id);
+			scheduleParseCompletionCheck(controller);
 		},
-		{
-			enforce: "post",
-			name: "parseEnd",
-			apply: "build",
-			moduleParsed(module) {
-				clearSettleTimeout();
-				const id = module.id;
-				lastParsedModule = id;
-				if (idleTimeout) resetIdleTimeout(idleTimeout);
-				const parsedModule = module;
-				const addPendingResolutions = (resolutions) => {
-					for (const resolution of resolutions || []) if (!resolution.external && !excludeFn(resolution.id)) parseStartSet.add(resolution.id);
-				};
-				addPendingResolutions(parsedModule.importedIdResolutions);
-				addPendingResolutions(parsedModule.dynamicallyImportedIdResolutions);
-				if (!excludeFn(id)) parseEndSet.add(id);
-				scheduleParseCompletionCheck();
-			},
-			buildEnd() {
-				_resolve?.(1);
-			}
+		buildEnd() {
+			controller.resolve?.({
+				complete: false,
+				reason: "build-end"
+			});
 		}
-	];
+	}];
 }
 //#endregion
 //#region src/plugins/pluginProxyRemoteEntry.ts
@@ -7890,7 +7878,7 @@ function resolveDevHashEntryFileName(fileName) {
 	const baseName = path$1.basename(normalized);
 	return path$1.extname(baseName) ? normalized : `${normalized}.js`;
 }
-function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposesId }) {
+function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposesId, getParsePromise = () => Promise.resolve() }) {
 	let viteConfig, _command, root, originalConfigBase;
 	let exposeRemoteDependencies = {};
 	let exposeRemoteDependenciesDirty = true;
@@ -8000,7 +7988,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 			}
 		},
 		async load(id) {
-			if (id === remoteEntryId) return parsePromise.then((_) => generateRemoteEntry(options, virtualExposesId, _command));
+			if (id === remoteEntryId) return getParsePromise().then((_) => generateRemoteEntry(options, virtualExposesId, _command));
 			if (id === virtualExposesId) {
 				await refreshExposeRemoteDependencies(this);
 				return generateExposes(options, exposeRemoteDependencies, _command, reactIslandExposes);
@@ -8010,7 +7998,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		async transform(code, id) {
 			return mapCodeToCodeWithSourcemap(await (async () => {
 				if (!filterId(id)) return;
-				if (id.includes(remoteEntryId)) return parsePromise.then((_) => generateRemoteEntry(options, virtualExposesId, _command));
+				if (id.includes(remoteEntryId)) return getParsePromise().then((_) => generateRemoteEntry(options, virtualExposesId, _command));
 				if (id === virtualExposesId) {
 					await refreshExposeRemoteDependencies(this);
 					return generateExposes(options, exposeRemoteDependencies, _command, reactIslandExposes);
@@ -8167,6 +8155,41 @@ function pluginProxyRemotes_default(options) {
 	};
 }
 //#endregion
+//#region src/plugins/pluginReactMixedModeGuard.ts
+const REACT_DEVELOPMENT_RUNTIME = /[\\/]react[\\/]cjs[\\/]react(?:-jsx-(?:dev-)?runtime)?\.development\.js$/;
+const UNSAFE_GET_OWNER = "return null === dispatcher ? null : dispatcher.getOwner();";
+const SAFE_GET_OWNER = "return typeof dispatcher?.getOwner === \"function\" ? dispatcher.getOwner() : null;";
+const REACT_MIXED_MODE_ROLLDOWN_PLUGIN = "module-federation:react-mixed-mode-rolldown";
+const REACT_MIXED_MODE_ESBUILD_PLUGIN = "module-federation:react-mixed-mode-esbuild";
+function patchReactDevelopmentRuntime(code, id) {
+	if (!REACT_DEVELOPMENT_RUNTIME.test(id)) return;
+	const patched = code.replaceAll(UNSAFE_GET_OWNER, SAFE_GET_OWNER);
+	return patched === code ? void 0 : patched;
+}
+function createRolldownReactMixedModeGuard() {
+	return {
+		name: REACT_MIXED_MODE_ROLLDOWN_PLUGIN,
+		transform(code, id) {
+			return patchReactDevelopmentRuntime(code, id);
+		}
+	};
+}
+function createEsbuildReactMixedModeGuard() {
+	return {
+		name: REACT_MIXED_MODE_ESBUILD_PLUGIN,
+		setup(build) {
+			build.onLoad({ filter: REACT_DEVELOPMENT_RUNTIME }, (args) => {
+				const patched = patchReactDevelopmentRuntime(readFileSync$1(args.path, "utf8"), args.path);
+				if (patched === void 0) return;
+				return {
+					contents: patched,
+					loader: "js"
+				};
+			});
+		}
+	};
+}
+//#endregion
 //#region src/utils/PromiseStore.ts
 /**
 * example:
@@ -8311,7 +8334,7 @@ function excludeSharedSubDependencies(shared) {
 	}
 }
 function proxySharedModule(options) {
-	const { shared = {}, federationOptions } = options;
+	const { shared = {}, federationOptions, getParsePromise = () => Promise.resolve() } = options;
 	let _config;
 	let _command = "serve";
 	let useDirectReactImport = false;
@@ -8320,6 +8343,7 @@ function proxySharedModule(options) {
 	let devServer;
 	const materializedLoadShareSources = /* @__PURE__ */ new Set();
 	const emittedTreeShakingProviders = /* @__PURE__ */ new Set();
+	const hasAnalyzableShares = Object.values(shared).some((share) => shouldAnalyzeSharedExports(share));
 	const normalizeTreeShakingOutputPath = (value) => {
 		const normalized = normalizePathForImport(value);
 		if (path$1.posix.isAbsolute(normalized) || /^[A-Za-z]:\//.test(normalized) || normalized.split("/").includes("..")) throw new Error(`Invalid treeShakingDir "${value}": absolute paths and parent segments are not allowed.`);
@@ -8364,7 +8388,7 @@ function proxySharedModule(options) {
 				if (source === getLocalSharedImportMapPath(federationOptions)) return getResolvedLocalSharedImportMapId(federationOptions);
 			},
 			load(id) {
-				if (id === getResolvedLocalSharedImportMapId(federationOptions)) return parsePromise.then((_) => {
+				if (id === getResolvedLocalSharedImportMapId(federationOptions)) return getParsePromise().then((_) => {
 					refreshTreeShakingModules(federationOptions);
 					const providerPackages = /* @__PURE__ */ new Set([...Object.keys(shared).filter((pkg) => !pkg.endsWith("/")), ...getUsedShares(federationOptions)]);
 					for (const pkg of providerPackages) {
@@ -8419,10 +8443,10 @@ function proxySharedModule(options) {
 				refreshTreeShakingModules(federationOptions);
 			},
 			shouldTransformCachedModule() {
-				return _command === "build" && Object.values(shared).some((share) => !!share.shareConfig.treeShaking);
+				return _command === "build" && hasAnalyzableShares;
 			},
 			transform(code, id) {
-				if (_command !== "build" || !Object.keys(shared).some((key) => shared[key].shareConfig.treeShaking)) return;
+				if (_command !== "build" || !hasAnalyzableShares) return;
 				collectTreeShakingImports(code, id, shared, findSharedKeyForSource, (sharedKey, exports, request) => recordTreeShakingExports(sharedKey, exports, request, federationOptions), (sharedKey, request) => markTreeShakingPackageUnsafe(sharedKey, request, federationOptions));
 				refreshTreeShakingModules(federationOptions);
 			}
@@ -8526,6 +8550,15 @@ const JS_EXTENSIONS_RE = /\.(?:[mc]?[jt]sx?|vue|svelte)(?:\?|$)/;
 function isAstNode(value) {
 	return !!value && typeof value === "object" && typeof value.type === "string";
 }
+function findStaticRemoteSources(code, isRemoteImport) {
+	const codePositions = createCodePositionMap(code);
+	const sources = /* @__PURE__ */ new Set();
+	for (const pattern of [/\b(?:import|export)\s+[^;]*?\bfrom\s*["']([^"']+)["']/g, /\bimport\s*["']([^"']+)["']/g]) for (const match of code.matchAll(pattern)) {
+		const source = match[1];
+		if (codePositions[match.index] && isRemoteImport(source)) sources.add(source);
+	}
+	return sources;
+}
 function walkAST(root, visitor) {
 	const seen = /* @__PURE__ */ new WeakSet();
 	function visit(node) {
@@ -8678,6 +8711,7 @@ async function collectFromAST(ast, code, isRemoteImport) {
 			if (!value || !isRemoteImport(value)) return;
 			result.push({
 				kind: "dynamic",
+				source: value,
 				start: node.start,
 				end: node.end,
 				originalText: code.slice(node.start, node.end)
@@ -8756,6 +8790,7 @@ function collectFromRegex(code, isRemoteImport) {
 		if (!isRemoteImport(source)) continue;
 		result.push({
 			kind: "dynamic",
+			source,
 			start: match.index,
 			end: match.index + full.length,
 			originalText: full
@@ -8782,6 +8817,7 @@ function pluginRemoteNamedExports(options) {
 			if (!JS_EXTENSIONS_RE.test(id)) return;
 			if (!remoteNames.some((name) => code.includes(name))) return;
 			const matchesRemoteImport = (source) => isRemoteImport(source, id);
+			for (const source of findStaticRemoteSources(code, matchesRemoteImport)) markStaticRemote(source, options);
 			let imports;
 			try {
 				imports = await collectFromAST(this.parse(code), code, matchesRemoteImport);
@@ -8790,6 +8826,7 @@ function pluginRemoteNamedExports(options) {
 				imports = collectFromRegex(code, matchesRemoteImport);
 			}
 			if (!imports) return;
+			for (const remoteImport of imports) if (remoteImport.kind === "dynamic") markDynamicRemote(remoteImport.source, options);
 			return applyRewrites(code, imports, id);
 		}
 	};
@@ -9318,7 +9355,7 @@ function stripEmptyPreloadCalls(code) {
 	}
 	nextCode = nextCode.replace(/import\s*["'][^"']*__loadShare__[^"']*["']\s*;?/g, "");
 	nextCode = nextCode.replace(helperImportRegex, (statement, local) => {
-		return new RegExp(`\\b${local}\\s*\\(`).test(nextCode.replace(statement, "")) ? statement : "";
+		return new RegExp(`\\b${local}\\b`).test(nextCode.replace(statement, "")) ? statement : "";
 	});
 	return nextCode;
 }
@@ -9624,6 +9661,7 @@ function includeLinkedSharedEntries(optimizeDeps, shared, projectRoot, exposes,
 function createEarlyVirtualModulesPlugin(options) {
 	const { shared, remotes } = options;
 	const isLitShare = (pkg) => pkg === "lit" || pkg.startsWith("lit/");
+	const shouldGuardReactMixedMode = Object.keys(remotes ?? {}).length > 0 && shared?.react?.shareConfig.singleton === true;
 	return {
 		name: "vite:module-federation-early-init",
 		enforce: "pre",
@@ -9651,6 +9689,7 @@ function createEarlyVirtualModulesPlugin(options) {
 					if (isRolldown) {
 						optimizeDeps.rolldownOptions ??= {};
 						optimizeDeps.rolldownOptions.plugins ??= [];
+						if (shouldGuardReactMixedMode) optimizeDeps.rolldownOptions.plugins.push(createRolldownReactMixedModeGuard());
 						optimizeDeps.rolldownOptions.plugins.push({
 							name: "module-federation:optimize-shared-resolver",
 							load(id) {
@@ -9695,6 +9734,7 @@ function createEarlyVirtualModulesPlugin(options) {
 					} else {
 						optimizeDeps.esbuildOptions ??= {};
 						optimizeDeps.esbuildOptions.plugins ??= [];
+						if (shouldGuardReactMixedMode) optimizeDeps.esbuildOptions.plugins.push(createEsbuildReactMixedModeGuard());
 						optimizeDeps.esbuildOptions.plugins.push({
 							name: "module-federation:optimize-shared-proxy",
 							setup(build) {
@@ -9769,7 +9809,7 @@ export default __mfShared.default ?? __mfShared;`
 						else optimizeDeps.include.push(key);
 						for (const subpath of getCommonSharedSubpaths(key)) {
 							const canResolveSubpath = canResolveSharedSubpath(subpath, root);
-							if (subpath === "react/compiler-runtime" && !canResolveSubpath) {
+							if (["react/compiler-runtime", "react-dom/client"].includes(subpath) && !canResolveSubpath) {
 								optimizeDeps.exclude.push(subpath);
 								continue;
 							}
@@ -9877,6 +9917,14 @@ function federation(mfUserOptions) {
 	if (!name) throw createModuleFederationError("name is required");
 	const remoteEntryId = getRemoteEntryId(options);
 	const virtualExposesId = getVirtualExposesId(options);
+	const moduleParseController = createModuleParseController();
+	const moduleParsePlugins = pluginModuleParseEnd_default((id) => {
+		return id.includes(getHostAutoInitImportId(options)) || id.includes(remoteEntryId) || id.includes(virtualExposesId) || id.includes("virtual:mf-localSharedImportMap") || id.includes("__loadShare__") || id.includes("__prebuild__") || id.includes("__treeShakingProvider__") || id.includes("__mf_tree_shaking_graph__");
+	}, {
+		moduleParseTimeout: options.moduleParseTimeout,
+		moduleParseIdleTimeout: options.moduleParseIdleTimeout,
+		exposedModuleImports: Object.values(options.exposes).map((expose) => expose.import)
+	}, moduleParseController);
 	let command;
 	let desiredRolldownOutput;
 	let isSsrBuild = false;
@@ -9908,7 +9956,7 @@ function federation(mfUserOptions) {
 		writePreBuildLibPath(pkg, shared[key], options, getLoadHookExportConditions(context, loadOptions));
 		return "refreshed";
 	};
-	const refreshLoadShareModuleForEnvironment = (id, context, loadOptions) => {
+	const refreshLoadShareModuleForEnvironment = (id, context, loadOptions, importFalseExportUsage) => {
 		const pkg = getCachedLoadSharePkg(id);
 		if (!pkg) return "not-applicable";
 		const key = findSharedKey(pkg, shared);
@@ -9916,9 +9964,26 @@ function federation(mfUserOptions) {
 		const requestedModule = VirtualModule.findById(id);
 		const ownedModule = VirtualModule.findById(getLoadShareModulePath(pkg, false, options));
 		if (!requestedModule || requestedModule !== ownedModule) return "not-owned";
-		writeLoadShareModule(pkg, shared[key], command, getIsRolldown(context), options, getLoadHookExportConditions(context, loadOptions));
+		writeLoadShareModule(pkg, shared[key], command, getIsRolldown(context), options, getLoadHookExportConditions(context, loadOptions), importFalseExportUsage);
 		return "refreshed";
 	};
+	const getCompleteImportFalseExportUsage = (id) => {
+		if (command !== "build") return void 0;
+		const pkg = getCachedLoadSharePkg(id);
+		if (!pkg) return void 0;
+		const key = findSharedKey(pkg, shared);
+		if (!key || shared[key].shareConfig.import !== false) return void 0;
+		return moduleParseController.parsePromise.then((completion) => {
+			if (!completion.complete) {
+				if (!moduleParseController.discardWarned) {
+					moduleParseController.discardWarned = true;
+					mfWarn(`import: false shared export analysis was discarded (reason: ${completion.reason}) — falling back to the complete export surface, so shared consumers keep every detected named export.` + (completion.reason === "idle-timeout" || completion.reason === "timeout" ? " If the build is simply slow, increasing moduleParseIdleTimeout may let the analysis finish." : ""));
+				}
+				return;
+			}
+			return getSharedExportUsage(pkg, shared[key], key, options);
+		});
+	};
 	return [
 		{
 			name: "vite:module-federation-virtual-modules",
@@ -10024,20 +10089,16 @@ function federation(mfUserOptions) {
 		pluginProxyRemoteEntry_default({
 			options,
 			remoteEntryId,
-			virtualExposesId
+			virtualExposesId,
+			getParsePromise: () => moduleParseController.parsePromise
 		}),
 		pluginProxyRemotes_default(options),
 		pluginRemoteNamedExports(options),
-		...pluginModuleParseEnd_default((id) => {
-			return id.includes(getHostAutoInitImportId(options)) || id.includes(remoteEntryId) || id.includes(virtualExposesId) || id.includes(getLocalSharedImportMapPath(options)) || id.includes("__loadShare__") || id.includes("__prebuild__") || id.includes("__treeShakingProvider__") || id.includes("__mf_tree_shaking_graph__");
-		}, {
-			moduleParseTimeout: options.moduleParseTimeout,
-			moduleParseIdleTimeout: options.moduleParseIdleTimeout,
-			exposedModuleImports: Object.values(options.exposes).map((expose) => expose.import)
-		}),
+		...moduleParsePlugins,
 		...proxySharedModule({
 			shared,
-			federationOptions: options
+			federationOptions: options,
+			getParsePromise: () => moduleParseController.parsePromise
 		}),
 		{
 			name: "module-federation-esm-shims",
@@ -10165,8 +10226,9 @@ function federation(mfUserOptions) {
 				}
 			},
 			load(id, loadOptions) {
-				if (id.includes("__loadShare__") || id.includes("__loadRemote__")) {
-					if (id.includes("__loadShare__") && refreshLoadShareModuleForEnvironment(id, this, loadOptions) === "not-owned") return;
+				const loadVirtualModule = (importFalseExportUsage) => {
+					if (!id.includes("__loadShare__") && !id.includes("__loadRemote__")) return;
+					if (id.includes("__loadShare__") && refreshLoadShareModuleForEnvironment(id, this, loadOptions, importFalseExportUsage) === "not-owned") return;
 					const virtualModule = VirtualModule.findById(id);
 					if (!virtualModule?.code) return null;
 					let code = virtualModule.code;
@@ -10183,7 +10245,10 @@ function federation(mfUserOptions) {
 						code,
 						syntheticNamedExports: "__moduleExports"
 					};
-				}
+				};
+				const pendingImportFalseExportUsage = id.includes("__loadShare__") ? getCompleteImportFalseExportUsage(id) : void 0;
+				if (pendingImportFalseExportUsage) return pendingImportFalseExportUsage.then(loadVirtualModule);
+				return loadVirtualModule();
 			},
 			generateBundle(_outputOptions, bundle, _isWrite) {
 				for (const [fileName, chunk] of Object.entries(bundle)) {