@module-federation/vite 1.21.6 → 1.22.1

package/lib/index.js

@@ -1,6 +1,6 @@
+import { _ as stripViteFsPrefix, a as ensureTrailingSlash, c as getCommonSharedSubpaths, d as isNodeModulePath, f as isNuxtClientBase, g as stripQueryAndHash, h as resolvePublicPath, l as getNodeModulesSuffix, m as normalizeNodeModulePath, n as invalidateSharedKeyMatcher, o as filterId, p as isViteOptimizableEntry, r as matchesSharedSource, s as getBasePath$1, t as findSharedKey, u as isAssetLikeImport } from "./sharedKeyMatcher-BRzBCbuR.js";
 import { i as resolveHashPlaceholderFileName, n as normalizePathForImport, r as rebaseImport } from "./buildPaths-BoaQTkxt.js";
-import { a as getPackageDetectionCwd, c as getSharedCacheDescriptor, d as packageNameDecode, f as packageNameEncode, g as createModuleFederationError, h as sharedCacheHelperCode, i as getIsRolldown, l as hasPackageDependency, m as setPackageDetectionCwd, n as getInstalledPackageEntry, o as getPackageName, p as resolveImportPath, r as getInstalledPackageJson, s as getPackageNameFromNodeModulePath, u as isNuxtProjectRoot, v as mfWarn } from "./dtsConstants-BsaLBaaK.js";
-import { a as filterId, c as getCommonSharedSubpaths, d as isNodeModulePath, f as isNuxtClientBase, h as resolvePublicPath, i as ensureTrailingSlash, l as getMatchingNodeModuleSubpath, m as normalizeNodeModulePath, n as invalidateSharedKeyMatcher, o as getBasePath$1, p as isViteOptimizableEntry, r as matchesSharedSource, s as getCommonSharedSubpathFromNodeModulePath, t as findSharedKey, u as isAssetLikeImport } from "./sharedKeyMatcher-DiUzRVH1.js";
+import { _ as sharedCacheHelperCode, a as getPackageDetectionCwd, b as mfWarn, c as getSharedCacheDescriptor, d as isPackageExportAvailable, f as isPackageInstalled, g as setPackageDetectionCwd, h as resolveImportPath, i as getIsRolldown, l as hasPackageDependency, m as packageNameEncode, n as getInstalledPackageEntry, o as getPackageName, p as packageNameDecode, r as getInstalledPackageJson, s as getPackageNameFromNodeModulePath, u as isNuxtProjectRoot, v as createModuleFederationError } from "./dtsConstants-dDsHZFC1.js";
 import { createRequire } from "node:module";
 import * as fs$2 from "fs";
 import { existsSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "fs";
@@ -373,6 +373,38 @@ async function mapCodeToCodeWithSourcemap(code) {
 	};
 }
 //#endregion
