@module-federation/vite 1.20.1 → 1.20.2

package/lib/index.js

@@ -933,7 +933,8 @@ function isNuxtClientBase(base) {
 	return getBasePath$2(base).endsWith("/_nuxt");
 }
 function normalizeNodeModulePath(source) {
-	return source.replace(/\\/g, "/").replace(/\?.*$/, "");
+	const queryIndex = source.indexOf("?");
+	return (queryIndex === -1 ? source : source.slice(0, queryIndex)).replace(/\\/g, "/");
 }
 function isNodeModulePath(source) {
 	return source.includes("/node_modules/") || source.includes("\\node_modules\\");
@@ -1914,6 +1915,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 +1991,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 +2008,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 +2126,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 +2140,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);
@@ -2709,7 +2717,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 +2740,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 +3301,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 +3329,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 +3340,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 +3627,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)},
@@ -5074,6 +5109,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 +5131,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 +5334,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 +5572,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 +7827,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 +8004,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 +8114,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 +8124,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 +8281,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 +8460,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 +8469,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 +8514,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 +8569,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 +8676,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 +8837,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 +8916,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 +8943,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 +8952,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);
 		}
 	};
@@ -9624,6 +9787,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 +9815,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 +9860,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) {
@@ -9877,6 +10043,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 +10082,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 +10090,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 +10215,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 +10352,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 +10371,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)) {

package/lib/{ssrEntryLoader-Bw423jj_.js → ssrEntryLoader-gVPDPAE8.js}

@@ -140,12 +140,13 @@ const runnerCache = /* @__PURE__ */ new Map();
 * exist.
 */
 async function getModuleRunnerModule() {
+	const moduleRunnerId = ["vite", "module-runner"].join("/");
 	try {
 		const { createRequire } = await nodeImport("module");
-		return createRequire(import.meta.url)("vite/module-runner");
+		return createRequire(import.meta.url)(moduleRunnerId);
 	} catch {}
 	try {
-		return await import("vite/module-runner");
+		return await nodeImport(moduleRunnerId);
 	} catch {
 		return null;
 	}
@@ -572,7 +573,7 @@ async function importTempModule(filePath, versionKey) {
 }
 let warnedVmUnavailable = false;
 async function tryVmStrategy(ssrEntry, options) {
-	const { loadViaVmStrategy, isVmStrategyAvailable } = await import("./ssrVmStrategy-7HAPa-Vc.js");
+	const { loadViaVmStrategy, isVmStrategyAvailable } = await import("./ssrVmStrategy-B34y11HE.js");
 	if (!await isVmStrategyAvailable()) {
 		if (!warnedVmUnavailable) {
 			warnedVmUnavailable = true;

package/lib/{ssrVmStrategy-7HAPa-Vc.js → ssrVmStrategy-B34y11HE.js}

@@ -1,4 +1,4 @@
-import { c as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, s as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-Bw423jj_.js";
+import { c as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, s as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-gVPDPAE8.js";
 //#region src/utils/ssrVmStrategy.ts
 /**
 * vm.SourceTextModule strategy for loading remote SSR entries.

package/lib/utils/ssrEntryLoader.js

@@ -1,2 +1,2 @@
-import { i as ssrEntryLoaderPlugin, n as neutralizeBrowserPreloadHelpers, r as revalidate, t as SsrEntryHttpError } from "../ssrEntryLoader-Bw423jj_.js";
+import { i as ssrEntryLoaderPlugin, n as neutralizeBrowserPreloadHelpers, r as revalidate, t as SsrEntryHttpError } from "../ssrEntryLoader-gVPDPAE8.js";
 export { SsrEntryHttpError, ssrEntryLoaderPlugin as default, neutralizeBrowserPreloadHelpers, revalidate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/vite",
-  "version": "1.20.1",
+  "version": "1.20.2",
   "description": "Vite plugin for Module Federation",
   "type": "module",
   "main": "./lib/index.js",
@@ -90,7 +90,41 @@
     "rollup": "4.62.3",
     "tsdown": "0.22.14",
     "typescript": "7.0.2",
-    "vite": "8.1.5",
-    "vitest": "4.0.18"
+    "vite": "8.2.0",
+    "vitest": "4.1.10"
+  },
+  "pnpm": {
+    "overrides": {
+      "@babel/core@<7.29.6": "7.29.6",
+      "@babel/helpers@<7.26.10": "7.29.7",
+      "@babel/plugin-transform-modules-systemjs@<7.29.4": "7.29.4",
+      "@babel/runtime@<7.26.10": "7.29.7",
+      "adm-zip@<0.6.0": "0.6.0",
+      "ajv@>=6.0.0 <6.14.0": "6.14.0",
+      "ajv@>=8.0.0 <8.18.0": "8.20.0",
+      "body-parser@<1.20.6": "1.20.6",
+      "cross-spawn@<7.0.5": "7.0.6",
+      "esbuild@<0.28.1": "0.28.1",
+      "fast-uri@>=3.0.0 <3.1.4": "3.1.4",
+      "follow-redirects@<1.16.0": "1.16.0",
+      "http-proxy-middleware@>=2.0.0 <2.0.10": "2.0.10",
+      "immutable@<4.3.9": "4.3.9",
+      "js-yaml@>=4.0.0 <4.3.0": "4.3.0",
+      "lodash@<4.18.0": "4.18.1",
+      "path-to-regexp@<0.1.13": "0.1.13",
+      "postcss@<8.5.18": "8.5.25",
+      "qs@>=6.0.0 <6.15.2": "6.15.2",
+      "serialize-javascript@<7.0.5": "7.0.5",
+      "shell-quote@<1.9.0": "1.10.0",
+      "sucrase@<3.35.1": "3.35.1",
+      "undici@>=7.0.0 <7.28.0": "7.28.0",
+      "uuid@<11.1.1": "11.1.1",
+      "webpack-dev-server@<5.2.6": "5.2.6",
+      "webpack@<5.104.1": "5.109.2",
+      "websocket-driver@<0.7.5": "0.7.5",
+      "ws@>=8.0.0 <8.21.0": "8.21.0",
+      "yaml@>=1.0.0 <1.10.3": "1.10.3",
+      "yaml@>=2.0.0 <2.8.3": "2.8.3"
+    }
   }
-}
+}