+//#region src/utils/remoteConsumerTarget.ts
+function getPluginEnvironmentName(ctx) {
+	if (ctx == null || typeof ctx !== "object") return void 0;
+	const environment = ctx["environment"];
+	if (environment == null || typeof environment !== "object") return void 0;
+	const name = environment["name"];
+	return typeof name === "string" ? name : void 0;
+}
+/**
+* Classify a plugin hook context's Vite environment. Environment names are
+* user-defined, so Vite's `config.consumer` is the semantic role; fall back to
+* the name only when it is missing (Vite 5–7). Returns `undefined` when the hook
+* has no environment context at all.
+*/
+function resolveEnvironmentConsumerTarget(ctx) {
+	if (ctx == null || typeof ctx !== "object") return void 0;
+	const environment = ctx["environment"];
+	if (environment == null || typeof environment !== "object") return void 0;
+	const consumer = environment.config?.consumer;
+	if (consumer === "client" || consumer === "server") return consumer;
+	const envName = getPluginEnvironmentName(ctx);
+	return !envName || envName === "client" ? "client" : "server";
+}
+/** Vite 5–7 hooks have no environment context and keep their client build behavior. */
+function isClientEnvironment(ctx) {
+	return resolveEnvironmentConsumerTarget(ctx) !== "server";
+}
+function resolveRemoteConsumer(ctx, hasMultiEnvironment) {
+	if (!hasMultiEnvironment) return "unified";
+	return resolveEnvironmentConsumerTarget(ctx) ?? "client";
+}
+//#endregion
 //#region src/utils/codePositionMap.ts
 const REGEX_PREFIX_KEYWORDS = /* @__PURE__ */ new Set([
 	"await",
@@ -399,7 +431,7 @@ function isJsxClosingTagSlash(code, slashIndex) {
 	return code[cursor] === ">";
 }
 /** Mark comments, string/template literals, and regular expressions as non-code. */
-function createCodePositionMap(code) {
+function createCodePositionMap(code, onComment) {
 	const positions = Array(code.length).fill(true);
 	const mask = (start, end) => {
 		for (let index = start; index < end; index++) positions[index] = false;
@@ -417,6 +449,7 @@ function createCodePositionMap(code) {
 			index += 2;
 			while (index < code.length && code[index] !== "\n" && code[index] !== "\r") index++;
 			mask(start, index);
+			onComment?.(start, index);
 			continue;
 		}
 		if (char === "/" && next === "*") {
@@ -425,6 +458,7 @@ function createCodePositionMap(code) {
 			while (index < code.length && !(code[index] === "*" && code[index + 1] === "/")) index++;
 			index = Math.min(code.length, index + 2);
 			mask(start, index);
+			onComment?.(start, index);
 			continue;
 		}
 		if (char === "\"" || char === "'" || char === "`") {
@@ -730,8 +764,8 @@ function normalizeRemoteItem(key, remote) {
 * @param {string} sharedName
 * @returns {string | undefined}
 */
-function searchPackageVersion(sharedName) {
-	const version = getInstalledPackageJson(sharedName)?.packageJson.version;
+function searchPackageVersion(sharedName, cwd) {
+	const version = getInstalledPackageJson(sharedName, { cwd })?.packageJson.version;
 	return typeof version === "string" ? version : void 0;
 }
 function inferVersionFromRequiredVersion(requiredVersion) {
@@ -766,36 +800,88 @@ const PACKAGE_SPECIFIER_PROTOCOL_RE = /^[a-z][a-z\d+.-]*:/i;
 function isProtocolRequiredVersion(requiredVersion) {
 	return PACKAGE_SPECIFIER_PROTOCOL_RE.test(requiredVersion.trim());
 }
+const SEMVER_COMPARATOR_RE = /^(?:[<>=~^]*v?(?:\d+|[xX*])(?:\.(?:\d+|[xX*]))*(?:[-+][\w.-]+)?|[<>=~^]+|[xX*]|-)$/;
+function isSemverRange(range) {
+	return range.split("||").every((alternative) => {
+		const comparators = alternative.trim().split(/\s+/).filter(Boolean);
+		return comparators.length > 0 && comparators.every((c) => SEMVER_COMPARATOR_RE.test(c));
+	});
+}
+function isUsableRequiredVersion(requiredVersion) {
+	return requiredVersion.trim() !== "" && !isProtocolRequiredVersion(requiredVersion) && isSemverRange(requiredVersion);
+}
+/** Bare specifiers name an installed package; relative/absolute paths do not. */
+function isBareSpecifier(specifier) {
+	return !specifier.startsWith(".") && !specifier.startsWith("\0") && !path$1.isAbsolute(specifier) && !PACKAGE_SPECIFIER_PROTOCOL_RE.test(specifier);
+}
+function readProjectPackageJson(cwd, cache) {
+	if (cache.has(cwd)) return cache.get(cwd);
+	let packageJson;
+	try {
+		packageJson = JSON.parse(fs$2.readFileSync(path$1.join(cwd, "package.json"), "utf8"));
+	} catch {}
+	cache.set(cwd, packageJson);
+	return packageJson;
+}
 function getLitExportSubpathShares(sharedName) {
 	if (sharedName !== "lit") return [];
 	const exportsField = getInstalledPackageJson(sharedName, { packageName: sharedName })?.packageJson.exports;
 	if (!exportsField || typeof exportsField === "string") return [];
 	return Object.keys(exportsField).filter((key) => key.startsWith("./") && key !== "." && !key.includes("*")).map((key) => `${sharedName}/${key.slice(2)}`);
 }
+const sharedVersionConfigs = /* @__PURE__ */ new WeakMap();
+function resolveSharedVersion(key, config, cwd, packageJsonCache = /* @__PURE__ */ new Map(), fallbackVersion) {
+	const source = typeof config.import === "string" && isBareSpecifier(config.import) ? config.import : key;
+	const version = config.version || searchPackageVersion(source, cwd) || inferVersionFromRequiredVersion(config.requiredVersion) || fallbackVersion;
+	let requiredVersion = config.requiredVersion;
+	if (requiredVersion === void 0 && !config.version) {
+		const packageJson = readProjectPackageJson(cwd, packageJsonCache);
+		const packageName = getPackageName(source);
+		requiredVersion = packageJson?.dependencies?.[packageName] ?? packageJson?.devDependencies?.[packageName] ?? packageJson?.peerDependencies?.[packageName] ?? packageJson?.optionalDependencies?.[packageName];
+	}
+	if (requiredVersion === false || typeof requiredVersion === "string" && isUsableRequiredVersion(requiredVersion)) return {
+		version,
+		requiredVersion
+	};
+	return {
+		version,
+		requiredVersion: config.import === false || config.version ? "*" : version ? `^${version}` : "*"
+	};
+}
+function resolveSharedVersions(shared, root) {
+	const packageJsonCache = /* @__PURE__ */ new Map();
+	for (const [key, item] of Object.entries(shared)) {
+		const config = sharedVersionConfigs.get(item);
+		if (!config) continue;
+		const { version, requiredVersion } = resolveSharedVersion(key, config, root, packageJsonCache, item.version);
+		item.version = version;
+		item.shareConfig.requiredVersion = requiredVersion;
+	}
+}
 function normalizeShareItem(key, shareItem) {
-	const isImportFalse = typeof shareItem === "object" && shareItem.import === false;
-	const explicitVersion = typeof shareItem === "object" ? shareItem.version : void 0;
-	const inferredVersion = typeof shareItem === "object" ? inferVersionFromRequiredVersion(shareItem.requiredVersion) : void 0;
 	const treeShaking = typeof shareItem === "object" ? shareItem.treeShaking : void 0;
 	if (treeShaking && treeShaking.mode !== "server-calc" && treeShaking.mode !== "runtime-infer") throw createModuleFederationError(`Invalid shared config for "${key}": treeShaking.mode must be either "server-calc" or "runtime-infer".`);
 	if (treeShaking && typeof shareItem === "object" && shareItem.eager) throw createModuleFederationError(`Invalid shared config for "${key}": cannot use both "eager: true" and "treeShaking.mode" simultaneously. Choose one strategy.`);
 	if (treeShaking?.mode === "runtime-infer" && typeof shareItem === "object" && shareItem.singleton) mfWarn(`Shared singleton "${key}" uses runtime-infer tree shaking, which may load both a tree-shaken bundle and a full bundle when consumers require different exports. Prefer server-calc for singleton dependencies. If runtime-infer is required, expand usedExports to reduce this risk.`);
-	const version = explicitVersion || searchPackageVersion(key) || inferredVersion;
-	if (typeof shareItem === "string") return {
-		name: shareItem,
-		version,
-		scope: "default",
-		from: "",
-		shareConfig: {
-			import: void 0,
-			singleton: false,
-			eager: false,
-			requiredVersion: version ? `^${version}` : "*"
-		}
-	};
-	const userRequiredVersion = shareItem.requiredVersion;
-	const keepUserRequiredVersion = userRequiredVersion === false || typeof userRequiredVersion === "string" && userRequiredVersion.trim() !== "" && !isProtocolRequiredVersion(userRequiredVersion);
-	return {
+	const config = typeof shareItem === "object" ? shareItem : {};
+	const { version, requiredVersion } = resolveSharedVersion(key, config, getPackageDetectionCwd());
+	if (typeof shareItem === "string") {
+		const result = {
+			name: shareItem,
+			version,
+			scope: "default",
+			from: "",
+			shareConfig: {
+				import: void 0,
+				singleton: false,
+				eager: false,
+				requiredVersion
+			}
+		};
+		sharedVersionConfigs.set(result, { ...config });
+		return result;
+	}
+	const result = {
 		name: key,
 		from: "",
 		version,
@@ -804,12 +890,14 @@ function normalizeShareItem(key, shareItem) {
 			import: shareItem.import,
 			singleton: shareItem.singleton || false,
 			eager: shareItem.eager || false,
-			requiredVersion: keepUserRequiredVersion ? userRequiredVersion : isImportFalse || shareItem.version ? "*" : version ? `^${version}` : "*",
+			requiredVersion,
 			strictVersion: !!shareItem.strictVersion,
 			...shareItem.suppressMissingImportWarning ? { suppressMissingImportWarning: true } : {},
 			...treeShaking ? { treeShaking: { ...treeShaking } } : {}
 		}
 	};
+	sharedVersionConfigs.set(result, { ...config });
+	return result;
 }
 /**
 * Trailing-slash keys are package namespace prefixes (`lodash/`, `@scope/ui/`).
@@ -887,6 +975,11 @@ function normalizeExperiments(experiments) {
 		ssrMode: experiments?.ssrMode === "ISLAND" ? "ISLAND" : void 0
 	};
 }
+function normalizeSsrEntryLoader(ssrEntryLoader) {
+	const strategy = ssrEntryLoader?.strategy;
+	if (strategy !== "temp-file" && strategy !== "vm") return void 0;
+	return { strategy };
+}
 let config;
 let explicitSharedKeys = /* @__PURE__ */ new Set();
 const explicitSharedKeysByOptions = /* @__PURE__ */ new WeakMap();
@@ -905,11 +998,27 @@ function resolveRuntimeImplementation() {
 function getNormalizeModuleFederationOptions() {
 	return config;
 }
+function hasRemotes(options = getNormalizeModuleFederationOptions()) {
+	return Object.keys(options.remotes || {}).length > 0;
+}
+function hasShared(options = getNormalizeModuleFederationOptions()) {
+	return Object.keys(options.shared || {}).length > 0;
+}
+function isRemoteContainer(options = getNormalizeModuleFederationOptions()) {
+	return Object.keys(options.exposes || {}).length > 0;
+}
+function isRemoteOnlyContainer(options = getNormalizeModuleFederationOptions()) {
+	return isRemoteContainer(options) && !hasRemotes(options);
+}
+function isLocalOnlyContainer(options = getNormalizeModuleFederationOptions()) {
+	return !isRemoteContainer(options) && !hasRemotes(options);
+}
 function isExplicitSharedKey(key, options) {
 	return (options ? explicitSharedKeysByOptions.get(options) : explicitSharedKeys)?.has(key) ?? false;
 }
 function getNormalizeShareItem(key, options = getNormalizeModuleFederationOptions()) {
-	return options.shared[key] || options.shared[getPackageName(key)] || options.shared[getPackageName(key) + "/"];
+	const matchedKey = findSharedKey(key, options.shared);
+	return options.shared[key] || (matchedKey ? options.shared[matchedKey] : void 0) || options.shared[getPackageName(key)] || options.shared[getPackageName(key) + "/"];
 }
 function normalizeModuleFederationOptions(options) {
 	warnOnReservedInternalNamePrefix(options.name, "containerName");
@@ -945,6 +1054,7 @@ function normalizeModuleFederationOptions(options) {
 		varFilename: options.varFilename,
 		target: options.target,
 		ssrExternals: options.ssrExternals,
+		ssrEntryLoader: normalizeSsrEntryLoader(options.ssrEntryLoader),
 		disableRemote: options.disableRemote,
 		disableShared: options.disableShared,
 		disableSnapshot: options.disableSnapshot,
@@ -1022,11 +1132,14 @@ var VirtualModule = class VirtualModule {
 		cacheMap[this.tag][this.name] = this;
 	}
 	getImportId() {
-		const importIdKey = `${this.scopeName ?? getNormalizeModuleFederationOptions().internalName}${this.tag}${this.name}${this.tag}`;
+		const mfName = this.scopeName ?? getNormalizeModuleFederationOptions().internalName;
+		const importIdKey = `${mfName}${this.tag}${this.name}${this.tag}`;
 		if (this.importId && this.importIdKey === importIdKey) return this.importId;
 		if (this.importId) delete idCacheMap[this.importId];
 		this.importIdKey = importIdKey;
-		this.importId = `virtual:mf:${packageNameEncode(importIdKey)}${this.suffix}`;
+		const namePart = packageNameEncode(this.name);
+		const mfNamePart = packageNameEncode(mfName);
+		this.importId = `virtual:mf:${mfNamePart}${this.tag}${namePart}${this.tag}${this.suffix}`;
 		idCacheMap[this.importId] = this;
 		return this.importId;
 	}
@@ -1163,161 +1276,431 @@ function isParsableExpression(source) {
 	}
 }
 //#endregion
-//#region src/utils/reactIsland.ts
-const SOURCE_EXTENSIONS$1 = [
-	".tsx",
-	".jsx",
-	".ts",
-	".js",
-	".mts",
-	".mjs",
-	".cts",
-	".cjs"
-];
-function stripQueryAndHash$2(id) {
-	return id.split(/[?#]/, 1)[0];
+//#region src/utils/treeShaking.ts
+function shouldAnalyzeSharedExports(shareItem) {
+	return !!(shareItem && (shareItem.shareConfig.treeShaking || shareItem.shareConfig.import === false));
 }
-function resolveSourceFile(importPath, root) {
-	const cleanImport = stripQueryAndHash$2(importPath);
-	if (!cleanImport.startsWith(".") && !path$1.isAbsolute(cleanImport)) return;
-	const candidate = path$1.isAbsolute(cleanImport) ? cleanImport : path$1.resolve(root, cleanImport);
-	return [
-		candidate,
-		...SOURCE_EXTENSIONS$1.map((extension) => `${candidate}${extension}`),
-		...SOURCE_EXTENSIONS$1.map((extension) => path$1.join(candidate, `index${extension}`))
-	].find((filePath) => {
-		try {
-			return fs$1.statSync(filePath).isFile();
-		} catch {
-			return false;
-		}
-	});
+const legacyTreeShakingState = {
+	inferredUsage: /* @__PURE__ */ new Map(),
+	buildMode: false
+};
+const treeShakingStates = /* @__PURE__ */ new WeakMap();
+function getTreeShakingState(options) {
+	if (!options) return legacyTreeShakingState;
+	let state = treeShakingStates.get(options);
+	if (!state) {
+		state = {
+			inferredUsage: /* @__PURE__ */ new Map(),
+			buildMode: false
+		};
+		treeShakingStates.set(options, state);
+	}
+	return state;
 }
-function localDefaultReexport(source) {
-	const match = source.match(/export\s*{\s*(?:default(?:\s+as\s+default)?|[A-Za-z_$][\w$]*\s+as\s+default)\s*}\s*from\s*["']([^"']+)["']/);
-	return match?.[1]?.startsWith(".") ? match[1] : void 0;
+function setTreeShakingBuildMode(enabled, options) {
+	getTreeShakingState(options).buildMode = enabled;
 }
-function isReactComponentSource(source, filePath = "component.tsx") {
-	if (!(/\bexport\s+default\b/.test(source) || /\bexport\s*{[^}]*\bdefault\b[^}]*}(?:\s*from\s*["'][^"']+["'])?/.test(source))) return false;
-	const extension = path$1.extname(stripQueryAndHash$2(filePath)).toLowerCase();
-	const canContainJsx = extension === ".tsx" || extension === ".jsx";
-	const hasJsx = /<>|<\s*[A-Za-z][\w.:-]*(?:\s[^<>]*?)?\s*\/?>/.test(source);
-	const importsReact = /\bfrom\s*["']react["']|\brequire\(\s*["']react["']\s*\)/.test(source);
-	const usesReactApi = /\b(?:React\.)?(?:createElement|jsx|jsxs)\s*\(/.test(source);
-	const isClientModule = /^\s*["']use client["']\s*;?/m.test(source);
-	return canContainJsx && hasJsx || importsReact && (hasJsx || usesReactApi || isClientModule);
+function resetTreeShakingExports(options) {
+	getTreeShakingState(options).inferredUsage.clear();
 }
-function isReactComponentFile(filePath, seen = /* @__PURE__ */ new Set()) {
-	const normalizedPath = path$1.resolve(filePath);
-	if (seen.has(normalizedPath)) return false;
-	seen.add(normalizedPath);
-	let source;
-	try {
-		source = fs$1.readFileSync(normalizedPath, "utf8");
-	} catch {
-		return false;
+function getOrCreateExportRecord(sharedKey, request, options) {
+	const inferredUsage = getTreeShakingState(options).inferredUsage;
+	let byRequest = inferredUsage.get(sharedKey);
+	if (!byRequest) {
+		byRequest = /* @__PURE__ */ new Map();
+		inferredUsage.set(sharedKey, byRequest);
 	}
-	if (isReactComponentSource(source, normalizedPath)) return true;
-	const reexport = localDefaultReexport(source);
-	if (!reexport) return false;
-	const reexportPath = resolveSourceFile(reexport, path$1.dirname(normalizedPath));
-	return reexportPath ? isReactComponentFile(reexportPath, seen) : false;
-}
-/**
-* React is shared by the normal MF runtime when explicitly configured. When it
-* is local, UI exposes can safely advertise an island capability in addition
-* to their unchanged default export.
-*/
-function getReactIslandExposes(options, root) {
-	if (options.experiments.ssrMode !== "ISLAND") return /* @__PURE__ */ new Set();
-	if (Object.hasOwn(options.shared, "react")) return /* @__PURE__ */ new Set();
-	const islandExposes = /* @__PURE__ */ new Set();
-	for (const [key, expose] of Object.entries(options.exposes)) {
-		const sourceFile = resolveSourceFile(expose.import, root);
-		if (sourceFile && isReactComponentFile(sourceFile)) islandExposes.add(key);
+	let record = byRequest.get(request);
+	if (!record) {
+		record = {
+			requiresFullBundle: false,
+			usedExports: /* @__PURE__ */ new Set()
+		};
+		byRequest.set(request, record);
 	}
-	return islandExposes;
-}
-function generateReactIslandBrowserDefinition(enabled) {
-	if (!enabled) return "";
-	return `
-          exportModule.__mf_island = {
-            version: 1,
-            renderToHtml() {
-              return Promise.reject(new Error("[Module Federation] renderToHtml is only available in the SSR remote entry"));
-            },
-            hydrate(element, props) {
-              const root = element && element.hasAttribute && element.hasAttribute("data-mf-island-state")
-                ? element
-                : element && element.querySelector
-                  ? element.querySelector("[data-mf-island-state]") || element
-                  : element;
-              if (!root) {
-                return Promise.reject(new Error("[Module Federation] Cannot hydrate an island without a root element"));
-              }
-              let serverProps = {};
-              const encodedState = root.getAttribute && root.getAttribute("data-mf-island-state");
-              if (encodedState) {
-                try {
-                  serverProps = JSON.parse(decodeURIComponent(encodedState));
-                } catch {
-                  serverProps = {};
-                }
-              }
-              const finalProps = Object.assign({}, serverProps, props || {});
-              return Promise.all([import("react"), import("react-dom/client")]).then(([React, ReactDOMClient]) => {
-                if (typeof ReactDOMClient.hydrateRoot !== "function") {
-                  throw new Error("[Module Federation] react-dom/client does not provide hydrateRoot");
-                }
-                return ReactDOMClient.hydrateRoot(
-                  root,
-                  React.createElement(importModule.default, finalProps)
-                );
-              });
-            }
-          }`;
+	return record;
 }
-function generateReactIslandSSRDefinition(enabled) {
-	if (!enabled) return "";
-	return `
-          exportModule.__mf_island = {
-            version: 1,
-            async renderToHtml(props) {
-              if (typeof importModule.default !== "function" && typeof importModule.default !== "object") {
-                throw new Error("[Module Federation] A React island expose must have a default component export");
-              }
-              const loadedProps = typeof importModule.load === "function" ? await importModule.load() : {};
-              const finalProps = Object.assign({}, loadedProps || {}, props || {});
-              const [React, ReactDOMServer] = await Promise.all([
-                import("react"),
-                import("react-dom/server")
-              ]);
-              const body = ReactDOMServer.renderToString(
-                React.createElement(importModule.default, finalProps)
-              );
-              const state = encodeURIComponent(JSON.stringify(finalProps));
-              return '<div data-mf-island-state="' + state + '">' + body + '</div>';
-            },
-            hydrate() {
-              return Promise.reject(new Error("[Module Federation] hydrate is only available in the browser remote entry"));
-            }
-          }`;
+function recordTreeShakingExports(sharedKey, exports, request = sharedKey, options) {
+	const record = getOrCreateExportRecord(sharedKey, request, options);
+	exports.forEach((name) => record.usedExports.add(name));
 }
-const REACT_ISLAND_CLIENT_ID_PREFIX = "virtual:mf-react-island-client:";
-const REACT_ISLAND_SERVER_ID_PREFIX = "virtual:mf-react-island-server:";
-const RESOLVED_REACT_ISLAND_CLIENT_ID_PREFIX = `\0${REACT_ISLAND_CLIENT_ID_PREFIX}`;
-const RESOLVED_REACT_ISLAND_SERVER_ID_PREFIX = `\0${REACT_ISLAND_SERVER_ID_PREFIX}`;
-function encodeIslandRemoteId(remoteId) {
-	return encodeURIComponent(remoteId);
+function markTreeShakingPackageUnsafe(sharedKey, request = sharedKey, options) {
+	getOrCreateExportRecord(sharedKey, request, options).requiresFullBundle = true;
 }
-function decodeIslandRemoteId(encodedRemoteId) {
-	return decodeURIComponent(encodedRemoteId);
+function getExportRecords(sharedKey, request, options) {
+	const inferredUsage = getTreeShakingState(options).inferredUsage;
+	if (sharedKey) {
+		const records = inferredUsage.get(sharedKey);
+		const wildcard = records?.get("*");
+		const exact = records?.get(request);
+		return [wildcard, exact === wildcard ? void 0 : exact].filter((record) => !!record);
+	}
+	const records = [];
+	inferredUsage.forEach((byRequest, configuredKey) => {
+		const wildcard = byRequest.get("*");
+		const exact = byRequest.get(request);
+		const keyBase = configuredKey.endsWith("/") ? configuredKey.slice(0, -1) : configuredKey;
+		const requestMatchesConfiguredKey = request === keyBase || request.startsWith(`${keyBase}/`);
+		if (wildcard && requestMatchesConfiguredKey) records.push(wildcard);
+		if (exact && exact !== wildcard) records.push(exact);
+	});
+	return records;
 }
-function getReactIslandImportRemoteId(source) {
-	const queryIndex = source.indexOf("?");
-	if (queryIndex === -1) return;
-	if (!new URLSearchParams(source.slice(queryIndex + 1)).has("mf-island")) return;
-	return source.slice(0, queryIndex);
+/**
+* Return the analyzed requirement for one concrete shared request.
+*
+* Callers that know the configured share key should pass it explicitly. The
+* fallback lookup across keys keeps aliases/backwards-compatible callers
+* working, while still keeping each concrete request's exports isolated.
+*/
+function getSharedExportUsage(request, shareItem, sharedKey, options) {
+	const treeShaking = shareItem?.shareConfig.treeShaking;
+	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 result = new Set(configured);
+	records.forEach((record) => record.usedExports.forEach((name) => result.add(name)));
+	if (result.size > 0) return {
+		kind: "exports",
+		usedExports: [...result].sort()
+	};
+	return records.length > 0 ? {
+		kind: "exports",
+		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;
+	if (source.type === "Literal" && typeof source.value === "string") return source.value;
+	if (source.type === "StringLiteral" && typeof source.value === "string") return source.value;
+	if (source.type !== "TemplateLiteral") return void 0;
+	const expressions = Array.isArray(source.expressions) ? source.expressions : [];
+	const quasis = Array.isArray(source.quasis) ? source.quasis : [];
+	if (expressions.length > 0 || quasis.length !== 1) return void 0;
+	const value = quasis[0]?.value;
+	return typeof value?.cooked === "string" ? value.cooked : typeof value?.raw === "string" ? value.raw : void 0;
+}
+function getExportedName(node) {
+	if (!node || typeof node !== "object") return void 0;
+	const exported = node;
+	if (exported.type === "Identifier" && typeof exported.name === "string") return exported.name;
+	if ((exported.type === "Literal" || exported.type === "StringLiteral") && typeof exported.value === "string") return exported.value;
+}
+function isTypeOnly(node) {
+	return node.importKind === "type" || node.exportKind === "type";
+}
+function forEachAstNode(root, visit) {
+	const stack = [root];
+	const seen = /* @__PURE__ */ new Set();
+	while (stack.length > 0) {
+		const value = stack.pop();
+		if (!value || typeof value !== "object") continue;
+		if (seen.has(value)) continue;
+		seen.add(value);
+		if (Array.isArray(value)) {
+			for (let index = value.length - 1; index >= 0; index--) stack.push(value[index]);
+			continue;
+		}
+		const node = value;
+		if (typeof node.type === "string") visit(node);
+		Object.entries(node).forEach(([key, child]) => {
+			if (key !== "parent" && key !== "loc") stack.push(child);
+		});
+	}
+}
+function collectImportDeclaration(node, source, record, markUnsafe) {
+	if (isTypeOnly(node)) return;
+	const specifiers = Array.isArray(node.specifiers) ? node.specifiers : [];
+	if (specifiers.length === 0) {
+		markUnsafe(source);
+		return;
+	}
+	const names = [];
+	for (const specifier of specifiers) {
+		if (isTypeOnly(specifier)) continue;
+		if (specifier.type === "ImportNamespaceSpecifier") {
+			markUnsafe(source);
+			return;
+		}
+		if (specifier.type === "ImportDefaultSpecifier") {
+			names.push("default");
+			continue;
+		}
+		if (specifier.type === "ImportSpecifier") {
+			const imported = specifier.imported;
+			if (imported?.type === "Literal" || imported?.type === "StringLiteral") {
+				markUnsafe(source);
+				return;
+			}
+			const name = getExportedName(specifier.imported);
+			if (!name) {
+				markUnsafe(source);
+				return;
+			}
+			names.push(name);
+			continue;
+		}
+		markUnsafe(source);
+		return;
+	}
+	record(names, source);
+}
+function collectReExport(node, source, record, markUnsafe) {
+	if (isTypeOnly(node)) return;
+	if (node.type === "ExportAllDeclaration") {
+		markUnsafe(source);
+		return;
+	}
+	const specifiers = Array.isArray(node.specifiers) ? node.specifiers : [];
+	if (specifiers.length === 0) {
+		markUnsafe(source);
+		return;
+	}
+	const names = [];
+	for (const specifier of specifiers) {
+		if (isTypeOnly(specifier)) continue;
+		if (specifier.type !== "ExportSpecifier") {
+			markUnsafe(source);
+			return;
+		}
+		const local = specifier.local;
+		if (local?.type === "Literal" || local?.type === "StringLiteral") {
+			markUnsafe(source);
+			return;
+		}
+		const name = getExportedName(specifier.local);
+		if (!name) {
+			markUnsafe(source);
+			return;
+		}
+		names.push(name);
+	}
+	record(names, source);
+}
+/**
+* Collect the exports required by a consumer's ESM graph.
+*
+* Parsing the module avoids treating import-looking text in comments, strings,
+* templates, or regular expressions as real dependencies. If parsing fails,
+* 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.
+*/
+async function collectTreeShakingImports(code, id, shared, findSharedKey, record, markUnsafe) {
+	const normalizedId = normalizePathForImport(id);
+	if (normalizedId.includes("__prebuild__") || normalizedId.includes("__loadShare__") || normalizedId.includes("__mf_tree_shaking_graph__")) return;
+	let ast;
+	try {
+		ast = parseAst(code);
+	} catch {
+		Object.entries(shared).forEach(([sharedKey, shareItem]) => {
+			if (shouldAnalyzeSharedExports(shareItem)) markUnsafe(sharedKey, "*");
+		});
+		return;
+	}
+	const pending = [];
+	const withSharedSource = (source, use) => {
+		const apply = (key) => {
+			if (key && shouldAnalyzeSharedExports(shared[key])) use(key);
+		};
+		const key = findSharedKey(source, shared);
+		if (key instanceof Promise) pending.push(key.then(apply));
+		else apply(key);
+	};
+	const recordSource = (names, source) => {
+		withSharedSource(source, (key) => record(key, names, source));
+	};
+	const markSourceUnsafe = (source) => {
+		withSharedSource(source, (key) => markUnsafe(key, source));
+	};
+	forEachAstNode(ast, (node) => {
+		if (node.type === "ImportDeclaration") {
+			const source = getModuleSource(node.source);
+			if (source) collectImportDeclaration(node, source, recordSource, markSourceUnsafe);
+			return;
+		}
+		if ((node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") && node.source) {
+			const source = getModuleSource(node.source);
+			if (source) collectReExport(node, source, recordSource, markSourceUnsafe);
+			return;
+		}
+		if (node.type === "ImportExpression") {
+			const source = getModuleSource(node.source);
+			if (source) markSourceUnsafe(source);
+			return;
+		}
+		if (node.type === "CallExpression") {
+			const callee = node.callee;
+			const args = Array.isArray(node.arguments) ? node.arguments : [];
+			if (callee?.type === "Identifier" && callee.name === "require" && args.length > 0) {
+				const source = getModuleSource(args[0]);
+				if (source) markSourceUnsafe(source);
+			}
+		}
+	});
+	await Promise.all(pending);
+}
+//#endregion
+//#region src/utils/reactIsland.ts
+const SOURCE_EXTENSIONS$1 = [
+	".tsx",
+	".jsx",
+	".ts",
+	".js",
+	".mts",
+	".mjs",
+	".cts",
+	".cjs"
+];
+function resolveSourceFile(importPath, root) {
+	const cleanImport = stripQueryAndHash(importPath);
+	if (!cleanImport.startsWith(".") && !path$1.isAbsolute(cleanImport)) return;
+	const candidate = path$1.isAbsolute(cleanImport) ? cleanImport : path$1.resolve(root, cleanImport);
+	return [
+		candidate,
+		...SOURCE_EXTENSIONS$1.map((extension) => `${candidate}${extension}`),
+		...SOURCE_EXTENSIONS$1.map((extension) => path$1.join(candidate, `index${extension}`))
+	].find((filePath) => {
+		try {
+			return fs$1.statSync(filePath).isFile();
+		} catch {
+			return false;
+		}
+	});
+}
+function localDefaultReexport(source) {
+	const match = source.match(/export\s*{\s*(?:default(?:\s+as\s+default)?|[A-Za-z_$][\w$]*\s+as\s+default)\s*}\s*from\s*["']([^"']+)["']/);
+	return match?.[1]?.startsWith(".") ? match[1] : void 0;
+}
+function isReactComponentSource(source, filePath = "component.tsx") {
+	if (!(/\bexport\s+default\b/.test(source) || /\bexport\s*{[^}]*\bdefault\b[^}]*}(?:\s*from\s*["'][^"']+["'])?/.test(source))) return false;
+	const extension = path$1.extname(stripQueryAndHash(filePath)).toLowerCase();
+	const canContainJsx = extension === ".tsx" || extension === ".jsx";
+	const hasJsx = /<>|<\s*[A-Za-z][\w.:-]*(?:\s[^<>]*?)?\s*\/?>/.test(source);
+	const importsReact = /\bfrom\s*["']react["']|\brequire\(\s*["']react["']\s*\)/.test(source);
+	const usesReactApi = /\b(?:React\.)?(?:createElement|jsx|jsxs)\s*\(/.test(source);
+	const isClientModule = /^\s*["']use client["']\s*;?/m.test(source);
+	return canContainJsx && hasJsx || importsReact && (hasJsx || usesReactApi || isClientModule);
+}
+function isReactComponentFile(filePath, seen = /* @__PURE__ */ new Set()) {
+	const normalizedPath = path$1.resolve(filePath);
+	if (seen.has(normalizedPath)) return false;
+	seen.add(normalizedPath);
+	let source;
+	try {
+		source = fs$1.readFileSync(normalizedPath, "utf8");
+	} catch {
+		return false;
+	}
+	if (isReactComponentSource(source, normalizedPath)) return true;
+	const reexport = localDefaultReexport(source);
+	if (!reexport) return false;
+	const reexportPath = resolveSourceFile(reexport, path$1.dirname(normalizedPath));
+	return reexportPath ? isReactComponentFile(reexportPath, seen) : false;
+}
+/**
+* React is shared by the normal MF runtime when explicitly configured. When it
+* is local, UI exposes can safely advertise an island capability in addition
+* to their unchanged default export.
+*/
+function getReactIslandExposes(options, root) {
+	if (options.experiments.ssrMode !== "ISLAND") return /* @__PURE__ */ new Set();
+	if (Object.hasOwn(options.shared, "react")) return /* @__PURE__ */ new Set();
+	const islandExposes = /* @__PURE__ */ new Set();
+	for (const [key, expose] of Object.entries(options.exposes)) {
+		const sourceFile = resolveSourceFile(expose.import, root);
+		if (sourceFile && isReactComponentFile(sourceFile)) islandExposes.add(key);
+	}
+	return islandExposes;
+}
+function generateReactIslandBrowserDefinition(enabled) {
+	if (!enabled) return "";
+	return `
+          exportModule.__mf_island = {
+            version: 1,
+            renderToHtml() {
+              return Promise.reject(new Error("[Module Federation] renderToHtml is only available in the SSR remote entry"));
+            },
+            hydrate(element, props) {
+              const root = element && element.hasAttribute && element.hasAttribute("data-mf-island-state")
+                ? element
+                : element && element.querySelector
+                  ? element.querySelector("[data-mf-island-state]") || element
+                  : element;
+              if (!root) {
+                return Promise.reject(new Error("[Module Federation] Cannot hydrate an island without a root element"));
+              }
+              let serverProps = {};
+              const encodedState = root.getAttribute && root.getAttribute("data-mf-island-state");
+              if (encodedState) {
+                try {
+                  serverProps = JSON.parse(decodeURIComponent(encodedState));
+                } catch {
+                  serverProps = {};
+                }
+              }
+              const finalProps = Object.assign({}, serverProps, props || {});
+              return Promise.all([import("react"), import("react-dom/client")]).then(([React, ReactDOMClient]) => {
+                if (typeof ReactDOMClient.hydrateRoot !== "function") {
+                  throw new Error("[Module Federation] react-dom/client does not provide hydrateRoot");
+                }
+                return ReactDOMClient.hydrateRoot(
+                  root,
+                  React.createElement(importModule.default, finalProps)
+                );
+              });
+            }
+          }`;
+}
+function generateReactIslandSSRDefinition(enabled) {
+	if (!enabled) return "";
+	return `
+          exportModule.__mf_island = {
+            version: 1,
+            async renderToHtml(props) {
+              if (typeof importModule.default !== "function" && typeof importModule.default !== "object") {
+                throw new Error("[Module Federation] A React island expose must have a default component export");
+              }
+              const loadedProps = typeof importModule.load === "function" ? await importModule.load() : {};
+              const finalProps = Object.assign({}, loadedProps || {}, props || {});
+              const [React, ReactDOMServer] = await Promise.all([
+                import("react"),
+                import("react-dom/server")
+              ]);
+              const body = ReactDOMServer.renderToString(
+                React.createElement(importModule.default, finalProps)
+              );
+              const state = encodeURIComponent(JSON.stringify(finalProps));
+              return '<div data-mf-island-state="' + state + '">' + body + '</div>';
+            },
+            hydrate() {
+              return Promise.reject(new Error("[Module Federation] hydrate is only available in the browser remote entry"));
+            }
+          }`;
+}
+const REACT_ISLAND_CLIENT_ID_PREFIX = "virtual:mf-react-island-client:";
+const REACT_ISLAND_SERVER_ID_PREFIX = "virtual:mf-react-island-server:";
+const RESOLVED_REACT_ISLAND_CLIENT_ID_PREFIX = `\0${REACT_ISLAND_CLIENT_ID_PREFIX}`;
+const RESOLVED_REACT_ISLAND_SERVER_ID_PREFIX = `\0${REACT_ISLAND_SERVER_ID_PREFIX}`;
+function encodeIslandRemoteId(remoteId) {
+	return encodeURIComponent(remoteId);
+}
+function decodeIslandRemoteId(encodedRemoteId) {
+	return decodeURIComponent(encodedRemoteId);
+}
+function getReactIslandImportRemoteId(source) {
+	const queryIndex = source.indexOf("?");
+	if (queryIndex === -1) return;
+	if (!new URLSearchParams(source.slice(queryIndex + 1)).has("mf-island")) return;
+	return source.slice(0, queryIndex);
 }
 function getReactIslandServerImportId(remoteId) {
 	return `${REACT_ISLAND_SERVER_ID_PREFIX}${encodeIslandRemoteId(remoteId)}`;
@@ -1741,328 +2124,59 @@ for (const __mfShareKey of Object.keys(__mfModuleCache.share)) {
     }
   }
 }
-`;
-}
-function getRuntimeInitPromiseBootstrapCode(enableSsrInit = false, ownerImportId, ssrRemotes, hostInitImportId = ownerImportId) {
-	return getRuntimeInitStateBootstrapCode({
-		globalKeyVar: "__mfPromiseGlobalKey",
-		stateVar: "__mfPromiseState",
-		exposedConst: "initPromise",
-		exposedProperty: "initPromise",
-		enableSsrInit,
-		ownerImportId,
-		hostInitImportId,
-		ssrRemotes
-	});
-}
-function getRuntimeInitResolveBootstrapCode(enableSsrInit = false, ownerImportId, ssrRemotes, hostInitImportId = ownerImportId) {
-	return getRuntimeInitStateBootstrapCode({
-		globalKeyVar: "__mfResolveGlobalKey",
-		stateVar: "__mfResolveState",
-		exposedConst: "initResolve",
-		exposedProperty: "initResolve",
-		enableSsrInit,
-		ownerImportId,
-		hostInitImportId,
-		ssrRemotes
-	});
-}
-function writeRuntimeInitStatus(command, enableSsrInit = false, hostInitImportId, options, ssrRemotes = _ssrRemotes) {
-	const exportStatement = command === "build" ? `const { initPromise, initResolve, initReject, moduleCache } = globalThis[globalKey];
-export { initPromise, initResolve, initReject, moduleCache };` : `module.exports = globalThis[globalKey];`;
-	const ownerImportId = options ? getRuntimeInitStatusImportId(options) : hostInitImportId;
-	getRuntimeInitModule(options).writeSync(`
-${getRuntimeInitBootstrapCode(enableSsrInit, ownerImportId, ssrRemotes, hostInitImportId)}
-${exportStatement}
-`);
-}
-//#endregion
-//#region src/plugins/pluginReactMixedModeGuard.ts
-function createReactMixedModeRuntimeGuard() {
-	return `const __mfReactInternals = mod["__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE"];
-if (__mfReactInternals && "A" in __mfReactInternals) {
-  let __mfReactDispatcher = __mfReactInternals.A;
-  Object.defineProperty(__mfReactInternals, "A", {
-    configurable: true,
-    enumerable: true,
-    get: () => __mfReactDispatcher,
-    set: (next) => {
-      if (next && typeof next.getOwner !== "function") next.getOwner = () => null;
-      __mfReactDispatcher = next;
-    },
-  });
-  __mfReactInternals.A = __mfReactDispatcher;
-}`;
-}
-//#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
-};
-const treeShakingStates = /* @__PURE__ */ new WeakMap();
-function getTreeShakingState(options) {
-	if (!options) return legacyTreeShakingState;
-	let state = treeShakingStates.get(options);
-	if (!state) {
-		state = {
-			inferredUsage: /* @__PURE__ */ new Map(),
-			buildMode: false
-		};
-		treeShakingStates.set(options, state);
-	}
-	return state;
-}
-function setTreeShakingBuildMode(enabled, options) {
-	getTreeShakingState(options).buildMode = enabled;
-}
-function resetTreeShakingExports(options) {
-	getTreeShakingState(options).inferredUsage.clear();
-}
-function getOrCreateExportRecord(sharedKey, request, options) {
-	const inferredUsage = getTreeShakingState(options).inferredUsage;
-	let byRequest = inferredUsage.get(sharedKey);
-	if (!byRequest) {
-		byRequest = /* @__PURE__ */ new Map();
-		inferredUsage.set(sharedKey, byRequest);
-	}
-	let record = byRequest.get(request);
-	if (!record) {
-		record = {
-			requiresFullBundle: false,
-			usedExports: /* @__PURE__ */ new Set()
-		};
-		byRequest.set(request, record);
-	}
-	return record;
-}
-function recordTreeShakingExports(sharedKey, exports, request = sharedKey, options) {
-	const record = getOrCreateExportRecord(sharedKey, request, options);
-	exports.forEach((name) => record.usedExports.add(name));
-}
-function markTreeShakingPackageUnsafe(sharedKey, request = sharedKey, options) {
-	getOrCreateExportRecord(sharedKey, request, options).requiresFullBundle = true;
-}
-function getExportRecords(sharedKey, request, options) {
-	const inferredUsage = getTreeShakingState(options).inferredUsage;
-	if (sharedKey) {
-		const records = inferredUsage.get(sharedKey);
-		const wildcard = records?.get("*");
-		const exact = records?.get(request);
-		return [wildcard, exact === wildcard ? void 0 : exact].filter((record) => !!record);
-	}
-	const records = [];
-	inferredUsage.forEach((byRequest, configuredKey) => {
-		const wildcard = byRequest.get("*");
-		const exact = byRequest.get(request);
-		const keyBase = configuredKey.endsWith("/") ? configuredKey.slice(0, -1) : configuredKey;
-		const requestMatchesConfiguredKey = request === keyBase || request.startsWith(`${keyBase}/`);
-		if (wildcard && requestMatchesConfiguredKey) records.push(wildcard);
-		if (exact && exact !== wildcard) records.push(exact);
-	});
-	return records;
-}
-/**
-* Return the analyzed requirement for one concrete shared request.
-*
-* Callers that know the configured share key should pass it explicitly. The
-* fallback lookup across keys keeps aliases/backwards-compatible callers
-* working, while still keeping each concrete request's exports isolated.
-*/
-function getSharedExportUsage(request, shareItem, sharedKey, options) {
-	const treeShaking = shareItem?.shareConfig.treeShaking;
-	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 result = new Set(configured);
-	records.forEach((record) => record.usedExports.forEach((name) => result.add(name)));
-	if (result.size > 0) return {
-		kind: "exports",
-		usedExports: [...result].sort()
-	};
-	return records.length > 0 ? {
-		kind: "exports",
-		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;
-	if (source.type === "Literal" && typeof source.value === "string") return source.value;
-	if (source.type === "StringLiteral" && typeof source.value === "string") return source.value;
-	if (source.type !== "TemplateLiteral") return void 0;
-	const expressions = Array.isArray(source.expressions) ? source.expressions : [];
-	const quasis = Array.isArray(source.quasis) ? source.quasis : [];
-	if (expressions.length > 0 || quasis.length !== 1) return void 0;
-	const value = quasis[0]?.value;
-	return typeof value?.cooked === "string" ? value.cooked : typeof value?.raw === "string" ? value.raw : void 0;
-}
-function getExportedName(node) {
-	if (!node || typeof node !== "object") return void 0;
-	const exported = node;
-	if (exported.type === "Identifier" && typeof exported.name === "string") return exported.name;
-	if ((exported.type === "Literal" || exported.type === "StringLiteral") && typeof exported.value === "string") return exported.value;
-}
-function isTypeOnly(node) {
-	return node.importKind === "type" || node.exportKind === "type";
-}
-function forEachAstNode(root, visit) {
-	const stack = [root];
-	const seen = /* @__PURE__ */ new Set();
-	while (stack.length > 0) {
-		const value = stack.pop();
-		if (!value || typeof value !== "object") continue;
-		if (seen.has(value)) continue;
-		seen.add(value);
-		if (Array.isArray(value)) {
-			for (let index = value.length - 1; index >= 0; index--) stack.push(value[index]);
-			continue;
-		}
-		const node = value;
-		if (typeof node.type === "string") visit(node);
-		Object.entries(node).forEach(([key, child]) => {
-			if (key !== "parent" && key !== "loc") stack.push(child);
-		});
-	}
-}
-function collectImportDeclaration(node, source, record, markUnsafe) {
-	if (isTypeOnly(node)) return;
-	const specifiers = Array.isArray(node.specifiers) ? node.specifiers : [];
-	if (specifiers.length === 0) {
-		markUnsafe(source);
-		return;
-	}
-	const names = [];
-	for (const specifier of specifiers) {
-		if (isTypeOnly(specifier)) continue;
-		if (specifier.type === "ImportNamespaceSpecifier") {
-			markUnsafe(source);
-			return;
-		}
-		if (specifier.type === "ImportDefaultSpecifier") {
-			names.push("default");
-			continue;
-		}
-		if (specifier.type === "ImportSpecifier") {
-			const imported = specifier.imported;
-			if (imported?.type === "Literal" || imported?.type === "StringLiteral") {
-				markUnsafe(source);
-				return;
-			}
-			const name = getExportedName(specifier.imported);
-			if (!name) {
-				markUnsafe(source);
-				return;
-			}
-			names.push(name);
-			continue;
-		}
-		markUnsafe(source);
-		return;
-	}
-	record(names, source);
-}
-function collectReExport(node, source, record, markUnsafe) {
-	if (isTypeOnly(node)) return;
-	if (node.type === "ExportAllDeclaration") {
-		markUnsafe(source);
-		return;
-	}
-	const specifiers = Array.isArray(node.specifiers) ? node.specifiers : [];
-	if (specifiers.length === 0) {
-		markUnsafe(source);
-		return;
-	}
-	const names = [];
-	for (const specifier of specifiers) {
-		if (isTypeOnly(specifier)) continue;
-		if (specifier.type !== "ExportSpecifier") {
-			markUnsafe(source);
-			return;
-		}
-		const local = specifier.local;
-		if (local?.type === "Literal" || local?.type === "StringLiteral") {
-			markUnsafe(source);
-			return;
-		}
-		const name = getExportedName(specifier.local);
-		if (!name) {
-			markUnsafe(source);
-			return;
-		}
-		names.push(name);
-	}
-	record(names, source);
+`;
 }
-/**
-* Collect the exports required by a consumer's ESM graph.
-*
-* Parsing the module avoids treating import-looking text in comments, strings,
-* templates, or regular expressions as real dependencies. If parsing fails,
-* 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.
-*/
-function collectTreeShakingImports(code, id, shared, findSharedKey, record, markUnsafe) {
-	const normalizedId = normalizePathForImport(id);
-	if (normalizedId.includes("__prebuild__") || normalizedId.includes("__loadShare__") || normalizedId.includes("__mf_tree_shaking_graph__")) return;
-	let ast;
-	try {
-		ast = parseAst(code);
-	} catch {
-		Object.entries(shared).forEach(([sharedKey, shareItem]) => {
-			if (shouldAnalyzeSharedExports(shareItem)) markUnsafe(sharedKey, "*");
-		});
-		return;
-	}
-	const matchShared = (source) => {
-		const sharedKey = findSharedKey(source, shared);
-		return sharedKey && shouldAnalyzeSharedExports(shared[sharedKey]) ? sharedKey : void 0;
-	};
-	const recordSource = (names, source) => {
-		const sharedKey = matchShared(source);
-		if (sharedKey) record(sharedKey, names, source);
-	};
-	const markSourceUnsafe = (source) => {
-		const sharedKey = matchShared(source);
-		if (sharedKey) markUnsafe(sharedKey, source);
-	};
-	forEachAstNode(ast, (node) => {
-		if (node.type === "ImportDeclaration") {
-			const source = getModuleSource(node.source);
-			if (source) collectImportDeclaration(node, source, recordSource, markSourceUnsafe);
-			return;
-		}
-		if ((node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") && node.source) {
-			const source = getModuleSource(node.source);
-			if (source) collectReExport(node, source, recordSource, markSourceUnsafe);
-			return;
-		}
-		if (node.type === "ImportExpression") {
-			const source = getModuleSource(node.source);
-			if (source) markSourceUnsafe(source);
-			return;
-		}
-		if (node.type === "CallExpression") {
-			const callee = node.callee;
-			const args = Array.isArray(node.arguments) ? node.arguments : [];
-			if (callee?.type === "Identifier" && callee.name === "require" && args.length > 0) {
-				const source = getModuleSource(args[0]);
-				if (source) markSourceUnsafe(source);
-			}
-		}
+function getRuntimeInitPromiseBootstrapCode(enableSsrInit = false, ownerImportId, ssrRemotes, hostInitImportId = ownerImportId) {
+	return getRuntimeInitStateBootstrapCode({
+		globalKeyVar: "__mfPromiseGlobalKey",
+		stateVar: "__mfPromiseState",
+		exposedConst: "initPromise",
+		exposedProperty: "initPromise",
+		enableSsrInit,
+		ownerImportId,
+		hostInitImportId,
+		ssrRemotes
+	});
+}
+function getRuntimeInitResolveBootstrapCode(enableSsrInit = false, ownerImportId, ssrRemotes, hostInitImportId = ownerImportId) {
+	return getRuntimeInitStateBootstrapCode({
+		globalKeyVar: "__mfResolveGlobalKey",
+		stateVar: "__mfResolveState",
+		exposedConst: "initResolve",
+		exposedProperty: "initResolve",
+		enableSsrInit,
+		ownerImportId,
+		hostInitImportId,
+		ssrRemotes
 	});
 }
+function writeRuntimeInitStatus(command, enableSsrInit = false, hostInitImportId, options, ssrRemotes = _ssrRemotes) {
+	const exportStatement = command === "build" ? `const { initPromise, initResolve, initReject, moduleCache } = globalThis[globalKey];
+export { initPromise, initResolve, initReject, moduleCache };` : `module.exports = globalThis[globalKey];`;
+	const ownerImportId = options ? getRuntimeInitStatusImportId(options) : hostInitImportId;
+	getRuntimeInitModule(options).writeSync(`
+${getRuntimeInitBootstrapCode(enableSsrInit, ownerImportId, ssrRemotes, hostInitImportId)}
+${exportStatement}
+`);
+}
+//#endregion
+//#region src/plugins/pluginReactMixedModeGuard.ts
+function createReactMixedModeRuntimeGuard() {
+	return `const __mfReactInternals = mod["__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE"];
+if (__mfReactInternals && "A" in __mfReactInternals) {
+  let __mfReactDispatcher = __mfReactInternals.A;
+  Object.defineProperty(__mfReactInternals, "A", {
+    configurable: true,
+    enumerable: true,
+    get: () => __mfReactDispatcher,
+    set: (next) => {
+      if (next && typeof next.getOwner !== "function") next.getOwner = () => null;
+      __mfReactDispatcher = next;
+    },
+  });
+  __mfReactInternals.A = __mfReactDispatcher;
+}`;
+}
 //#endregion
 //#region src/utils/typeArgumentScanner.ts
 function getTypeArgumentStartContext(source, start) {
@@ -2191,8 +2305,12 @@ function getPackageEsmEntryPath(pkg) {
 }
 const packageNamedExportsCache = /* @__PURE__ */ new Map();
 const sharedExportInspectionCache = /* @__PURE__ */ new Map();
+const sharedMutableExportsCache = /* @__PURE__ */ new Map();
 function invalidateSharedExportInspectionCache(filePath) {
-	if (!/(?:^|[/\\])node_modules(?:[/\\]|$)/.test(filePath)) sharedExportInspectionCache.clear();
+	if (!/(?:^|[/\\])node_modules(?:[/\\]|$)/.test(filePath)) {
+		sharedExportInspectionCache.clear();
+		sharedMutableExportsCache.clear();
+	}
 }
 const DEFAULT_SHARED_EXPORT_CONDITIONS = [
 	"browser",
@@ -2200,6 +2318,18 @@ const DEFAULT_SHARED_EXPORT_CONDITIONS = [
 	"module",
 	"default"
 ];
+function getSharedExportSource(source) {
+	const parts = [];
+	let offset = 0;
+	const codePositions = createCodePositionMap(source, (start, end) => {
+		parts.push(source.slice(offset, start), source.slice(start, end).replace(/[^\r\n\u2028\u2029]/g, " "));
+		offset = end;
+	});
+	return {
+		source: parts.length ? parts.join("") + source.slice(offset) : source,
+		codePositions
+	};
+}
 function hasCodeMatch(source, regex, codePositions) {
 	regex.lastIndex = 0;
 	let match;
@@ -2244,8 +2374,7 @@ function getMutableExportsFromFile(entryPath, exportConditions = DEFAULT_SHARED_
 	if (!entryPath || visited.has(entryPath)) return [];
 	visited.add(entryPath);
 	try {
-		const source = readFileSync(entryPath, "utf-8");
-		const codePositions = createCodePositionMap(source);
+		const { source, codePositions } = getSharedExportSource(readFileSync(entryPath, "utf-8"));
 		const mutableBindings = /* @__PURE__ */ new Set();
 		const mutableExports = /* @__PURE__ */ new Set();
 		let match;
@@ -2278,7 +2407,7 @@ function getMutableExportsFromFile(entryPath, exportConditions = DEFAULT_SHARED_
 				if (isValidEsmExportName(exported) && (mutableBindings.has(local) || reExportedMutable.has(local))) mutableExports.add(exported);
 			}
 		}
-		const starExportRegex = /export\s+\*\s+from\s+['"]([^'"]+)['"]/g;
+		const starExportRegex = /export\s*\*\s*from\s*['"]([^'"]+)['"]/g;
 		while ((match = starExportRegex.exec(source)) !== null) {
 			if (!codePositions[match.index]) continue;
 			const resolved = resolveReExportModule(entryPath, match[1], exportConditions);
@@ -2293,10 +2422,18 @@ function getMutableExportsFromFile(entryPath, exportConditions = DEFAULT_SHARED_
 }
 function getSharedMutableExports(pkg, shareItem, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
 	const configuredImport = shareItem?.shareConfig.import;
-	return getMutableExportsFromFile(typeof configuredImport === "string" ? resolveConfiguredImportPath(configuredImport, exportConditions) : getInstalledPackageEntry(pkg, {
+	const entryPath = typeof configuredImport === "string" ? resolveConfiguredImportPath(configuredImport, exportConditions) : getInstalledPackageEntry(pkg, {
 		conditions: exportConditions,
 		resolveSubpathWithRequire: false
-	}), exportConditions);
+	});
+	if (!entryPath) return [];
+	const cacheKey = `${entryPath}\0${exportConditions.join("\0")}`;
+	let mutableExports = sharedMutableExportsCache.get(cacheKey);
+	if (!mutableExports) {
+		mutableExports = getMutableExportsFromFile(entryPath, exportConditions);
+		sharedMutableExportsCache.set(cacheKey, mutableExports);
+	}
+	return mutableExports;
 }
 function resolveConfiguredImportPath(importSource, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
 	if (path$1.isAbsolute(importSource)) return resolveFileLikeModule(importSource);
@@ -2551,7 +2688,9 @@ function hasUnsupportedBindingPattern(source, start) {
 }
 function getNamedExportsViaRegex(source, filePath, visited, scanState = { complete: true }, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
 	const names = /* @__PURE__ */ new Set();
-	const codePositions = createCodePositionMap(source);
+	const inspected = getSharedExportSource(source);
+	source = inspected.source;
+	const codePositions = inspected.codePositions;
 	const recognizedExportStarts = /* @__PURE__ */ new Set();
 	visited = visited || /* @__PURE__ */ new Set();
 	if (filePath) visited.add(filePath);
@@ -2609,15 +2748,15 @@ function getNamedExportsViaRegex(source, filePath, visited, scanState = { comple
 			else if (name === "default" || name === "__esModule") {} else scanState.complete = false;
 		}
 	}
-	const namespaceReExportRegex = new RegExp(`export\\s+\\*\\s+as\\s+(${JS_IDENTIFIER_PATTERN})\\s+from\\s+['"][^'"]+['"]`, "gu");
+	const namespaceReExportRegex = new RegExp(`export\\s*\\*\\s*as\\s+(${JS_IDENTIFIER_PATTERN})\\s*from\\s*['"][^'"]+['"]`, "gu");
 	while ((match = namespaceReExportRegex.exec(source)) !== null) {
 		if (!codePositions[match.index]) continue;
 		recognizedExportStarts.add(match.index);
 		if (isValidEsmExportName(match[1])) names.add(match[1]);
 	}
-	if (hasCodeMatch(source, /export\s+\*\s+as\s+['"]/g, codePositions)) scanState.complete = false;
+	if (hasCodeMatch(source, /export\s*\*\s*as\s*['"]/g, codePositions)) scanState.complete = false;
 	if (filePath) {
-		const starExportRegex = /export\s+\*\s+from\s+['"]([^'"]+)['"]/g;
+		const starExportRegex = /export\s*\*\s*from\s*['"]([^'"]+)['"]/g;
 		while ((match = starExportRegex.exec(source)) !== null) {
 			if (!codePositions[match.index]) continue;
 			recognizedExportStarts.add(match.index);
@@ -2852,12 +2991,6 @@ function isSharedSingletonConsumedByPeer(pkg, options = getNormalizeModuleFedera
 	};
 	return Array.from(sharedKeyByPackageName.values()).some((sharedPkg) => sharedPkg !== pkg && reachesPkg(sharedPkg, /* @__PURE__ */ new Set([sharedPkg])));
 }
-function isRemoteOnlyContainer(options = getNormalizeModuleFederationOptions()) {
-	return Object.keys(options.exposes || {}).length > 0 && Object.keys(options.remotes || {}).length === 0;
-}
-function isLocalOnlyContainer(options = getNormalizeModuleFederationOptions()) {
-	return Object.keys(options.exposes || {}).length === 0 && Object.keys(options.remotes || {}).length === 0;
-}
 function tryResolveImportFromPackageRoot(pkg, root) {
 	try {
 		return resolveWorkspaceEsmEntry(pkg, createRequire$1(pathToFileURL(path$1.join(root, "package.json"))).resolve(pkg), root);
@@ -3378,11 +3511,10 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	const liveNamedExportLine = liveNamedExports.length ? `export { ${liveNamedExports.join(", ")} } from ${escapeGeneratedStringLiteral(sharedImportSource)};` : "";
 	const hasCompleteExportCoverage = detectedNamedExports !== void 0;
 	const isWorkspaceSingleton = isWorkspacePackage && shareItem.shareConfig.singleton === true;
-	const isDefaultShareScope = shareItem.scope === void 0 || shareItem.scope === "default" || Array.isArray(shareItem.scope) && shareItem.scope[0] === "default";
-	const usesDeferredSingletonFallback = hasCompleteExportCoverage && shareItem.shareConfig.eager !== true && (isWorkspacePackage || command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true || command === "build" && isRemoteOnlyContainer(resolvedOptions) && (shareItem.shareConfig.singleton === true || isDefaultShareScope) && !isSharedSingletonConsumedByPeer(pkg, resolvedOptions, true));
+	const usesDeferredSingletonFallback = hasCompleteExportCoverage && shareItem.shareConfig.eager !== true && (isWorkspacePackage || command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true || command === "build" && isRemoteContainer(resolvedOptions) && !isSharedSingletonConsumedByPeer(pkg, resolvedOptions, true));
 	const servesRemoteSingletonFallback = command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true;
 	const isConsumedByPeerSingleton = isSharedSingletonConsumedByPeer(pkg, resolvedOptions);
-	const usesEntryInjectedRemoteFallback = hasCompleteExportCoverage && !isWorkspaceSingleton && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true && resolvedOptions.hostInitInjectLocation === "entry" && (command === "build" || isConsumedByPeerSingleton);
+	const usesEntryInjectedRemoteFallback = hasCompleteExportCoverage && !isWorkspaceSingleton && isRemoteContainer(resolvedOptions) && shareItem.shareConfig.singleton === true && resolvedOptions.hostInitInjectLocation === "entry" && (command === "build" || isConsumedByPeerSingleton);
 	const usesEagerWorkspaceFallback = hasCompleteExportCoverage && isWorkspaceSingleton && !servesRemoteSingletonFallback && (isConsumedByPeerSingleton || shareItem.shareConfig.eager === true);
 	const usesDeferredTreeShakingFallback = hasCompleteExportCoverage && Boolean(treeShakingConsumer);
 	const reactMixedModeGuard = pkg === "react" ? createReactMixedModeRuntimeGuard() : "";
@@ -3566,6 +3698,7 @@ function generateLocalSharedImportMap(options) {
 	const useDirectReactImport = shouldUseDirectReactImport();
 	const orderedShares = getOrderedUsedShares(options);
 	const sharesToMaterialize = new Set(getMaterializedShares(options));
+	const hasConsumeOnlyShare = orderedShares.some((pkg) => getNormalizeShareItem(pkg, resolvedOptions)?.shareConfig.import === false);
 	return `
     import {loadShare} from "@module-federation/runtime";
     ${orderedShares.map((pkg, index) => {
@@ -3574,12 +3707,47 @@ function generateLocalSharedImportMap(options) {
 		return `import * as __mfEagerShare_${index} from ${toSafeJsLiteral(getLocalSharedPackagePath(pkg, shareItem, options))};`;
 	}).filter(Boolean).join("\n")}
     ${normalizeRuntimeShareCode}
+    const __mfGetCachedReactFamily = (keys, reactKeys, localVersion, requiredExport) => {
+      const cache = globalThis.__mf_module_cache__?.share;
+      const react = reactKeys.map((key) => cache?.[key]).find((value) => value !== undefined);
+      const reactVersion = react?.version ?? react?.default?.version;
+      const actual = String(reactVersion || '').split(/[^0-9]+/).map(Number);
+      const expected = String(localVersion || '').split(/[^0-9]+/).map(Number);
+      for (let index = 0; index < Math.max(actual.length, expected.length); index++) {
+        if ((actual[index] || 0) < (expected[index] || 0)) return undefined;
+        if ((actual[index] || 0) > (expected[index] || 0)) break;
+      }
+      for (const key of keys) {
+        const cached = cache?.[key];
+        if (cached === undefined) continue;
+        if (!requiredExport || typeof cached?.[requiredExport] === 'function' || typeof cached?.default?.[requiredExport] === 'function') return cached;
+      }
+      return undefined;
+    };
+    ${hasConsumeOnlyShare ? `// A consume-only share has no local module: its entry is the same shape for every key, so one helper builds it instead of a literal per key
+    const __mfHostOnly = (name) => async () => {
+      throw new Error(\`[Module Federation] Shared module '\${name}' must be provided by host\`);
+    };
+    const __mfConsumeOnly = (name, version, scope, materialize, shareConfig) => ({
+      name,
+      version,
+      scope: [scope],
+      loaded: false,
+      materialize,
+      eager: shareConfig.eager,
+      from: ${toSafeJsLiteral(resolvedOptions.name)},
+      canLiveRebind: true,
+      get: __mfHostOnly(name),
+      shareConfig: { ...shareConfig, import: false },
+    });` : ""}
     const importMap = {
       ${orderedShares.map((pkg, index) => {
 		const shareItem = getNormalizeShareItem(pkg, resolvedOptions);
+		if (shareItem?.shareConfig.import === false) return `
+        ${toSafeJsLiteral(pkg)}: __mfHostOnly(${toSafeJsLiteral(pkg)})`;
 		return `
         ${toSafeJsLiteral(pkg)}: async () => {
-          ${shareItem?.shareConfig.import === false ? `throw new Error(\`[Module Federation] Shared module '\${${toSafeJsLiteral(pkg)}}' must be provided by host\`);` : shareItem?.shareConfig.eager ? `let pkg = __mfEagerShare_${index};
+          ${shareItem?.shareConfig.eager ? `let pkg = __mfEagerShare_${index};
             return pkg;` : `let pkg = await import(${toSafeJsLiteral(getLocalSharedPackagePath(pkg, shareItem, options))});
             return pkg;`}
         }
@@ -3590,9 +3758,20 @@ function generateLocalSharedImportMap(options) {
       ${orderedShares.map((key) => {
 		const shareItem = getNormalizeShareItem(key, resolvedOptions);
 		if (!shareItem) return null;
+		const isReactFamily = key.startsWith("react/") || key === "react-dom/client";
+		const cacheKeys = [key, ...key === "react-dom/client" ? ["react-dom"] : []].flatMap((pkg) => {
+			const descriptor = getSharedCacheDescriptor(pkg, shareItem);
+			return [descriptor.canonical, ...descriptor.aliases ?? []];
+		});
+		const reactCacheKeys = ["react"].flatMap((pkg) => {
+			const descriptor = getSharedCacheDescriptor(pkg, shareItem);
+			return [descriptor.canonical, ...descriptor.aliases ?? []];
+		});
 		const detectedNamedExports = getSharedNamedExports(key, shareItem);
 		const canLiveRebind = shareItem.shareConfig.import === false || detectedNamedExports !== void 0;
 		const treeShakingConfig = canLiveRebind ? shareItem.shareConfig.treeShaking : void 0;
+		if (shareItem.shareConfig.import === false && !treeShakingConfig) return `
+          ${toSafeJsLiteral(key)}: __mfConsumeOnly(${toSafeJsLiteral(key)}, ${toSafeJsLiteral(shareItem.version)}, ${toSafeJsLiteral(shareItem.scope)}, ${sharesToMaterialize.has(key)}, {singleton: ${shareItem.shareConfig.singleton}, requiredVersion: ${toSafeJsLiteral(shareItem.shareConfig.requiredVersion)}, strictVersion: ${shareItem.shareConfig.strictVersion}, eager: ${Boolean(shareItem.shareConfig.eager)}})`;
 		const treeShakingUsage = treeShakingConfig ? getTreeShakingExportUsage(key, shareItem, shareItem.name, options) : void 0;
 		const treeShakingProviderExports = treeShakingUsage?.kind === "exports" ? treeShakingUsage.usedExports : [];
 		const treeShakingUsedExports = resolvedOptions.injectTreeShakingUsedExports === false ? treeShakingConfig?.usedExports || [] : treeShakingProviderExports;
@@ -3609,26 +3788,54 @@ function generateLocalSharedImportMap(options) {
             eager: ${Boolean(shareItem.shareConfig.eager)},
             from: ${toSafeJsLiteral(resolvedOptions.name)},
             canLiveRebind: ${canLiveRebind},
-            async get () {
+            get () {
               if (${shareItem.shareConfig.import === false}) {
                 throw new Error(\`[Module Federation] Shared module '\${${toSafeJsLiteral(key)}}' must be provided by host\`);
               }
-              usedShared[${toSafeJsLiteral(key)}].loaded = true
-              const {${toSafeJsLiteral(key)}: pkgDynamicImport} = importMap
-              const res = await pkgDynamicImport()
-              const exportModule = ${toSafeJsLiteral(useDirectReactImport)} && ${toSafeJsLiteral(key)} === "react"
-                ? (res?.default ?? res)
-                : __mfNormalizeRuntimeShare({...res})
-              // All npm packages pre-built by vite will be converted to esm
-              if (exportModule.__esModule !== true) {
-                Object.defineProperty(exportModule, "__esModule", {
-                  value: true,
-                  enumerable: false
-                })
-              }
-              return function () {
-                return exportModule
+              // A webpack consumer built with eager: true calls get() synchronously and needs the
+              // factory, not a promise: once the module is loaded, hand the same factory back directly,
+              // and while it is loading hand every caller the same pending promise.
+              const share = usedShared[${toSafeJsLiteral(key)}]
+              if (share.lib) return share.lib
+              if (share.loading) return share.loading
+              const cachedSingleton = ${shareItem.shareConfig.singleton && isReactFamily}
+                ? __mfGetCachedReactFamily(
+                    ${toSafeJsLiteral(cacheKeys)},
+                    ${toSafeJsLiteral(reactCacheKeys)},
+                    ${toSafeJsLiteral(shareItem.version)},
+                    ${toSafeJsLiteral(key === "react-dom/client" ? "createRoot" : void 0)}
+                  )
+                : undefined
+              if (cachedSingleton !== undefined) {
+                share.lib = function () { return cachedSingleton }
+                share.loaded = true
+                return share.lib
               }
+              share.loading = (async () => {
+                try {
+                  const {${toSafeJsLiteral(key)}: pkgDynamicImport} = importMap
+                  const res = await pkgDynamicImport()
+                  const exportModule = ${toSafeJsLiteral(useDirectReactImport)} && ${toSafeJsLiteral(key)} === "react"
+                    ? (res?.default ?? res)
+                    : __mfNormalizeRuntimeShare({...res})
+                  // All npm packages pre-built by vite will be converted to esm
+                  if (exportModule.__esModule !== true) {
+                    Object.defineProperty(exportModule, "__esModule", {
+                      value: true,
+                      enumerable: false
+                    })
+                  }
+                  share.lib = function () {
+                    return exportModule
+                  }
+                  share.loaded = true
+                  return share.lib
+                } finally {
+                  // A failed import must not pin the rejection: the next get() retries
+                  share.loading = undefined
+                }
+              })()
+              return share.loading
             },
             shareConfig: {
               singleton: ${shareItem.shareConfig.singleton},
@@ -3673,10 +3880,11 @@ function generateLocalSharedImportMap(options) {
       }
       `;
 }
-/** Expand `pkg/` → package root + matching usedShares; never returns the prefix string. */
+/** Expand `pkg/` → package root (if importable) + matching usedShares; never returns the prefix string. */
 function expandSharedPrefixKey(prefixKey, used) {
 	const base = prefixKey.slice(0, -1);
-	const expanded = /* @__PURE__ */ new Set([base]);
+	const baseImportable = isPackageInstalled(base) && isPackageExportAvailable(base);
+	const expanded = new Set(baseImportable ? [base] : []);
 	for (const pkg of used) {
 		if (pkg.endsWith("/")) continue;
 		if (pkg === base || pkg.startsWith(`${base}/`)) expanded.add(pkg);
@@ -3854,6 +4062,8 @@ const normalizeRuntimeShareCode = `const __mfNormalizeRuntimeShare = (mod) => {
           };`;
 const sharedProviderSelectionHelperCode = `const __mfOriginalProviderKey = Symbol("mf.originalSharedProvider");
           const __mfResolveShareHook = { emit: (params) => params };
+          const __mfGetShareScopeNames = (share) =>
+            Array.isArray(share.scope) ? share.scope : [share.scope || "default"];
           const __mfCreateProviderSelectionVersions = (versions, strategy) => {
             if (strategy !== "version-first") return versions;
             const selectionVersions = {};
@@ -3895,7 +4105,7 @@ const sharedProviderSelectionHelperCode = `const __mfOriginalProviderKey = Symbo
               Object.entries(versions).filter(([, provider]) => provider?.shareConfig?.import !== false)
             );
             if (Object.keys(candidates).length === 0) return undefined;
-            const scopes = Array.isArray(share.scope) ? share.scope : [share.scope || "default"];
+            const scopes = __mfGetShareScopeNames(share);
             const selectionVersions = __mfCreateProviderSelectionVersions(candidates, strategy);
             const shareScopeMap = {};
             for (const scope of scopes) {
@@ -4054,10 +4264,26 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy, options) {
           );
           return;
         }
-        const pendingExternalProvider = typeof __mfGetPendingExternalSharedProvider === 'function'
-          ? __mfGetPendingExternalSharedProvider(pkg, share)
+        const externalProvider = typeof __mfGetExternalSharedProvider === 'function'
+          ? __mfGetExternalSharedProvider(pkg, share)
           : undefined;
-        if (pendingExternalProvider && !pendingExternalProvider.lib && !pendingExternalProvider.loaded) {
+        if (externalProvider) {
+          let externalFactory = externalProvider.lib;
+          if (!externalFactory && externalProvider.loading) externalFactory = await externalProvider.loading;
+          if (!externalFactory && externalProvider.loaded && typeof externalProvider.get === 'function') {
+            externalFactory = await externalProvider.get();
+          }
+          if (externalFactory) {
+            const externalModule = typeof externalFactory === "function" ? externalFactory() : externalFactory;
+            const externalResolved = await Promise.resolve(externalModule);
+            ${normalizeRuntimeShareCode}
+            __mfWriteSharedCache(
+              __mfModuleCache.share,
+              cacheDescriptor,
+              __mfNormalizeRuntimeShare(externalResolved),
+              externalProvider.from
+            );
+          }
           return;
         }
         const providerKey = cacheDescriptor.canonical;
@@ -4339,10 +4565,10 @@ function generateTreeShakingSnapshotPluginCode(enabled) {
   });`;
 }
 function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(options), command = "build", exportConditions) {
-	const needsSharedProviderSelectionHelper = Object.keys(options.shared ?? {}).length > 0;
+	const needsSharedProviderSelectionHelper = hasShared(options);
 	const hasTreeShakingShared = Object.values(options.shared ?? {}).some((share) => !!share?.shareConfig.treeShaking);
 	const hasMultipleShareScopes = Array.isArray(options.shareScope);
-	const guardHostAutoInit = command === "build" && Object.keys(options.exposes ?? {}).length > 0 && Object.keys(options.remotes ?? {}).length > 0;
+	const guardHostAutoInit = command === "build" && isRemoteContainer(options) && hasRemotes(options);
 	const materializedShareBatches = toSafeJsLiteral(getShareBatches(options, false));
 	const runtimeImports = [
 		"init as runtimeInit",
@@ -4397,6 +4623,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   import {${runtimeImports}} from "@module-federation/runtime";
   ${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];"}
   ${getRuntimeModuleCacheBootstrapCode(exportConditions)}
   const initTokens = {}
@@ -4405,7 +4632,6 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   const mfName = ${toSafeJsLiteral(options.name)}
   const __mfMaterializedShareBatches = ${materializedShareBatches}
   let localSharedImportMapPromise
-  let exposesMapPromise
   let __mfLateBridgeShared
   const shouldRetrySharedInitError = ${command !== "build"} && ((error) => {
     const message = String((error && error.message) || error || '');
@@ -4439,12 +4665,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   }
 
   async function getExposesMap() {
-    if (!exposesMapPromise) {
-      exposesMapPromise = retrySharedInit(() => import("${virtualExposesId}"))
-        .then((mod) => mod.default ?? mod)
-        .catch((e) => { exposesMapPromise = undefined; throw e; });
-    }
-    return exposesMapPromise
+    return __mfExposesMap
   }
 
   async function init(shared = {}, initScope = [], remoteEntryInitOptions = {}) {
@@ -4560,29 +4781,33 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       const parts = pkg.split('/');
       return pkg.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0];
     };
-    const __mfGetPendingExternalSharedProvider = (pkg, share, versionMap) => {
+    const __mfGetExternalSharedProvider = (pkg, share, versionMap, includePackage) => {
       if (typeof __mfSelectExternalSharedProvider !== 'function') return undefined;
       const packageName = __mfGetSharePackageName(pkg);
-      const candidates = packageName === pkg
+      const candidates = !includePackage || packageName === pkg
         ? [[pkg, share]]
         : [[pkg, share], [packageName, usedShared[packageName]]];
       for (const [candidatePkg, candidateShare] of candidates) {
         if (!candidateShare) continue;
         const candidateVersionMap = versionMap
           ? (candidatePkg === pkg ? versionMap : initialShared[candidatePkg])
-          : ${hasMultipleShareScopes ? "getShareVersions(candidatePkg, candidateShare)" : "shared[candidatePkg]"};
+          : (initialShared[candidatePkg] ?? ${hasMultipleShareScopes ? "getShareVersions(candidatePkg, candidateShare)" : "shared[candidatePkg]"});
         const provider = __mfSelectExternalSharedProvider(
           candidateVersionMap,
           candidatePkg,
           candidateShare,
           '${options.shareStrategy}'
         );
-        if (provider && isWebpackProvider(provider) && !provider.lib && !provider.loaded) {
-          return provider;
-        }
+        if (provider) return provider;
       }
       return undefined;
     };
+    const __mfGetPendingExternalSharedProvider = (pkg, share, versionMap) => {
+      const provider = __mfGetExternalSharedProvider(pkg, share, versionMap, true);
+      return provider && isWebpackProvider(provider) && !provider.lib && !provider.loaded
+        ? provider
+        : undefined;
+    };
     // handling circular init calls before an external provider can re-enter this container
     ${hasMultipleShareScopes ? `const shareScopeNamesToInitialize = [];
     for (const shareScopeName of shareScopeNames) {
@@ -5320,7 +5545,28 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
 	const hostInitShareBatches = toSafeJsLiteral(getShareBatches(options, false));
 	const cacheOwner = toSafeJsLiteral(resolvedOptions.name);
 	const preferLocalVinextReact = hasPackageDependency("vinext") && (!exportConditions?.includes("browser") || exportConditions.includes("worker"));
+	const hasConfiguredShared = hasShared(resolvedOptions);
+	const hostInitSharedProviderHelperImport = shouldPreloadShares && hasConfiguredShared ? "import {share as runtimeShare} from \"@module-federation/runtime/helpers\";" : "";
+	const hostInitSharedProviderHelperCode = shouldPreloadShares && hasConfiguredShared ? `
+          ${sharedProviderSelectionHelperCode}
+          const __mfHasUsableProvider = (versions, pkg, share, scopeName) => {
+            // Keep runtime singleton negotiation unchanged. A singleton already
+            // registered in this scope is authoritative, even when runtime-core
+            // reports a version mismatch.
+            if (share.shareConfig?.singleton) {
+              return Object.values(versions || {}).some(
+                (provider) => provider?.shareConfig?.import !== false
+              );
+            }
+            return Boolean(__mfSelectSharedProvider(
+              versions,
+              pkg,
+              { ...share, scope: [scopeName] },
+              ${toSafeJsLiteral(resolvedOptions.shareStrategy)}
+            ));
+          };` : "";
 	return `
+    ${hostInitSharedProviderHelperImport}
     ${getRuntimeModuleCacheBootstrapCode(exportConditions)}
     let hostInitPromise;
     async function initHost() {
@@ -5334,12 +5580,13 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
           ${normalizeRuntimeShareCode}
           ${shouldPreloadShares ? `
           const __mfHasAlternativeSharedVersion = (pkg, share) =>
-            (Array.isArray(share.scope) ? share.scope : [share.scope || 'default']).some(
+            __mfGetShareScopeNames(share).some(
               (scopeName) => Object.keys(runtime.shareScopeMap?.[scopeName]?.[pkg] || {}).some(
                 (version) => version !== share.version
               )
             );
           const __mfHostInitShareBatches = ${hostInitShareBatches};
+          ${hostInitSharedProviderHelperCode}
           for (const __mfHostInitShareBatch of __mfHostInitShareBatches) {
             await Promise.all(__mfHostInitShareBatch.map(async (pkg) => {
               const share = usedShared[pkg];
@@ -5357,18 +5604,57 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
                       )`}
               ) return;
               // An import:false share has nothing to load until a foreign provider
-              // registers: its own stub getter throws by construction.
-              if (
-                share.shareConfig?.import === false &&
-                !(Array.isArray(share.scope) ? share.scope : [share.scope || 'default']).some((scopeName) =>
-                  Object.values(runtime.shareScopeMap?.[scopeName]?.[pkg] || {}).some(
-                    (provider) => provider?.shareConfig?.import !== false
-                  )
-                )
-              ) return;
+              // registers: its own stub getter throws by construction. A standalone
+              // container initialized on the same page keeps its providers in its
+              // own runtime scope (#1307), so adopt those before giving up.
+              if (share.shareConfig?.import === false) {
+                const __mfScopeNames = __mfGetShareScopeNames(share);
+                const __mfNeedsSiblingProvider = (scopeName) =>
+                  !__mfHasUsableProvider(
+                    runtime.shareScopeMap?.[scopeName]?.[pkg],
+                    pkg,
+                    share,
+                    scopeName
+                  );
+                if (__mfScopeNames.some(__mfNeedsSiblingProvider)) {
+                  // loadShare() re-runs initializeSharing(), which re-registers this
+                  // container's own stub and lets it displace an unloaded adopted
+                  // provider whenever this container's name sorts after the provider's
+                  // (#1311). Put the provider back: a stub never outranks a provider.
+                  if (!runtime.__mfKeepAdoptedProviders) {
+                    runtime.__mfKeepAdoptedProviders = true;
+                    runtime.sharedHandler?.hooks?.lifecycle?.afterRegisterShare?.on?.((args) => {
+                      const { shared, previousShared, registeredShared } = args || {};
+                      if (
+                        shared?.shareConfig?.import !== false ||
+                        registeredShared !== shared ||
+                        !previousShared ||
+                        previousShared.shareConfig?.import === false
+                      ) return;
+                      const versions = runtime.shareScopeMap?.[args.scope]?.[args.pkgName];
+                      if (versions && versions[shared.version] === shared) versions[shared.version] = previousShared;
+                    });
+                  }
+                  for (const instance of globalThis.__FEDERATION__?.__INSTANCES__ || []) {
+                    for (const scopeName of __mfScopeNames) {
+                      const versions = instance?.shareScopeMap?.[scopeName]?.[pkg];
+                      if (!__mfHasUsableProvider(versions, pkg, share, scopeName)) continue;
+                      if (!__mfNeedsSiblingProvider(scopeName)) continue;
+                      const target = (runtime.shareScopeMap[scopeName] ||= {})[pkg] ||= {};
+                      for (const [version, provider] of Object.entries(versions)) {
+                        if (provider?.shareConfig?.import === false) continue;
+                        if (target[version] && target[version].shareConfig?.import !== false) continue;
+                        target[version] = provider;
+                      }
+                    }
+                  }
+                }
+                if (__mfScopeNames.every(__mfNeedsSiblingProvider)) return;
+              }
               await runtime.loadShare(pkg, {
                 customShareInfo: { shareConfig: share.shareConfig }
               }).then(async (factory) => {
+                if (factory === false) return;
                 const mod = typeof factory === "function" ? factory() : factory;
                 let resolved = __mfNormalizeRuntimeShare(await Promise.resolve(mod));
                 ${preferLocalVinextReact ? `if (
@@ -5451,6 +5737,7 @@ function generatePendingSharesCode(command = "build", options) {
 	const pendingShareImports = command === "build" ? getMaterializedShares(options).filter((pkg) => {
 		const shareItem = getShareItemForPreload(pkg, resolvedOptions);
 		if (!shareItem || pkg.endsWith("/")) return false;
+		if (shareItem.shareConfig.eager) return false;
 		return shareItem.shareConfig.import !== false && !shareItem.shareConfig.treeShaking;
 	}).map((pkg) => `[${toSafeJsLiteral(pkg)}, () => import(${toSafeJsLiteral(getLoadShareModulePath(pkg, false, options))})]`) : [];
 	return `
@@ -5793,9 +6080,10 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
 	const devRuntimeBootstrap = `${getRuntimeInitBootstrapCode(enableSsrInit, getRuntimeInitStatusImportId(options), ssrRemotes, hostAutoInitPath, exportConditions)}
     const { initPromise, initResolve, initReject, moduleCache: __mfModuleCache } = globalThis[globalKey];`;
 	const importLine = command === "build" ? `${getRuntimeModuleCacheBootstrapCode(exportConditions)}
-    import { hostInitPromise as __mfHostInitPromise } from ${JSON.stringify(hostAutoInitPath)};` : `${devRuntimeBootstrap}
+    const __mfHostInitPromise = () => import(${JSON.stringify(hostAutoInitPath)})
+      .then((mod) => mod.hostInitPromise);` : `${devRuntimeBootstrap}
     ${command === "serve" && consumer !== "server" ? browserHostInitCode : ""}`;
-	const remoteLoadRuntimePromise = command === "build" ? "__mfHostInitPromise" : "initPromise";
+	const remoteLoadRuntimePromise = command === "build" ? "__mfHostInitPromise()" : "initPromise";
 	const remoteCacheKey = `${getRuntimeRemoteCachePrefix(options)}${id}`;
 	const remoteLoadFailureHandler = command === "build" ? `.catch((error) => {
             delete __mfModuleCache.remote[pendingKey];
@@ -5859,24 +6147,19 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
 }
 //#endregion
 //#region src/plugins/pluginAddEntry.ts
-const isPreloadableVirtualMfChunk = (name) => name.includes("virtual_mf") && !name.includes("__prebuild__") && !name.includes("__loadShare__");
+const isPreloadableVirtualMfChunk = (name) => name.includes("virtual_mf") && !name.includes("__prebuild__") && !name.includes("__loadShare__") && !name.includes("__loadRemote__");
 const HOST_INIT_PRELOAD_CHUNKS = [
 	(name) => name === "hostInit",
 	(name) => name === "remoteEntry",
-	(name) => name === "virtualExposes",
 	isPreloadableVirtualMfChunk,
 	(name) => name === "index"
 ];
 const isRemoteWarmupExcluded = (name) => name.includes("__prebuild__") || name.includes("__loadShare__");
-const REMOTE_ENTRY_WARMUP_CHUNKS = [
-	(name) => name === "hostInit",
-	(name) => name === "virtualExposes",
-	(name) => isPreloadableVirtualMfChunk(name) && !isRemoteWarmupExcluded(name)
-];
+const REMOTE_ENTRY_WARMUP_CHUNKS = [(name) => name === "hostInit", (name) => isPreloadableVirtualMfChunk(name) && !isRemoteWarmupExcluded(name)];
 function getChunksByFileName(bundle) {
 	return new Map(Object.values(bundle).filter((chunk) => chunk.type === "chunk").map((chunk) => [chunk.fileName, chunk]));
 }
-function collectPreloadChunkFiles(chunksByFileName, seeds, excludeFromClosure = (name) => name.includes("__prebuild__")) {
+function collectPreloadChunkFiles(chunksByFileName, seeds, excludeFromClosure = (name) => name.includes(PREBUILD_TAG)) {
 	const seenFiles = /* @__PURE__ */ new Set();
 	const files = [];
 	const queue = [...seeds];
@@ -5955,9 +6238,6 @@ if (typeof document !== 'undefined' && document.head) {
 function getFirstHtmlEntryFile(entryFiles) {
 	return entryFiles.find((file) => file.endsWith(".html"));
 }
-function stripQueryAndHash$1(file) {
-	return file.split(/[?#]/)[0];
-}
 function isReactRouterClientRouteInput(file) {
 	return /[?&]__react-router-build-client-route(?:[=&]|$)/.test(file);
 }
@@ -6008,6 +6288,7 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 	let emitFileId;
 	let pendingSharesEmitId;
 	let viteConfig;
+	let devServer;
 	let skipHtmlDevFallback = forceClientInjected ?? false;
 	let clientInjected = false;
 	let emittedFileName;
@@ -6081,9 +6362,31 @@ const __mfCurrentScript = document.currentScript;
 		const remoteSources = isLoadedFirstClientBuild ? Array.from(getPreloadRemotes(normalizedOptions)) : Object.keys(getUsedRemotesMap(federationOptions));
 		return Array.from(new Set(remoteSources.flatMap((remote) => {
 			const registration = getRemoteRegistration(remote, normalizedOptions.remotes, federationOptions);
-			return registration && (registration.type === "module" || registration.type === "esm") && /^(?:https?:)?\/\//.test(registration.entry) ? [registration.entry] : [];
+			return registration && (registration.type === "module" || registration.type === "esm") && /^(?:https?:)?\/\//.test(registration.entry) && !/\.json(?:[?#]|$)/i.test(registration.entry) ? [registration.entry] : [];
 		})));
 	}
+	async function warmupDevEntryGraph(entryUrl) {
+		const server = devServer;
+		if (!server) return;
+		const seen = /* @__PURE__ */ new Set();
+		const cacheDir = normalizePathForImport(server.config?.cacheDir ?? "").replace(/\/$/, "") + "/";
+		const visit = async (url) => {
+			if (seen.has(url)) return;
+			seen.add(url);
+			try {
+				await server.transformRequest(url);
+			} catch {
+				return;
+			}
+			const deps = [...(await server.moduleGraph.getModuleByUrl(url))?.importedModules ?? []].filter((dep) => {
+				if (!dep.file || dep.type !== "js" || !path$1.isAbsolute(dep.file)) return false;
+				const file = normalizePathForImport(dep.file);
+				return !file.includes("/node_modules/") && !file.startsWith(cacheDir);
+			});
+			await Promise.all(deps.map((dep) => visit(dep.url)));
+		};
+		await visit(entryUrl).catch(() => {});
+	}
 	function getBootstrapSource(initSrc, entrySrc, useSystemImportFallback = false, options) {
 		const importHelper = useSystemImportFallback ? `const __mfImport = (src) =>
   globalThis.System && typeof globalThis.System.import === 'function'
@@ -6109,7 +6412,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
   import(/* @vite-ignore */ __mfRemoteEntryPrefetchUrl).catch(() => {});
 }
 ` : "";
-		const sharedPreloadSources = _command === "serve" && waitsForInit && Object.keys(normalizedOptions.exposes || {}).length > 0 && Object.keys(normalizedOptions.remotes || {}).length === 0 && federationOptions ? Array.from(getUsedShares(federationOptions)).filter((pkg) => !pkg.endsWith("/")).filter((pkg) => {
+		const sharedPreloadSources = _command === "serve" && waitsForInit && isRemoteOnlyContainer(normalizedOptions) && federationOptions ? Array.from(getUsedShares(federationOptions)).filter((pkg) => !pkg.endsWith("/")).filter((pkg) => {
 			const shareItem = federationOptions.shared[pkg] || Object.entries(federationOptions.shared).find(([key]) => key.endsWith("/") && pkg.startsWith(key))?.[1];
 			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)));
@@ -6195,12 +6498,12 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 	}
 	function isFederationInternalVirtualId(id) {
 		const normalized = decodeViteId(id).replace(/^\0+/, "");
-		return normalized.includes("virtual:mf:") || /__(?:loadShare|prebuild|loadRemote)__/.test(normalized);
+		return normalized.includes("virtual:mf:") || normalized.startsWith("virtual:mf-") || /__(?:loadShare|prebuild|loadRemote)__/.test(normalized);
 	}
 	function isWorkspaceSourceId(id) {
 		const normalized = normalizeModuleId(decodeViteId(id));
 		if (normalized.startsWith("\0") || normalized.startsWith("virtual:")) return false;
-		const filePath = stripQueryAndHash$1(normalized);
+		const filePath = stripQueryAndHash(normalized);
 		if (filePath.startsWith("/@fs/")) return true;
 		if (!path$1.isAbsolute(filePath)) return false;
 		const root = normalizePathForImport(path$1.resolve(viteConfig.root));
@@ -6222,7 +6525,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 				ignoredHtmlScriptSources.add(match[1]);
 				continue;
 			}
-			const scriptSrc = stripQueryAndHash$1(match[1]);
+			const scriptSrc = stripQueryAndHash(match[1]);
 			if (/^(?:[a-z]+:)?\/\//i.test(scriptSrc)) continue;
 			addEntryFile(scriptSrc);
 			addEntryFile(scriptSrc.startsWith("/") ? path$1.resolve(viteConfig.root, scriptSrc.slice(1)) : path$1.resolve(path$1.dirname(htmlPath), scriptSrc));
@@ -6230,7 +6533,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 	}
 	function addEntryRemoteImports(entrySrc) {
 		if (!federationOptions || /^(?:[a-z]+:)?\/\//i.test(entrySrc)) return;
-		const file = path$1.resolve(viteConfig.root, stripQueryAndHash$1(entrySrc).replace(/^\//, ""));
+		const file = path$1.resolve(viteConfig.root, stripQueryAndHash(entrySrc).replace(/^\//, ""));
 		if (!fs$2.existsSync(file)) return;
 		const code = fs$2.readFileSync(file, "utf-8");
 		for (const source of findModuleImportSources(code)) {
@@ -6257,6 +6560,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			skipTransformIds = new Set(skipTransformFor.map(resolveProjectId));
 		},
 		configureServer(server) {
+			devServer = server;
 			server.middlewares.use((req, res, next) => {
 				const rawUrl = req.url?.split("#")[0] ?? "";
 				if (normalizeDevHtmlProxyId(rawUrl.split("?")[0]) === DEV_HTML_PROXY_PREFIX.slice(0, -1)) {
@@ -6266,9 +6570,12 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 					const entrySrc = params.get("entry");
 					if (initSrc && entrySrc) {
 						const withBase = (src) => viteConfig.base + src.replace(/^\//, "");
-						res.statusCode = 200;
-						res.setHeader("Content-Type", "application/javascript");
-						res.end(getBootstrapSource(withBase(initSrc), withBase(entrySrc)));
+						const source = getBootstrapSource(withBase(initSrc), withBase(entrySrc));
+						warmupDevEntryGraph(entrySrc).finally(() => {
+							res.statusCode = 200;
+							res.setHeader("Content-Type", "application/javascript");
+							res.end(source);
+						});
 						return;
 					}
 				}
@@ -6316,7 +6623,8 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			const initSrc = params.get("init");
 			const entrySrc = params.get("entry");
 			if (!initSrc || !entrySrc) return;
-			return getBootstrapSource(initSrc, entrySrc);
+			const source = getBootstrapSource(initSrc, entrySrc);
+			return warmupDevEntryGraph(entrySrc).then(() => source);
 		},
 		transform(code, id) {
 			if (id.includes("node_modules") || inject !== "html" || htmlFilePath) return;
@@ -6334,15 +6642,24 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 		configResolved(config) {
 			viteConfig = config;
 			skipTransformIds = new Set(skipTransformFor.map(resolveProjectId));
-			const ctx = this;
-			const envName = ctx != null && typeof ctx === "object" ? ctx["environment"] : void 0;
-			if (envName?.name && envName.name !== "client") return;
-			const inputOptions = getBuildInput(config);
+			const clientEnvironmentInputs = [];
+			for (const environment of Object.values(config.environments ?? {})) {
+				if (environment.consumer !== "client") continue;
+				const input = getBuildInput(environment);
+				if (!input) {
+					htmlFilePath ??= path$1.resolve(config.root, "index.html");
+					continue;
+				}
+				if (typeof input === "string") clientEnvironmentInputs.push(input);
+				else if (Array.isArray(input)) clientEnvironmentInputs.push(...input);
+				else clientEnvironmentInputs.push(...Object.values(input));
+			}
+			const inputOptions = clientEnvironmentInputs.length > 0 ? clientEnvironmentInputs : getBuildInput(config);
 			if (!inputOptions) htmlFilePath = path$1.resolve(config.root, "index.html");
 			else if (typeof inputOptions === "string") entryFiles = [resolveProjectId(inputOptions)];
 			else if (Array.isArray(inputOptions)) entryFiles = inputOptions.filter((input) => !isReactRouterClientRouteInput(String(input))).map(resolveProjectId);
 			else if (typeof inputOptions === "object") entryFiles = Object.values(inputOptions).filter((input) => !isReactRouterClientRouteInput(String(input))).map((input) => resolveProjectId(String(input)));
-			if (entryFiles.length > 0) htmlFilePath = getFirstHtmlEntryFile(entryFiles);
+			if (entryFiles.length > 0) htmlFilePath = getFirstHtmlEntryFile(entryFiles) ?? htmlFilePath;
 			if (config.command === "serve" && !htmlFilePath) {
 				const rootIndexHtml = path$1.resolve(config.root, "index.html");
 				if (fs$2.existsSync(rootIndexHtml)) htmlFilePath = rootIndexHtml;
@@ -6457,14 +6774,13 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 		},
 		transform(code, id) {
 			if (skipSvelteKitSsrBuild()) return;
+			if (viteConfig?.command === "build" && !waitsForInit) return;
 			if (isSvelteKitServerModule(id)) return;
 			if (hasEntryBootstrapParam(id)) return;
 			if (normalizeModuleId(id).endsWith(".html")) return;
 			const projectId = resolveProjectId(id);
 			if (skipTransformIds.has(projectId)) return;
-			const transformCtx = this;
-			const transformEnv = transformCtx != null && typeof transformCtx === "object" ? transformCtx["environment"] : void 0;
-			if (transformEnv?.name && transformEnv.name !== "client") return;
+			if (!isClientEnvironment(this)) return;
 			const isVinext = hasPackageDependency("vinext");
 			if (isVinext && inject === "html" && id.includes("virtual:vite-rsc/remove-duplicate-server-css")) {
 				const namespaceReactImport = `import * as React from 'react';`;
@@ -7252,7 +7568,7 @@ function pluginExternalRuntimeCore() {
 }
 //#endregion
 //#region package.json
-var version$1 = "1.21.6";
+var version$1 = "1.22.1";
 //#endregion
 //#region src/virtualModules/index.ts
 function initVirtualModules(command, remoteEntryId, enableSsrInit = false, options) {
@@ -7341,16 +7657,31 @@ const collectStaticChunks = (bundle, roots) => {
 };
 /**
 * Analyzes assets associated with a chunk without mutating the output map.
-* The static-import traversal is cycle-safe and ignores missing bundle entries.
+* Dynamic imports are collected transitively (a lazy route nested behind another
+* lazy route is still reachable), following both static and dynamic edges.
+* The traversal is cycle-safe and ignores missing bundle entries.
 */
 const analyzeChunkAssets = (bundle, fileName, chunk) => {
 	const dynamicAssets = [];
-	for (const currentChunk of collectStaticChunks(bundle, [fileName])) for (const dynamicImport of currentChunk.dynamicImports ?? []) {
-		if (!bundle[dynamicImport]) continue;
-		dynamicAssets.push({
-			fileName: dynamicImport,
-			type: isCSSFile(dynamicImport) ? "css" : "js"
-		});
+	const visited = /* @__PURE__ */ new Set([fileName]);
+	const queue = [fileName];
+	const enqueue = (imported) => {
+		if (visited.has(imported)) return;
+		visited.add(imported);
+		queue.push(imported);
+	};
+	for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
+		const currentChunk = bundle[queue[queueIndex]];
+		if (!currentChunk || currentChunk.type !== "chunk") continue;
+		for (const imported of currentChunk.imports ?? []) enqueue(imported);
+		for (const dynamicImport of currentChunk.dynamicImports ?? []) {
+			if (!bundle[dynamicImport]) continue;
+			dynamicAssets.push({
+				fileName: dynamicImport,
+				type: isCSSFile(dynamicImport) ? "css" : "js"
+			});
+			enqueue(dynamicImport);
+		}
 	}
 	return {
 		importedCss: Array.from(chunk.viteMetadata?.importedCss ?? []),
@@ -7699,8 +8030,38 @@ function collectImportedCss(chunks) {
 	for (const chunk of chunks) for (const cssFile of chunk.viteMetadata?.importedCss ?? []) css.add(cssFile);
 	return Array.from(css);
 }
-function expandExposeAssets(filesMap, exposeModules, bundle, remoteEntryFileName, options) {
+/**
+* Collects the virtual module ids of the `__loadShare__` wrappers belonging to shares
+* that are not eager.
+*
+* Such a wrapper resolves its share through the host at runtime, so it is a deferred
+* dependency even though the expose statically imports it. Advertising it as a sync
+* asset makes a preloader fetch a provider the host is going to supply anyway.
+*/
+function collectDeferredShareModules(options, isRolldown) {
+	const deferred = /* @__PURE__ */ new Set();
+	for (const shareKey of getUsedShares(options)) {
+		const shareConfig = getNormalizeShareItem(shareKey, options)?.shareConfig;
+		if (shareConfig?.eager === true) continue;
+		if (shareConfig?.import === false) continue;
+		deferred.add(normalizeVirtualModuleId(getLoadShareModulePath(shareKey, isRolldown, options)));
+	}
+	return deferred;
+}
+/**
+* True when the chunk exists to load a deferred share rather than expose code.
+*
+* `chunk.moduleIds` carry Rollup's `\0` virtual-module prefix while
+* `getLoadShareModulePath` returns the unprefixed id, so both sides are normalized —
+* the same comparison `isContainerBootstrapChunk` makes.
+*/
+function isDeferredShareChunk(chunk, deferredShareModules) {
+	if (!chunk || chunk.type !== "chunk" || deferredShareModules.size === 0) return false;
+	return [chunk.facadeModuleId, ...chunk.moduleIds ?? []].some((id) => typeof id === "string" && deferredShareModules.has(normalizeVirtualModuleId(id)));
+}
+function expandExposeAssets(filesMap, exposeModules, bundle, remoteEntryFileName, options, isRolldown) {
 	if (exposeModules.length === 0) return;
+	const deferredShareModules = collectDeferredShareModules(options, isRolldown);
 	const containerChunks = remoteEntryFileName ? collectStaticChunks(bundle, [remoteEntryFileName]) : [];
 	const bootstrapChunks = containerChunks.slice(1);
 	const seen = new Set(containerChunks.map((chunk) => chunk.fileName));
@@ -7721,11 +8082,13 @@ function expandExposeAssets(filesMap, exposeModules, bundle, remoteEntryFileName
 	for (const exposeModule of exposeModules) {
 		const assets = filesMap[exposeModule];
 		if (!assets) continue;
-		const syncChunks = collectStaticChunks(bundle, assets.js.sync);
+		const allSyncChunks = collectStaticChunks(bundle, assets.js.sync);
+		const syncChunks = allSyncChunks.filter((chunk) => !isDeferredShareChunk(chunk, deferredShareModules));
+		const deferredChunks = allSyncChunks.filter((chunk) => isDeferredShareChunk(chunk, deferredShareModules));
 		const sync = Array.from(/* @__PURE__ */ new Set([...bootstrapAssets, ...syncChunks.map((chunk) => chunk.fileName)]));
 		const syncSet = new Set(sync);
-		const asyncChunks = collectStaticChunks(bundle, assets.js.async);
-		const async = asyncChunks.map((chunk) => chunk.fileName).filter((fileName) => !syncSet.has(fileName));
+		const asyncChunks = [...collectStaticChunks(bundle, assets.js.async), ...deferredChunks];
+		const async = Array.from(new Set(asyncChunks.map((chunk) => chunk.fileName))).filter((fileName) => !syncSet.has(fileName));
 		assets.js.sync = sync;
 		assets.js.async = async;
 		const syncCss = Array.from(/* @__PURE__ */ new Set([
@@ -7901,17 +8264,28 @@ const Manifest = (providedOptions) => {
 					root,
 					stripKnownJsExtensions: true
 				});
-				expandExposeAssets(filesMap, exposesModules, bundle, foundRemoteEntryFile, mfOptions);
+				expandExposeAssets(filesMap, exposesModules, bundle, foundRemoteEntryFile, mfOptions, getIsRolldown(this));
 				const fileToShareKey = await buildFileToShareKeyMap(getUsedShares(mfOptions), this.resolve.bind(this), mfOptions);
 				processModuleAssets(Object.fromEntries(Object.entries(bundle).filter(([, file]) => !isTreeShakingProviderChunk(file))), filesMap, (modulePath) => fileToShareKey.get(modulePath));
+				const deferredSharedAssets = {
+					js: /* @__PURE__ */ new Set(),
+					css: /* @__PURE__ */ new Set()
+				};
 				for (const shareKey of getUsedShares(mfOptions)) {
 					const shareItem = getNormalizeShareItem(shareKey, mfOptions);
 					const assets = filesMap[shareKey];
 					if (!assets || shareItem?.shareConfig.eager === true) continue;
-					assets.js.async.push(...assets.js.sync.splice(0));
-					assets.css.async.push(...assets.css.sync.splice(0));
+					for (const type of ASSET_TYPES) {
+						assets[type].async.push(...assets[type].sync.splice(0));
+						for (const asset of assets[type].async) deferredSharedAssets[type].add(asset);
+					}
 				}
 				if (mfOptions.bundleAllCSS) addCssAssetsToAllExports(filesMap, allCssAssets);
+				for (const exposeModule of exposesModules) {
+					const assets = filesMap[exposeModule];
+					if (!assets) continue;
+					for (const type of ASSET_TYPES) for (const timing of LOAD_TIMINGS) assets[type][timing] = assets[type][timing].filter((asset) => !deferredSharedAssets[type].has(asset));
+				}
 				filesMap = deduplicateAssets(filesMap);
 			}
 			const manifest = await applyManifestAdditionalData(generateMFManifest(filesMap, disableAssetsAnalyze), void 0);
@@ -8438,21 +8812,6 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 	};
 }
 //#endregion
-//#region src/utils/remoteConsumerTarget.ts
-function getPluginEnvironmentName(ctx) {
-	if (ctx == null || typeof ctx !== "object") return void 0;
-	const environment = ctx["environment"];
-	if (environment == null || typeof environment !== "object") return void 0;
-	const name = environment["name"];
-	return typeof name === "string" ? name : void 0;
-}
-function resolveRemoteConsumer(ctx, hasMultiEnvironment) {
-	if (!hasMultiEnvironment) return "unified";
-	const envName = getPluginEnvironmentName(ctx);
-	if (!envName || envName === "client") return "client";
-	return "server";
-}
-//#endregion
 //#region src/plugins/pluginProxyRemotes.ts
 function isNodeModulesImporter(importer) {
 	return importer?.includes("/node_modules/") || importer?.includes("\\node_modules\\");
@@ -8532,6 +8891,81 @@ function pluginProxyRemotes_default(options) {
 	};
 }
 //#endregion
+//#region src/utils/sharedSource.ts
+/** 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 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);
+		for (const key of Object.keys(shared)) {
+			if (getPackageName(key) !== packageName) continue;
+			if (!key.endsWith("/")) candidates.add(key);
+			for (const subpath of getCommonSharedSubpaths(key)) if (findSharedKey(subpath, shared)) candidates.add(subpath);
+		}
+		if (candidates.size === 0) return;
+		const resolvedSource = await resolveEntry(source);
+		if (!resolvedSource) return;
+		for (const candidate of candidates) {
+			const entry = await resolveEntry(candidate);
+			if (!entry) continue;
+			if (normalizeNodeModulePath(entry) === normalizeNodeModulePath(resolvedSource) || getNodeModulesSuffix(entry) === suffix) return candidate;
+		}
+	}
+	return {
+		clear() {
+			caches.clear();
+		},
+		async resolve(context, source, options = {}) {
+			if (source.startsWith("\0") || source.includes("#")) return;
+			const queryIndex = source.indexOf("?");
+			const query = queryIndex === -1 ? "" : source.slice(queryIndex + 1);
+			if (query && [...new URLSearchParams(query).keys()].some((key) => ![
+				"v",
+				"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);
+			}
+			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;
+				try {
+					const resolved = await context.resolve(request, path$1.join(root, "package.json"), {
+						...options,
+						skipSelf: true,
+						custom: {
+							...options.custom,
+							__mfSharedEntryLookup: true
+						}
+					});
+					return resolved && !resolved.external ? resolved.id : void 0;
+				} catch {
+					return;
+				}
+			});
+			cache?.set(normalizedSource, result);
+			return result;
+		}
+	};
+}
+//#endregion
 //#region src/utils/PromiseStore.ts
 /**
 * example:
@@ -8581,23 +9015,6 @@ function isBuildConfigImporter(importer) {
 	if (!importer) return false;
 	return /(^|\/)(?:nuxt|vite|vitest|webpack|rollup|rspack)\.config\.[cm]?[jt]sx?$/.test(importer.replace(/\\/g, "/"));
 }
-function findSharedKeyForSource(source, shared) {
-	const key = findSharedKey(source, shared);
-	if (key) return key;
-	const explicitSharedSubpathKeys = Object.keys(shared || {}).filter((sharedKey) => getPackageName(sharedKey) !== sharedKey && !sharedKey.endsWith("/"));
-	if (isNodeModulePath(source)) {
-		const explicitSubpathKey = getMatchingNodeModuleSubpath(source, explicitSharedSubpathKeys);
-		if (explicitSubpathKey) return explicitSubpathKey;
-		const normalizedSource = normalizeNodeModulePath(source);
-		const explicitSubpathEntryKey = explicitSharedSubpathKeys.find((sharedKey) => {
-			const entry = getInstalledPackageEntry(sharedKey, { cwd: getPackageDetectionCwd() });
-			return entry ? normalizeNodeModulePath(entry) === normalizedSource : false;
-		});
-		if (explicitSubpathEntryKey) return explicitSubpathEntryKey;
-	}
-	const packageName = getPackageNameFromNodeModulePath(source);
-	return packageName ? findSharedKey(packageName, shared) : void 0;
-}
 /**
 * Reads the dependencies of an installed package from its package.json.
 */
@@ -8755,6 +9172,21 @@ function isSharedPackageDependency(sharedKey, dependency) {
 	}
 	return reachable.has(dependency);
 }
+function isConfiguredSharedPackage(pkg, shared) {
+	return Object.keys(shared).some((key) => getPackageName(key) === pkg);
+}
+function shouldKeepSharedImportLocal(source, importer, sharedKey, shared, importerPackage) {
+	if (!importer || shared[sharedKey]?.shareConfig.import === false) return false;
+	const prebuildImporter = importer.includes("__prebuild__") ? VirtualModule.findModule(PREBUILD_TAG, importer) : void 0;
+	const fallbackPackage = prebuildImporter ? getPackageName(prebuildImporter.name) : importerPackage;
+	if (!fallbackPackage || !isConfiguredSharedPackage(fallbackPackage, shared)) return false;
+	const sourcePackage = getPackageName(sharedKey);
+	if (fallbackPackage !== "react-dom" || sourcePackage !== "react") return false;
+	if (prebuildImporter && matchesSharedSource(source, prebuildImporter.name)) return false;
+	if (!isSharedPackageDependency(prebuildImporter?.name ?? fallbackPackage, sourcePackage)) return false;
+	if (isSharedPackageDependency(sharedKey, fallbackPackage)) return false;
+	return true;
+}
 const sharedRuntimeDependencyCache = /* @__PURE__ */ new Map();
 const SOURCE_FILE_RE = /\.(?:[cm]?js|[cm]?ts|jsx|tsx)$/;
 const NON_RUNTIME_SOURCE_RE = /(?:\.d\.[cm]?ts|\.(?:test|spec|stories)\.[cm]?[jt]sx?)$/;
@@ -8956,6 +9388,10 @@ function proxySharedModule(options) {
 			ssrTarget
 		});
 	};
+	const sharedSourceResolver = createSharedSourceResolver(shared, (context, resolveOptions) => ({
+		root: _config?.root || getPackageDetectionCwd(),
+		conditions: getRuntimeDependencyConditions(context, resolveOptions)
+	}));
 	const refreshTreeShakingForEnvironment = (context) => refreshTreeShakingModules(federationOptions, _command, getIsRolldown(context), getEnvironmentConditions(context));
 	const normalizeTreeShakingOutputPath = (value) => {
 		const normalized = normalizePathForImport(value);
@@ -9005,7 +9441,7 @@ function proxySharedModule(options) {
 					refreshTreeShakingForEnvironment(this);
 					const providerPackages = /* @__PURE__ */ new Set([...Object.keys(shared).filter((pkg) => !pkg.endsWith("/")), ...getUsedShares(federationOptions)]);
 					for (const pkg of providerPackages) {
-						const sharedKey = findSharedKeyForSource(pkg, shared);
+						const sharedKey = findSharedKey(pkg, shared);
 						const shareItem = shared[pkg] || (sharedKey ? shared[sharedKey] : void 0);
 						if (shareItem) emitTreeShakingProvider(this, pkg, shareItem);
 					}
@@ -9025,6 +9461,7 @@ function proxySharedModule(options) {
 				setTreeShakingBuildMode(command === "build", federationOptions);
 				resetTreeShakingExports(federationOptions);
 				emittedTreeShakingProviders.clear();
+				sharedSourceResolver.clear();
 				sharedDependencyCache.clear();
 				dependencyManifestCache.clear();
 				sharedRuntimeDependencyCache.clear();
@@ -9059,7 +9496,11 @@ function proxySharedModule(options) {
 				writeLocalSharedImportMap(federationOptions);
 				refreshHostAutoInit(federationOptions);
 			},
+			watchChange() {
+				sharedSourceResolver.clear();
+			},
 			buildStart() {
+				sharedSourceResolver.clear();
 				if (_command !== "build") return;
 				resetTreeShakingExports(federationOptions);
 				emittedTreeShakingProviders.clear();
@@ -9068,9 +9509,12 @@ function proxySharedModule(options) {
 			shouldTransformCachedModule() {
 				return _command === "build" && hasAnalyzableShares;
 			},
-			transform(code, id) {
+			async transform(code, id, transformOptions) {
 				if (_command !== "build" || !hasAnalyzableShares) return;
-				collectTreeShakingImports(code, id, shared, findSharedKeyForSource, (sharedKey, exports, request) => recordTreeShakingExports(sharedKey, exports, request, federationOptions), (sharedKey, request) => markTreeShakingPackageUnsafe(sharedKey, request, federationOptions));
+				await collectTreeShakingImports(code, id, shared, async (source, shares) => {
+					const request = await sharedSourceResolver.resolve(this, source, transformOptions);
+					return request ? findSharedKey(request, shares) : void 0;
+				}, (sharedKey, exports, request) => recordTreeShakingExports(sharedKey, exports, request, federationOptions), (sharedKey, request) => markTreeShakingPackageUnsafe(sharedKey, request, federationOptions));
 				refreshTreeShakingForEnvironment(this);
 			}
 		},
@@ -9079,6 +9523,7 @@ function proxySharedModule(options) {
 			enforce: "pre",
 			apply: "build",
 			async resolveId(source, importer, resolveOptions) {
+				if (resolveOptions.custom?.__mfSharedEntryLookup) return;
 				const sourceToken = getTreeShakingGraphToken(source);
 				const importerToken = getTreeShakingGraphToken(importer);
 				const token = sourceToken || importerToken;
@@ -9086,7 +9531,8 @@ function proxySharedModule(options) {
 				const cleanSource = normalizePathForImport(stripTreeShakingGraphQuery(source));
 				const cleanImporter = importer ? normalizePathForImport(stripTreeShakingGraphQuery(importer)) : void 0;
 				if (!sourceToken && importerToken) {
-					const nestedSharedKey = findSharedKeyForSource(cleanSource, shared);
+					const request = await sharedSourceResolver.resolve(this, cleanSource, resolveOptions);
+					const nestedSharedKey = request ? findSharedKey(request, shared) : void 0;
 					if (nestedSharedKey && getPackageName(nestedSharedKey) !== getPackageName(importerToken)) return this.resolve(cleanSource, cleanImporter, {
 						...resolveOptions,
 						skipSelf: true
@@ -9113,20 +9559,22 @@ function proxySharedModule(options) {
 			name: "proxyPreBuildShared:resolve-shared-loadShare",
 			enforce: "pre",
 			async resolveId(source, importer, resolveOptions) {
-				if (resolveOptions.custom?.__mfTreeShakingGraph) return;
-				function shouldSkipTaggedImporterProxy(sharedKey, tag) {
+				if (resolveOptions.custom?.__mfSharedEntryLookup || resolveOptions.custom?.__mfTreeShakingGraph) return;
+				const sharedSource = await sharedSourceResolver.resolve(this, source, resolveOptions);
+				if (!sharedSource) return;
+				const key = findSharedKey(sharedSource, shared);
+				if (!key) return;
+				const shouldSkipTaggedImporterProxy = (sharedKey, tag) => {
 					if (!importer?.includes(tag)) return false;
 					const taggedModule = VirtualModule.findModule(tag, importer);
 					if (!taggedModule) return true;
-					return taggedModule.name === sharedKey || matchesSharedSource(source, taggedModule.name);
-				}
-				const key = findSharedKeyForSource(source, shared);
-				if (!key) return;
+					return taggedModule.name === sharedKey || matchesSharedSource(sharedSource, taggedModule.name);
+				};
 				const importerPackage = getSharedPackageFromFile(importer, shared);
 				if (importerPackage === getPackageName(key)) return;
-				if (importerPackage) {
+				if (importerPackage && shared[key].shareConfig.import !== false) {
 					const importerIsUnsharedWorkspacePackage = !isNodeModulePath(importer) && !Object.keys(shared).some((sharedKey) => getPackageName(sharedKey) === importerPackage);
-					const runtimeDependencyRequest = key.endsWith("/") && matchesSharedSource(source, key) ? source : key;
+					const runtimeDependencyRequest = key.endsWith("/") && matchesSharedSource(sharedSource, key) ? sharedSource : key;
 					if (importerIsUnsharedWorkspacePackage ? isSharedPackageRuntimeDependency(runtimeDependencyRequest, importerPackage, getRuntimeDependencyConditions(this, resolveOptions)) : isSharedPackageDependency(key, importerPackage)) return;
 				}
 				if (useDirectReactImport && key === "react") return;
@@ -9137,7 +9585,11 @@ function proxySharedModule(options) {
 				if (importer && (importer.includes("hostAutoInit") || importer.includes("__H_A_I__"))) return;
 				if (shouldSkipTaggedImporterProxy(key, "__loadShare__")) return;
 				if (shouldSkipTaggedImporterProxy(key, "__prebuild__")) return;
-				const shareSource = key === "vue" && source.startsWith("vue/dist/") ? key : isNodeModulePath(source) ? getCommonSharedSubpathFromNodeModulePath(source, key) || key : source;
+				const shareSource = key === "vue" && sharedSource.startsWith("vue/dist/") ? key : sharedSource;
+				if (shouldKeepSharedImportLocal(sharedSource, importer, key, shared, importerPackage)) {
+					const localSource = getPrebuildResolutionSource(shareSource, shared[key]);
+					return tryResolveFromProjectRoot(localSource) || localSource;
+				}
 				const loadSharePath = getLoadShareModulePath(shareSource, useRolldown, federationOptions);
 				if (!materializedLoadShareSources.has(shareSource)) {
 					materializedLoadShareSources.add(shareSource);
@@ -9460,7 +9912,6 @@ function pluginRemoteNamedExports(options) {
 const MAX_RUNNER_BODY_BYTES = 1024 * 1024;
 const MAX_RUNNER_START_OFFSET = 1024 * 1024;
 const ALLOWED_RUNNER_INVOKE_NAMES = /* @__PURE__ */ new Set(["fetchModule", "getBuiltins"]);
-const VITE_FS_PREFIX = "/@fs/";
 function isPlainObject(value) {
 	return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -9479,12 +9930,6 @@ function isSafeRunnerFetchModuleOptions(value) {
 	}
 	return true;
 }
-function stripQueryAndHash(id) {
-	const queryIndex = id.indexOf("?");
-	const hashIndex = id.indexOf("#");
-	const endIndex = queryIndex === -1 ? hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
-	return endIndex === -1 ? id : id.slice(0, endIndex);
-}
 function decodeRunnerFilePath(filePath) {
 	try {
 		return decodeURIComponent(filePath);
@@ -9528,8 +9973,8 @@ function isSafeRunnerFetchModuleId(id, config) {
 	const cleanId = decodeRunnerFilePath(stripQueryAndHash(decoded));
 	if (!cleanId || hasRelativeTraversal(cleanId)) return false;
 	const allowedDirectories = getRunnerAllowedDirectories(config);
-	if (cleanId.startsWith(VITE_FS_PREFIX)) {
-		const fsPath = `/${cleanId.slice(5)}`;
+	if (cleanId.startsWith("/@fs/")) {
+		const fsPath = stripViteFsPrefix(cleanId);
 		return path$1.isAbsolute(fsPath) && isPathWithinAllowedDirectories(fsPath, allowedDirectories);
 	}
 	if (path$1.isAbsolute(cleanId)) {
@@ -9944,11 +10389,7 @@ var aliasToArrayPlugin_default = {
 };
 //#endregion
 //#region src/utils/controlChunkSanitizer.ts
-const FEDERATION_CONTROL_CHUNK_HINTS = [
-	"hostInit",
-	"virtualExposes",
-	"localSharedImportMap"
-];
+const FEDERATION_CONTROL_CHUNK_HINTS = ["hostInit", "localSharedImportMap"];
 function stripEmptyPreloadCalls(code) {
 	const helperImportRegex = /import\s*\{\s*_\s*as\s*([A-Za-z_$][\w$]*)\s*\}\s*from\s*["'][^"']+["']\s*;?/g;
 	const helperAliases = [];
@@ -10068,7 +10509,7 @@ function applyRuntimeCapabilityDefines(define, options, { defaultDisableSnapshot
 function getRuntimeCapabilityConfigurationWarnings(options) {
 	const warnings = [];
 	if (options.disableRemote && Object.keys(options.remotes).length > 0) warnings.push("disableRemote is true, but remotes are configured. Remote loading will be unavailable at runtime.");
-	if (options.disableShared && Object.keys(options.shared).length > 0) warnings.push("disableShared is true, but shared dependencies are configured. Shared dependency loading will be unavailable at runtime.");
+	if (options.disableShared && hasShared(options)) warnings.push("disableShared is true, but shared dependencies are configured. Shared dependency loading will be unavailable at runtime.");
 	return warnings;
 }
 //#endregion
@@ -10159,7 +10600,7 @@ function escapeUnsafeJsSourceChars(str) {
 }
 function isFederationHtmlPreloadDependency(dep, includeSharedRuntime = false) {
 	const file = path$1.basename(dep);
-	if (file.includes("__mfe_internal__") || file.includes("virtual_mf-") || file.includes("virtualExposes") || file.includes("localSharedImportMap") || file.includes("hostInit")) return true;
+	if (file.includes("__mfe_internal__") || file.includes("virtual_mf-") || file.includes("localSharedImportMap") || file.includes("hostInit")) return true;
 	return includeSharedRuntime && (file.includes("preload-helper") || file.includes("rolldown-runtime") || file.startsWith("dist-"));
 }
 function canResolveSharedSubpath(subpath, projectRoot) {
@@ -10379,6 +10820,7 @@ function createEarlyVirtualModulesPlugin(options) {
 			const resolvedConfiguredEntryFiles = (typeof buildInput === "string" ? [buildInput] : Array.isArray(buildInput) ? buildInput : buildInput && typeof buildInput === "object" ? Object.values(buildInput) : []).map((entry) => String(entry)).filter((entry) => !isReactRouterBuildClientRouteInput(entry)).map((entry) => entry.split(/[?#]/)[0]).map((entry) => path$1.isAbsolute(entry) ? entry : path$1.resolve(root, entry));
 			resetConcreteSharedImportSourceCache();
 			setPackageDetectionCwd(root);
+			resolveSharedVersions(shared, root);
 			const isVinext = hasPackageDependency("vinext");
 			initVirtualModules(_command, getRemoteEntryId(options), false, options);
 			const isRolldown = getIsRolldown(this);
@@ -10391,11 +10833,11 @@ function createEarlyVirtualModulesPlugin(options) {
 					config.optimizeDeps.exclude.push(...Object.keys(remotes || {}));
 				}
 			}
-			if (!config.build?.ssr && (Object.keys(shared ?? {}).length > 0 || Object.keys(remotes ?? {}).length > 0)) {
+			if (!config.build?.ssr && (hasShared(options) || hasRemotes(options))) {
 				const hasJsxSource = registerEntryImports(options, root, _command === "serve", resolvedConfiguredEntryFiles);
 				if (_command === "serve") hasClientJsxSource = hasJsxSource;
 			}
-			if (shared && Object.keys(shared).length > 0) {
+			if (hasShared(options)) {
 				if (_command === "serve") {
 					excludeSharedSubDependencies(shared);
 					config.optimizeDeps = config.optimizeDeps || {};
@@ -10568,9 +11010,7 @@ export default __mfShared.default ?? __mfShared;`
 				const automaticJsxRuntime = getAutomaticJsxRuntime(config);
 				if (automaticJsxRuntime && materializeAutomaticJsxRuntime(options, automaticJsxRuntime)) writeLocalSharedImportMap(options);
 			}
-			const viteMajor = parseInt(version, 10);
-			const hasRemotes = Object.keys(options.remotes).length > 0;
-			if (!getSsrCapabilities(viteMajor, config.command, hasRemotes).injectSsrEntryLoader) return;
+			if (!getSsrCapabilities(parseInt(version, 10), config.command, hasRemotes(options)).injectSsrEntryLoader) return;
 			if (options.runtimePlugins.some((p) => {
 				return (typeof p === "string" ? p : p[0]) === "@module-federation/vite/ssrEntryLoader";
 			})) return;
@@ -10597,7 +11037,10 @@ export default __mfShared.default ?? __mfShared;`
 			const ssrEntryLoaderSpecifier = SSR_ENTRY_LOADER_SPECIFIER;
 			try {
 				resolveImportPath(ssrEntryLoaderSpecifier);
-				options.runtimePlugins.push([ssrEntryLoaderSpecifier, { resolvedShared }]);
+				options.runtimePlugins.push([ssrEntryLoaderSpecifier, {
+					resolvedShared,
+					...options.ssrEntryLoader?.strategy ? { strategy: options.ssrEntryLoader.strategy } : {}
+				}]);
 			} catch {}
 		}
 	};
@@ -10613,7 +11056,7 @@ function applyBuildTimeRuntimeDefines(define, options, { target, isAstro, defaul
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-4sHIZPIi.js").then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-CQ088qGF.js").then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {
@@ -10638,7 +11081,6 @@ function resolveInjectExternalRuntimeCorePlugin() {
 function applyExternalRuntimeExperiments(options) {
 	const { experiments } = options;
 	if (experiments.provideExternalRuntime) {
-		if (Object.keys(options.exposes).length > 0) throw createModuleFederationError("You can only set provideExternalRuntime: true in pure consumer which not expose modules.");
 		if (!hasInjectExternalRuntimeCorePlugin(options.runtimePlugins)) options.runtimePlugins = options.runtimePlugins.concat(resolveInjectExternalRuntimeCorePlugin());
 	}
 }
@@ -10654,7 +11096,7 @@ function federation(mfUserOptions) {
 	const virtualExposesId = getVirtualExposesId(options);
 	const moduleParseController = createModuleParseController();
 	const moduleParsePlugins = pluginModuleParseEnd_default((id) => {
-		return id.includes(getHostAutoInitPath(options)) || id.includes(getPendingSharesPath(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__");
+		return id.includes(getHostAutoInitPath(options)) || id.includes(getPendingSharesPath(options)) || id.includes("virtual:mf-REMOTE_ENTRY_ID") || 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,
@@ -10795,6 +11237,7 @@ function federation(mfUserOptions) {
 				ssrTarget = config.ssr?.target ?? "node";
 				isProduction = config.isProduction;
 				const ssrCapabilities = getSsrCapabilities(parseInt(version, 10), command, Object.keys(options.remotes).length > 0);
+				resolveSharedVersions(shared, config.root);
 				initVirtualModules(command, remoteEntryId, ssrCapabilities.enableSsrInitBootstrap, options);
 			}
 		},
@@ -10829,11 +11272,6 @@ function federation(mfUserOptions) {
 			skipTransformFor: Object.values(options.exposes).map((expose) => expose.import),
 			federationOptions: options
 		}),
-		...addEntry({
-			entryName: "virtualExposes",
-			entryPath: virtualExposesId,
-			federationOptions: options
-		}),
 		pluginProxyRemoteEntry_default({
 			options,
 			remoteEntryId,
@@ -10857,6 +11295,10 @@ function federation(mfUserOptions) {
 				const runtimeInitId = getRuntimeInitStatusImportId(options);
 				config.build = config.build || {};
 				if (config.build.modulePreload !== false) {
+					const remoteEntryBasename = path$1.posix.basename(options.filename);
+					const hashParts = remoteEntryBasename.split(/\[hash(?::\d+)?\]/);
+					const remoteEntryFilePattern = new RegExp(`^${hashParts.map((part) => escapeRegExp(part)).join("[\\w-]+")}${hashParts.length > 1 && !/\.[^/.]+$/.test(remoteEntryBasename) ? "\\.js" : ""}$`);
+					const isRemoteEntryFile = (file) => file === remoteEntryBasename || remoteEntryFilePattern.test(file);
 					const currentModulePreload = config.build.modulePreload && typeof config.build.modulePreload === "object" ? config.build.modulePreload : {};
 					const existingResolveDependencies = currentModulePreload.resolveDependencies;
 					config.build.modulePreload = {
@@ -10864,7 +11306,7 @@ function federation(mfUserOptions) {
 						resolveDependencies(filename, deps, context) {
 							const resolvedDeps = existingResolveDependencies ? existingResolveDependencies(filename, deps, context) : deps;
 							const hostFile = path$1.basename(context.hostId);
-							if (context.hostType === "js" && (hostFile === options.filename || hostFile.includes("hostInit") || hostFile.includes("virtualExposes") || hostFile.includes("localSharedImportMap"))) return [];
+							if (context.hostType === "js" && (isRemoteEntryFile(hostFile) || hostFile.includes("hostInit") || hostFile.includes("localSharedImportMap"))) return [];
 							const hasFederationHtmlDeps = context.hostType === "html" && resolvedDeps.some((dep) => isFederationHtmlPreloadDependency(dep));
 							const hasFederationJsDeps = context.hostType === "js" && resolvedDeps.some((dep) => isFederationHtmlPreloadDependency(dep));
 							const treeShakingFallbackDeps = hasTreeShakingShared ? (dep) => dep.includes("__prebuild__") : () => false;
@@ -10903,6 +11345,10 @@ function federation(mfUserOptions) {
 					const mfChunkName = function(id) {
 						if (id.includes(runtimeInitId) || id.includes("__mf_v__runtimeInit__mf_v__")) return "runtimeInit";
 						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;
 							const match = id.match(/([^/\\]+__loadShare__[^/\\]+)/);
 							return match ? match[1] : "loadShare";
 						}
@@ -11011,8 +11457,8 @@ function federation(mfUserOptions) {
 					const virtualModule = VirtualModule.findById(id);
 					if (!virtualModule?.code) return null;
 					let code = virtualModule.code;
-					const environmentName = this.environment?.name;
-					if (environmentName && environmentName !== "client" || !environmentName && isSsrBuild) code = prependWorkspaceSingletonSsrImport(code);
+					const consumerTarget = resolveEnvironmentConsumerTarget(this);
+					if (consumerTarget === "server" || !consumerTarget && isSsrBuild) code = prependWorkspaceSingletonSsrImport(code);
 					code = code.replace(/import\s+["'][^"']*__prebuild__[^"']*["']\s*;?/g, "");
 					code = code.replace(/export\s+\*\s+from\s+["'][^"']*__prebuild__[^"']*["']\s*;?/g, "");
 					if (!(/\b(?:var|let|const)\s+__moduleExports\b/.test(code) || /\bexport\s+const\s+__moduleExports\b/.test(code) || /\bexport\s*\{[^}]*__moduleExports/.test(code))) {
@@ -11078,7 +11524,7 @@ function federation(mfUserOptions) {
 			config(config, { command: _command }) {
 				const isRolldown = getIsRolldown(this);
 				isSsrBuild = _command === "build" && Boolean(config.build?.ssr);
-				const needsRuntimeHelpers = Object.keys(options.shared ?? {}).length > 0;
+				const needsRuntimeHelpers = hasShared(options);
 				if (needsRuntimeHelpers) appendResolveAlias(config, {
 					find: /^@module-federation\/runtime\/helpers$/,
 					replacement: getRuntimeHelpersImplementation(options.implementation)