@module-federation/vite 1.22.0 → 1.23.0

package/lib/index.js

@@ -1,6 +1,6 @@
+import { _ as resolvePublicPath, a as matchesSharedSource, c as filterId, d as getNodeModulesSuffix, f as isAssetLikeImport, g as normalizeNodeModulePath, h as isViteOptimizableEntry, i as invalidateSharedKeyMatcher, l as getBasePath$1, m as isNuxtClientBase, n as getSharedRequest, p as isNodeModulePath, r as getSharedRuntimeKey, s as ensureTrailingSlash, t as findSharedKey, u as getCommonSharedSubpaths, v as stripQueryAndHash, y as stripViteFsPrefix } from "./sharedKeyMatcher-Od_nYxJA.js";
 import { 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-BEGrtvcw.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 { C as isReactCoreShare, E as mfWarn, S as REACT_DOM_CLIENT_SHARE, _ as resolveModulePath, a as getIsRolldown, b as supportsCodeSplittingGroupDebugName, c as getPackageNameFromNodeModulePath, d as isNuxtProjectRoot, f as isPackageExportAvailable, g as resolveImportPath, h as packageNameEncode, i as getInstalledPackageJson, l as getSharedCacheDescriptor, m as packageNameDecode, n as getDependencyNames, o as getPackageDetectionCwd, p as isPackageInstalled, r as getInstalledPackageEntry, s as getPackageName, u as hasPackageDependency, v as setPackageDetectionCwd, w as createModuleFederationError, x as REACT_CLIENT_INTERNALS_KEY, y as sharedCacheHelperCode } from "./dtsConstants-DEMpRfBz.js";
 import { createRequire } from "node:module";
 import * as fs$2 from "fs";
 import { existsSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "fs";
@@ -8,6 +8,7 @@ import { createRequire as createRequire$1, isBuiltin } from "module";
 import * as path$1 from "node:path";
 import path, { basename } from "node:path";
 import { fileURLToPath, pathToFileURL } from "url";
+import * as vite from "vite";
 import { parseAst, version } from "vite";
 import { createHash } from "node:crypto";
 import * as fs$1 from "node:fs";
@@ -400,6 +401,16 @@ function resolveEnvironmentConsumerTarget(ctx) {
 function isClientEnvironment(ctx) {
 	return resolveEnvironmentConsumerTarget(ctx) !== "server";
 }
+/**
+* Whether a build hook runs for a server graph. Vite 6+ hooks carry an
+* environment; Vite 5 (and hooks invoked before `configResolved`) fall back to
+* the legacy root `build.ssr` flag.
+*/
+function isServerBuildContext(ctx, config) {
+	const target = resolveEnvironmentConsumerTarget(ctx);
+	if (target) return target === "server";
+	return Boolean(config?.build?.ssr);
+}
 function resolveRemoteConsumer(ctx, hasMultiEnvironment) {
 	if (!hasMultiEnvironment) return "unified";
 	return resolveEnvironmentConsumerTarget(ctx) ?? "client";
@@ -431,7 +442,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;
@@ -449,6 +460,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 === "*") {
@@ -457,6 +469,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 === "`") {
@@ -762,8 +775,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) {
@@ -798,36 +811,93 @@ 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 (typeof shareItem === "object") {
+		const request = typeof shareItem.request === "string" ? shareItem.request : key;
+		const shareKey = typeof shareItem.shareKey === "string" ? shareItem.shareKey : key;
+		if (request.endsWith("/") !== shareKey.endsWith("/")) throw createModuleFederationError(`Invalid shared config for "${key}": "request" and "shareKey" must both end with "/" for a prefix share, or neither. Got request "${request}" and shareKey "${shareKey}".`);
+	}
 	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,
@@ -836,12 +906,17 @@ 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.request !== void 0 ? { request: shareItem.request } : {},
+			...shareItem.shareKey !== void 0 ? { shareKey: shareItem.shareKey } : {},
+			...shareItem.allowNodeModulesSuffixMatch !== void 0 ? { allowNodeModulesSuffixMatch: shareItem.allowNodeModulesSuffixMatch } : {},
 			...shareItem.suppressMissingImportWarning ? { suppressMissingImportWarning: true } : {},
 			...treeShaking ? { treeShaking: { ...treeShaking } } : {}
 		}
 	};
+	sharedVersionConfigs.set(result, { ...config });
+	return result;
 }
 /**
 * Trailing-slash keys are package namespace prefixes (`lodash/`, `@scope/ui/`).
@@ -885,7 +960,8 @@ function normalizeShared(shared) {
 		const value = shared[key];
 		const hadConfiguredPackageSubpath = (result[normalizedKey]?.shareConfig)?.__mfConfiguredPackageSubpath === true;
 		result[normalizedKey] = normalizeShareItem(normalizedKey, value);
-		if (key.endsWith("/") || hadConfiguredPackageSubpath) result[normalizedKey].shareConfig.__mfConfiguredPackageSubpath = true;
+		const requestIsPrefix = typeof value?.request === "string" && value.request.endsWith("/");
+		if (key.endsWith("/") || requestIsPrefix || hadConfiguredPackageSubpath) result[normalizedKey].shareConfig.__mfConfiguredPackageSubpath = true;
 		explicitSharedKeys.add(normalizedKey);
 		sourceEntries.push([normalizedKey, value]);
 	});
@@ -945,6 +1021,9 @@ function getNormalizeModuleFederationOptions() {
 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;
 }
@@ -958,7 +1037,13 @@ 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);
+	const shareItem = options.shared[key] || (matchedKey ? options.shared[matchedKey] : void 0) || options.shared[getPackageName(key)] || options.shared[getPackageName(key) + "/"];
+	if (shareItem) return shareItem;
+	return Object.entries(options.shared).find(([sharedKey, item]) => {
+		const runtimeKey = typeof item.shareConfig.shareKey === "string" ? item.shareConfig.shareKey : sharedKey;
+		return runtimeKey.endsWith("/") ? key === runtimeKey.slice(0, -1) || key.startsWith(runtimeKey) : runtimeKey === key;
+	})?.[1];
 }
 function normalizeModuleFederationOptions(options) {
 	warnOnReservedInternalNamePrefix(options.name, "containerName");
@@ -966,6 +1051,7 @@ function normalizeModuleFederationOptions(options) {
 	const normalized = {
 		exposes: normalizeExposes(options.exposes),
 		filename: options.filename || "remoteEntry-[hash]",
+		ssrFilename: options.ssrFilename || void 0,
 		internalName: toInternalModuleFederationName(options.name),
 		library: normalizeLibrary(options.library),
 		name: options.name,
@@ -1071,6 +1157,10 @@ var VirtualModule = class VirtualModule {
 		if (!cacheMap[this.tag]) cacheMap[this.tag] = {};
 		cacheMap[this.tag][this.name] = this;
 	}
+	/** The federation scope this module was created under, if it was scoped. */
+	getScopeName() {
+		return this.scopeName;
+	}
 	getImportId() {
 		const mfName = this.scopeName ?? getNormalizeModuleFederationOptions().internalName;
 		const importIdKey = `${mfName}${this.tag}${this.name}${this.tag}`;
@@ -1102,17 +1192,38 @@ const SERVER_ENV_GUARD = "import.meta.env.SSR";
 const SSR_ENTRY_LOADER_SPECIFIER = "@module-federation/vite/ssrEntryLoader";
 const SSR_ONLY_RUNTIME_PLUGINS = /* @__PURE__ */ new Set([SSR_ENTRY_LOADER_SPECIFIER]);
 /**
+* Whether a Vite environment builds a server graph.
+*
+* Vite 6+ sets `consumer` on the environment config; `build.ssr` covers the
+* legacy `vite build --ssr` flag. Environment names are user-defined, so `ssr`
+* and `server` are only a fallback for configs that carry neither field.
+*/
+function isServerEnvironment(name, config) {
+	return config?.consumer === "server" || Boolean(config?.build?.ssr) || name === "ssr" || name === "server";
+}
+/**
+* Whether a resolved Vite config includes a server graph: the legacy
+* `build.ssr` flag, or any server environment. Vite always registers an `ssr`
+* environment for `serve`, so this only gates builds.
+*/
+function isSsrConfig(config) {
+	if (Boolean(config.build?.ssr)) return true;
+	return Object.entries(config.environments ?? {}).some(([name, environment]) => isServerEnvironment(name, environment));
+}
+/**
 * Single source of truth for SSR-related feature gates.
 *
-* - Vite 8+ dev: ModuleRunner + FetchableDevEnvironment for `/__mf_ssr__/` entries.
-* - Any Vite major on build/preview: HTTP fetch + temp-file import via ssrEntryLoader.
+* - Vite 8+ server environments: ModuleRunner + FetchableDevEnvironment for
+*   `/__mf_ssr__/` entries.
+* - SSR builds on any Vite major: HTTP fetch + temp-file import via
+*   ssrEntryLoader.
 */
-function getSsrCapabilities(viteMajor, command, hasRemotes) {
+function getSsrCapabilities(viteMajor, command, hasRemotes, isSsr = false) {
 	if (!hasRemotes) return {
 		enableSsrInitBootstrap: false,
 		injectSsrEntryLoader: false
 	};
-	const supported = command === "build" || command === "serve" && viteMajor >= 8;
+	const supported = isSsr && (command === "build" || command === "serve" && viteMajor >= 8);
 	return {
 		enableSsrInitBootstrap: supported,
 		injectSsrEntryLoader: supported
@@ -1216,171 +1327,517 @@ 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];
-}
-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;
-		}
-	});
-}
-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$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);
+//#region src/utils/runtimePluginSpecifier.ts
+function getRuntimePluginSpecifier(plugin) {
+	return typeof plugin === "string" ? plugin : plugin[0];
 }
-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;
+/** Drop SSR-only plugins from a client graph; a server graph keeps them all. */
+function filterRuntimePluginsForTarget(runtimePlugins, ssrOnlySpecifiers, isServer) {
+	if (isServer) return [...runtimePlugins];
+	return runtimePlugins.filter((plugin) => !ssrOnlySpecifiers.has(getRuntimePluginSpecifier(plugin)));
 }
+//#endregion
+//#region src/utils/importAnalysis.ts
+const analysisByBuild = /* @__PURE__ */ new WeakMap();
 /**
-* 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.
+* Share source analysis within one build environment. Callers still resolve
+* requests and apply their own sharing configuration. Clear at buildStart and
+* buildEnd so watch rebuilds start fresh and completed builds release source.
 */
-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);
+function getImportAnalysis(build) {
+	let analysis = analysisByBuild.get(build);
+	if (!analysis) {
+		const importsByCode = /* @__PURE__ */ new Map();
+		analysis = {
+			analyze(code) {
+				const cached = importsByCode.get(code);
+				if (cached !== void 0) return cached;
+				const imports = analyzeImports(code);
+				importsByCode.set(code, imports);
+				return imports;
+			},
+			clear() {
+				importsByCode.clear();
+			}
+		};
+		analysisByBuild.set(build, analysis);
 	}
-	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 analysis;
 }
-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 isRecord(value) {
+	return value !== null && typeof value === "object";
 }
-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 getModuleSource(node) {
+	if (!isRecord(node)) 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 quasi = quasis[0];
+	if (!isRecord(quasi) || !isRecord(quasi.value)) return void 0;
+	const value = quasi.value;
+	return typeof value.cooked === "string" ? value.cooked : typeof value.raw === "string" ? value.raw : void 0;
 }
-function decodeIslandRemoteId(encodedRemoteId) {
-	return decodeURIComponent(encodedRemoteId);
+function getExportedName(node) {
+	if (!isRecord(node)) 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 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 isTypeOnly(node) {
+	return node.importKind === "type" || node.exportKind === "type";
 }
-function getReactIslandServerImportId(remoteId) {
-	return `${REACT_ISLAND_SERVER_ID_PREFIX}${encodeIslandRemoteId(remoteId)}`;
+function forEachAstNode(root, visit) {
+	const stack = [root];
+	const seen = /* @__PURE__ */ new Set();
+	while (stack.length > 0) {
+		const value = stack.pop();
+		if (!isRecord(value)) 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 getReactIslandClientImportId(remoteId) {
-	return `${REACT_ISLAND_CLIENT_ID_PREFIX}${encodeIslandRemoteId(remoteId)}`;
+function collectImportDeclaration(node, source, record, requireAllExports) {
+	if (isTypeOnly(node)) return;
+	const specifiers = Array.isArray(node.specifiers) ? node.specifiers : [];
+	if (specifiers.length === 0) {
+		requireAllExports(source);
+		return;
+	}
+	const names = [];
+	for (const specifier of specifiers) {
+		if (!isRecord(specifier)) {
+			requireAllExports(source);
+			return;
+		}
+		if (isTypeOnly(specifier)) continue;
+		if (specifier.type === "ImportNamespaceSpecifier") {
+			requireAllExports(source);
+			return;
+		}
+		if (specifier.type === "ImportDefaultSpecifier") {
+			names.push("default");
+			continue;
+		}
+		if (specifier.type === "ImportSpecifier") {
+			const imported = specifier.imported;
+			if (isRecord(imported) && (imported.type === "Literal" || imported.type === "StringLiteral")) {
+				requireAllExports(source);
+				return;
+			}
+			const name = getExportedName(specifier.imported);
+			if (!name) {
+				requireAllExports(source);
+				return;
+			}
+			names.push(name);
+			continue;
+		}
+		requireAllExports(source);
+		return;
+	}
+	record(names, source);
 }
-function resolveReactIslandConsumerId(id) {
-	if (id.startsWith("virtual:mf-react-island-server:")) return `\0${id}`;
-	if (id.startsWith("virtual:mf-react-island-client:")) return `\0${id}`;
+function collectReExport(node, source, record, requireAllExports) {
+	if (isTypeOnly(node)) return;
+	if (node.type === "ExportAllDeclaration") {
+		requireAllExports(source);
+		return;
+	}
+	const specifiers = Array.isArray(node.specifiers) ? node.specifiers : [];
+	if (specifiers.length === 0) {
+		requireAllExports(source);
+		return;
+	}
+	const names = [];
+	for (const specifier of specifiers) {
+		if (!isRecord(specifier)) {
+			requireAllExports(source);
+			return;
+		}
+		if (isTypeOnly(specifier)) continue;
+		if (specifier.type !== "ExportSpecifier") {
+			requireAllExports(source);
+			return;
+		}
+		const local = specifier.local;
+		if (isRecord(local) && (local.type === "Literal" || local.type === "StringLiteral")) {
+			requireAllExports(source);
+			return;
+		}
+		const name = getExportedName(specifier.local);
+		if (!name) {
+			requireAllExports(source);
+			return;
+		}
+		names.push(name);
+	}
+	record(names, source);
+}
+function analyzeImports(code) {
+	let ast;
+	try {
+		ast = vite.parseAst(code);
+	} catch {
+		return null;
+	}
+	const imports = [];
+	const recordSource = (names, source) => imports.push({
+		source,
+		usedExports: names
+	});
+	const requireAllExports = (source) => imports.push({
+		source,
+		usedExports: null
+	});
+	const collectImport = (node) => {
+		if (node.type === "ImportDeclaration") {
+			const source = getModuleSource(node.source);
+			if (source) collectImportDeclaration(node, source, recordSource, requireAllExports);
+			return;
+		}
+		if ((node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") && node.source) {
+			const source = getModuleSource(node.source);
+			if (source) collectReExport(node, source, recordSource, requireAllExports);
+			return;
+		}
+		if (node.type === "ImportExpression") {
+			const source = getModuleSource(node.source);
+			if (source) requireAllExports(source);
+			return;
+		}
+		if (node.type === "CallExpression") {
+			const callee = node.callee;
+			const args = Array.isArray(node.arguments) ? node.arguments : [];
+			if (isRecord(callee) && callee.type === "Identifier" && callee.name === "require" && args.length > 0) {
+				const source = getModuleSource(args[0]);
+				if (source) requireAllExports(source);
+			}
+		}
+	};
+	if ("Visitor" in vite && typeof vite.Visitor === "function") {
+		const visit = (node) => {
+			if (isRecord(node)) collectImport(node);
+		};
+		try {
+			new vite.Visitor({
+				ImportDeclaration: visit,
+				ExportNamedDeclaration: visit,
+				ExportAllDeclaration: visit,
+				ImportExpression: visit,
+				CallExpression: visit
+			}).visit(ast);
+			return imports;
+		} catch {
+			imports.length = 0;
+		}
+	}
+	forEachAstNode(ast, collectImport);
+	return imports;
+}
+//#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 configuredRequest = getSharedRequest(configuredKey, options?.shared?.[configuredKey]);
+		const keyBase = configuredRequest.endsWith("/") ? configuredRequest.slice(0, -1) : configuredRequest;
+		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);
+}
+/**
+* Record consumer imports against this instance's sharing configuration.
+* Generated wrappers do not contribute consumer usage. If parsing fails,
+* every share enabled for analysis requires all of its exports.
+*/
+async function collectTreeShakingImports(code, id, shared, findSharedKey, record, markUnsafe, analysis = getImportAnalysis(shared)) {
+	const normalizedId = normalizePathForImport(id);
+	if (normalizedId.includes("__prebuild__") || normalizedId.includes("__loadShare__") || normalizedId.includes("__mf_tree_shaking_graph__")) return;
+	const imports = analysis.analyze(code);
+	if (imports === null) {
+		Object.entries(shared).forEach(([sharedKey, shareItem]) => {
+			if (shouldAnalyzeSharedExports(shareItem)) markUnsafe(sharedKey, "*");
+		});
+		return;
+	}
+	const pending = [];
+	for (const { source, usedExports } of imports) {
+		const apply = (key) => {
+			if (!key || !shouldAnalyzeSharedExports(shared[key])) return;
+			if (usedExports === null) markUnsafe(key, source);
+			else record(key, usedExports, source);
+		};
+		const key = findSharedKey(source, shared);
+		if (key instanceof Promise) pending.push(key.then(apply));
+		else apply(key);
+	}
+	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)}`;
+}
+function getReactIslandClientImportId(remoteId) {
+	return `${REACT_ISLAND_CLIENT_ID_PREFIX}${encodeIslandRemoteId(remoteId)}`;
+}
+function resolveReactIslandConsumerId(id) {
+	if (id.startsWith("virtual:mf-react-island-server:")) return `\0${id}`;
+	if (id.startsWith("virtual:mf-react-island-client:")) return `\0${id}`;
 }
 function remoteIdFromResolvedIslandId(id, prefix) {
 	if (!id.startsWith(prefix)) return;
@@ -1832,7 +2289,7 @@ ${exportStatement}
 //#endregion
 //#region src/plugins/pluginReactMixedModeGuard.ts
 function createReactMixedModeRuntimeGuard() {
-	return `const __mfReactInternals = mod["__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE"];
+	return `const __mfReactInternals = mod[${JSON.stringify(REACT_CLIENT_INTERNALS_KEY)}];
 if (__mfReactInternals && "A" in __mfReactInternals) {
   let __mfReactDispatcher = __mfReactInternals.A;
   Object.defineProperty(__mfReactInternals, "A", {
@@ -1842,279 +2299,10 @@ if (__mfReactInternals && "A" in __mfReactInternals) {
     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);
-			}
-		}
-	});
+    },
+  });
+  __mfReactInternals.A = __mfReactDispatcher;
+}`;
 }
 //#endregion
 //#region src/utils/typeArgumentScanner.ts
@@ -2191,6 +2379,77 @@ function findLikelyTypeArgumentEnd(source, start, codePositions) {
 	}
 }
 //#endregion
+//#region src/virtualModules/shareTags.ts
+const LOAD_SHARE_TAG = "__loadShare__";
+/** A share's local copy. Reachable only through `import()`, so it stays lazy. */
+const PREBUILD_TAG = "__prebuild__";
+//#endregion
+//#region src/virtualModules/loadShareSharedChunk.ts
+const HELPERS_MODULE_NAME = "loadShareHelpers";
+const HELPERS_MODULE_TAG = "__mf_v__";
+const HELPERS_MODULE_MARKER = `${HELPERS_MODULE_TAG}${HELPERS_MODULE_NAME}${HELPERS_MODULE_TAG}`;
+const SHARED_CHUNK_SUFFIX = `${LOAD_SHARE_TAG}shared`;
+const HELPER_EXPORT_LIST = [
+	"__mfGetSharedCacheDescriptor",
+	"__mfReadSharedCache",
+	"__mfSharedCacheListenersKey",
+	"__mfGetSharedCacheListeners",
+	"__mfSubscribeSharedCache",
+	"__mfSharedCacheOwnersKey",
+	"__mfGetSharedCacheOwners",
+	"__mfReadSharedCacheOwner",
+	"__mfGetSharedModuleIdentity",
+	"__mfIsSameSharedModule",
+	"__mfWriteSharedCache",
+	"__mfTreeShakingSharedCacheKey",
+	"__mfGetTreeShakingSharedCache",
+	"__mfReadTreeShakingSharedCache",
+	"__mfWriteTreeShakingSharedCache",
+	"__mfTreeShakingSelectionCacheKey",
+	"__mfGetTreeShakingSelectionCache",
+	"__mfReadTreeShakingSharedSelection",
+	"__mfWriteTreeShakingSharedSelection"
+].join(", ");
+const helperModules = /* @__PURE__ */ new WeakMap();
+function getSharedCacheHelpersModule(options) {
+	let module = helperModules.get(options);
+	if (!module) {
+		module = new VirtualModule(HELPERS_MODULE_NAME, HELPERS_MODULE_TAG, "", getFederationScopeKey(options));
+		module.writeSync(`${sharedCacheHelperCode}\nexport { ${HELPER_EXPORT_LIST} };`);
+		helperModules.set(options, module);
+	}
+	return module;
+}
+function getSharedCacheHelpersImportCode(options) {
+	const importId = getSharedCacheHelpersModule(options).getImportId();
+	return `import { ${HELPER_EXPORT_LIST} } from ${JSON.stringify(importId)};`;
+}
+function isSharedCacheHelpersId(id) {
+	return id.includes(HELPERS_MODULE_MARKER);
+}
+function getSharedChunkName(id) {
+	const ownerTag = isSharedCacheHelpersId(id) ? HELPERS_MODULE_MARKER : LOAD_SHARE_TAG;
+	return `${id.slice(0, id.indexOf(ownerTag))}${SHARED_CHUNK_SUFFIX}`;
+}
+function isSharedChunk(chunk) {
+	return chunk.name?.endsWith(SHARED_CHUNK_SUFFIX) ?? false;
+}
+/**
+* Fallbacks inlined into a shared chunk, which means they are no longer lazy.
+* Only inlined modules count: a shared chunk also imports fallback chunks with
+* the experiment off, because Rolldown hoists its runtime helpers into whichever
+* chunk first uses them.
+*/
+function findEagerFallbacksInSharedChunk(bundle) {
+	const offenders = /* @__PURE__ */ new Map();
+	for (const [fileName, chunk] of Object.entries(bundle)) {
+		if (chunk.type !== "chunk" || !isSharedChunk(chunk)) continue;
+		const inlined = Object.keys(chunk.modules ?? {}).filter((id) => id.includes(PREBUILD_TAG));
+		if (inlined.length > 0) offenders.set(fileName, inlined);
+	}
+	return offenders;
+}
+//#endregion
 //#region src/virtualModules/virtualShared_preBuild.ts
 /**
 * Even the resolveId hook cannot interfere with vite pre-build,
@@ -2226,7 +2485,7 @@ function isValidEsmExportName(name) {
 const JS_IDENTIFIER_PATTERN = `[\$_\\p{ID_Start}][\$_\\u200C\\u200D\\p{ID_Continue}]*`;
 function resolvePackageEntryFromProjectRoot(pkg) {
 	try {
-		return createRequire$1(pathToFileURL(path$1.join(getPackageDetectionCwd(), "package.json"))).resolve(pkg);
+		return resolveModulePath(pkg, path$1.join(getPackageDetectionCwd(), "package.json"));
 	} catch {
 		return;
 	}
@@ -2257,6 +2516,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;
@@ -2301,8 +2572,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;
@@ -2373,7 +2643,7 @@ function resolveConfiguredImportPath(importSource, exportConditions = DEFAULT_SH
 	});
 	if (esmEntry) return esmEntry;
 	try {
-		return createRequire$1(pathToFileURL(path$1.join(projectRoot, "package.json"))).resolve(importSource);
+		return resolveModulePath(importSource, path$1.join(projectRoot, "package.json"));
 	} catch {
 		return;
 	}
@@ -2428,7 +2698,7 @@ function resolveReExportModule(filePath, specifier, exportConditions) {
 	});
 	if (esmEntry) return esmEntry;
 	try {
-		return resolveFileLikeModule(createRequire$1(pathToFileURL(filePath)).resolve(specifier));
+		return resolveFileLikeModule(resolveModulePath(specifier, filePath));
 	} catch {
 		return;
 	}
@@ -2616,7 +2886,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);
@@ -2754,7 +3026,8 @@ function getRequiredNamedExports(specifier) {
 	const getActiveHandles = process._getActiveHandles;
 	const handlesBeforeRequire = typeof getActiveHandles === "function" ? new Set(getActiveHandles.call(process)) : void 0;
 	try {
-		const mod = createRequire$1(pathToFileURL(path$1.join(getPackageDetectionCwd(), "package.json")))(specifier);
+		const projectPackageJson = path$1.join(getPackageDetectionCwd(), "package.json");
+		const mod = createRequire$1(pathToFileURL(projectPackageJson))(resolveModulePath(specifier, projectPackageJson));
 		const runtimeNamedKeys = Object.keys(mod).filter((key) => key !== "default" && key !== "__esModule");
 		if (runtimeNamedKeys.some((key) => !isValidEsmExportName(key))) return void 0;
 		return runtimeNamedKeys;
@@ -2797,7 +3070,7 @@ function getSharedNamedExports(pkg, shareItem, exportConditions = DEFAULT_SHARED
 }
 function getLocalProviderImportPath(pkg) {
 	try {
-		const resolved = resolveWorkspaceEsmEntry(pkg, createRequire$1(pathToFileURL(path$1.join(getPackageDetectionCwd(), "package.json"))).resolve(pkg));
+		const resolved = resolveWorkspaceEsmEntry(pkg, resolveModulePath(pkg, path$1.join(getPackageDetectionCwd(), "package.json")));
 		return isWorkspaceFilePath(resolved) ? resolved : void 0;
 	} catch {
 		const resolved = getInstalledPackageEntry(pkg, {
@@ -2818,7 +3091,7 @@ function getProjectResolvedImportPath(pkg) {
 		if (esmEntry) return esmEntry;
 	}
 	try {
-		return resolveWorkspaceEsmEntry(pkg, createRequire$1(pathToFileURL(path$1.join(getPackageDetectionCwd(), "package.json"))).resolve(pkg));
+		return resolveWorkspaceEsmEntry(pkg, resolveModulePath(pkg, path$1.join(getPackageDetectionCwd(), "package.json")));
 	} catch {
 		return;
 	}
@@ -2874,25 +3147,11 @@ function getSharedDependencyGraphPackageJson(pkg) {
 	const installedPackageJson = getInstalledPackageJson(pkg, { packageName: getPackageName(pkg) })?.packageJson;
 	if (installedPackageJson) return installedPackageJson;
 	try {
-		const packageJsonPath = createRequire$1(pathToFileURL(path$1.join(getPackageDetectionCwd(), "package.json"))).resolve(`${getPackageName(pkg)}/package.json`);
+		const packageJsonPath = resolveModulePath(`${getPackageName(pkg)}/package.json`, path$1.join(getPackageDetectionCwd(), "package.json"));
 		return JSON.parse(readFileSync(packageJsonPath, "utf-8"));
 	} catch {}
 	return getWorkspacePackageJson(pkg);
 }
-function getDependencyNames(packageJson) {
-	if (!packageJson) return [];
-	const names = /* @__PURE__ */ new Set();
-	for (const field of [
-		"dependencies",
-		"peerDependencies",
-		"optionalDependencies"
-	]) {
-		const deps = packageJson[field];
-		if (!deps || typeof deps !== "object") continue;
-		for (const dep of Object.keys(deps)) names.add(dep);
-	}
-	return Array.from(names);
-}
 function isSharedSingletonConsumedByPeer(pkg, options = getNormalizeModuleFederationOptions(), requireFederationRuntimeDependency = false) {
 	const shared = options?.shared || {};
 	if (!requireFederationRuntimeDependency && Object.entries(shared).some(([key, item]) => key !== pkg && key.startsWith(`${pkg}/`) && item.shareConfig.singleton === true)) return true;
@@ -2901,25 +3160,39 @@ function isSharedSingletonConsumedByPeer(pkg, options = getNormalizeModuleFedera
 		const packageName = getPackageName(key);
 		if (!sharedKeyByPackageName.get(packageName) || key === packageName) sharedKeyByPackageName.set(packageName, key);
 	});
-	const reachesPkg = (current, seen, hasFederationRuntimeDependency = false) => {
+	const runtimeDependencyCache = /* @__PURE__ */ new Map();
+	const reachesFederationRuntime = (current, seen) => {
+		if (runtimeDependencyCache.has(current)) return runtimeDependencyCache.get(current);
+		const result = getDependencyNames(getSharedDependencyGraphPackageJson(current)).some((dependency) => {
+			if (dependency === "@module-federation/enhanced" || dependency === "@module-federation/runtime" || dependency === "@module-federation/runtime-core") return true;
+			if (seen.has(dependency)) return false;
+			seen.add(dependency);
+			const reachable = reachesFederationRuntime(dependency, seen);
+			seen.delete(dependency);
+			return reachable;
+		});
+		runtimeDependencyCache.set(current, result);
+		return result;
+	};
+	const reachesPkg = (current, seen) => {
 		const dependencies = getDependencyNames(getSharedDependencyGraphPackageJson(current));
-		const usesFederationRuntime = dependencies.some((dependency) => dependency === "@module-federation/enhanced" || dependency === "@module-federation/runtime" || dependency === "@module-federation/runtime-core");
-		const runtimeIsReachable = hasFederationRuntimeDependency || usesFederationRuntime;
 		for (const dependency of dependencies) {
 			const sharedDependency = sharedKeyByPackageName.get(dependency);
-			if (!sharedDependency) continue;
-			if (sharedDependency === pkg) return !requireFederationRuntimeDependency || runtimeIsReachable;
-			if (seen.has(sharedDependency)) continue;
-			seen.add(sharedDependency);
-			if (reachesPkg(sharedDependency, seen, runtimeIsReachable)) return true;
+			if (sharedDependency === pkg) return true;
+			if (!sharedDependency && !requireFederationRuntimeDependency) continue;
+			const next = sharedDependency || dependency;
+			if (seen.has(next)) continue;
+			seen.add(next);
+			if (reachesPkg(next, seen)) return true;
+			seen.delete(next);
 		}
 		return false;
 	};
-	return Array.from(sharedKeyByPackageName.values()).some((sharedPkg) => sharedPkg !== pkg && reachesPkg(sharedPkg, /* @__PURE__ */ new Set([sharedPkg])));
+	return Array.from(sharedKeyByPackageName.values()).some((sharedPkg) => sharedPkg !== pkg && (!requireFederationRuntimeDependency || reachesFederationRuntime(sharedPkg, /* @__PURE__ */ new Set([sharedPkg]))) && reachesPkg(sharedPkg, /* @__PURE__ */ new Set([sharedPkg])));
 }
 function tryResolveImportFromPackageRoot(pkg, root) {
 	try {
-		return resolveWorkspaceEsmEntry(pkg, createRequire$1(pathToFileURL(path$1.join(root, "package.json"))).resolve(pkg), root);
+		return resolveWorkspaceEsmEntry(pkg, resolveModulePath(pkg, path$1.join(root, "package.json")), root);
 	} catch {
 		return;
 	}
@@ -2952,9 +3225,11 @@ function resolveConcreteSharedImportSource(pkg, projectRoot) {
 		if (resolved) return resolved;
 		currentDir = path$1.dirname(currentDir);
 	}
-	return tryResolveImportFromPackageRoot(pkg, currentDir);
+	return tryResolveImportFromPackageRoot(pkg, currentDir) ?? getInstalledPackageEntry(pkg, {
+		conditions: DEFAULT_SHARED_EXPORT_CONDITIONS,
+		resolveSubpathWithRequire: false
+	});
 }
-const PREBUILD_TAG = "__prebuild__";
 const TREE_SHAKING_PROVIDER_TAG = "__treeShakingProvider__";
 const TREE_SHAKING_GRAPH_QUERY = "__mf_tree_shaking_graph__";
 const legacySharedVirtualModuleState = {
@@ -2963,9 +3238,11 @@ const legacySharedVirtualModuleState = {
 	treeShakingProviderCacheMap: {},
 	materializedTreeShakingProviders: /* @__PURE__ */ new Set(),
 	loadShareCacheMap: {},
-	warnedMissingImportFalse: /* @__PURE__ */ new Set()
+	warnedMissingImportFalse: /* @__PURE__ */ new Set(),
+	coalescableLoadShares: /* @__PURE__ */ new Set()
 };
 const sharedVirtualModuleStates = /* @__PURE__ */ new WeakMap();
+const sharedVirtualModuleStatesByOwner = /* @__PURE__ */ new Map();
 function getSharedVirtualModuleState(options) {
 	if (!options) try {
 		const currentOptions = getNormalizeModuleFederationOptions();
@@ -2982,12 +3259,19 @@ function getSharedVirtualModuleState(options) {
 			materializedTreeShakingProviders: /* @__PURE__ */ new Set(),
 			loadShareCacheMap: {},
 			warnedMissingImportFalse: /* @__PURE__ */ new Set(),
+			coalescableLoadShares: /* @__PURE__ */ new Set(),
 			ownerKey: getFederationScopeKey(options)
 		};
 		sharedVirtualModuleStates.set(options, state);
+		if (state.ownerKey !== void 0) sharedVirtualModuleStatesByOwner.set(state.ownerKey, state);
 	}
 	return state;
 }
+/** State of the instance that owns a scoped virtual id; `options` covers unscoped ids. */
+function getSharedVirtualModuleStateForId(id, options) {
+	const ownerKey = id === void 0 ? void 0 : VirtualModule.findById(id)?.getScopeName();
+	return (ownerKey !== void 0 ? sharedVirtualModuleStatesByOwner.get(ownerKey) : void 0) ?? getSharedVirtualModuleState(options);
+}
 function createScopedSharedVirtualModule(pkg, tag, options) {
 	return new VirtualModule(pkg, tag, ".js", getSharedVirtualModuleState(options).ownerKey);
 }
@@ -3104,7 +3388,7 @@ function writePreBuildLibPath(pkg, shareItem, options, exportConditions) {
       const cache = globalThis[__mfCacheGlobalKey]?.share;
       const sharedReact = cache && __mfReadSharedCache(cache, ${reactCacheDescriptor});
       const reactExports = sharedReact?.default ?? sharedReact;
-      const internals = reactExports?.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+      const internals = reactExports?.[${JSON.stringify(REACT_CLIENT_INTERNALS_KEY)}];
       return internals?.H?.useMemoCache(size);
     };
     export default { c };
@@ -3182,7 +3466,6 @@ function getPreBuildShareItem(pkg, options) {
 function getSharedImportSource(pkg, shareItem, options) {
 	return getConcreteSharedImportSource(pkg, shareItem) || getPreBuildLibImportId(pkg, options);
 }
-const LOAD_SHARE_TAG = "__loadShare__";
 function getLoadShareImportId(pkg, _isRolldown, options) {
 	const { loadShareCacheMap } = getSharedVirtualModuleState(options);
 	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = createScopedSharedVirtualModule(pkg, LOAD_SHARE_TAG, options);
@@ -3242,14 +3525,14 @@ function getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer) {
 * a merged chunk, TDZ bindings otherwise), so the exports stay unassigned until the deferred cache write
 * re-applies them; a host-provided copy re-applies them through the cache subscription as before.
 */
-function generateEagerWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer, mutableExports = []) {
+function generateEagerWorkspaceSingletonExports(edges, namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer, mutableExports = []) {
 	const copiedExports = namedExports.filter((name) => !mutableExports.includes(name));
 	const namedExportVars = copiedExports.map((_name, i) => `__mf_${i}`);
 	const declarations = namedExports.length > 0 ? ["let __mf_default;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ") : "let __mf_default;";
 	const assignments = [...copiedExports.map((name, i) => `${namedExportVars[i]} = mod[${escapeGeneratedStringLiteral(name)}];`), "__mf_default = mod.default ?? mod;"].join("\n      ");
 	const namedExportLine = copiedExports.length > 0 ? `\n    export { ${copiedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : "";
-	const mutableExportLine = mutableExports.length ? `\n    export { ${mutableExports.join(", ")} } from ${escapeGeneratedStringLiteral(importSource)};` : "";
-	return `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(importSource)};
+	const mutableExportLine = mutableExports.length ? `\n    ${edges.reExportNames(mutableExports, importSource)}` : "";
+	return `${edges.importNamespace(importSource)}
     let exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
     if (exportModule === undefined) {
       Promise.resolve().then(() => {
@@ -3277,28 +3560,26 @@ function generateEagerWorkspaceSingletonExports(namedExports, importSource, cach
     __mfApplyEagerShareExportsWhenReady(exportModule);
     export { __mf_default as default };${namedExportLine}${mutableExportLine}`;
 }
-function generateLazyWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer, serveLocalFallback = false, mutableExports = []) {
+function generateLazyWorkspaceSingletonExports(edges, namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer, serveLocalFallback = false, mutableExports = [], deferredEntryFallback = false) {
 	const copiedExports = namedExports.filter((name) => !mutableExports.includes(name));
 	const namedExportVars = copiedExports.map((_name, i) => `__mf_${i}`);
 	const declarations = namedExports.length > 0 ? ["let __mf_default;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ") : "let __mf_default;";
 	const assignments = copiedExports.length > 0 ? [...copiedExports.map((name, i) => `${namedExportVars[i]} = mod[${escapeGeneratedStringLiteral(name)}];`), "__mf_default = mod.default ?? mod;"].join("\n      ") : "__mf_default = mod.default ?? mod;";
 	const namedExportLine = copiedExports.length > 0 ? `\n    export { ${copiedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : "";
-	const mutableExportLine = mutableExports.length ? `\n    export { ${mutableExports.join(", ")} } from ${escapeGeneratedStringLiteral(importSource)};` : "";
+	const mutableExportLine = mutableExports.length ? `\n    ${edges.reExportNames(mutableExports, importSource)}` : "";
 	const applyLocalFallback = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
       __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});
       __mfApplyLazyShareExports(exportModule);`;
-	return `${declarations}
-    const __mfApplyLazyShareExports = (mod) => {
-      ${assignments}
-    };
-    __mfSubscribeSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfApplyLazyShareExports);
-    let exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
-    if (exportModule === undefined) {
-      if (import.meta.env.SSR${serveLocalFallback ? " || (import.meta.env.DEV && typeof __mfLocalShare !== 'undefined')" : ""}) {
-        ${applyLocalFallback}
-      } else {
-        __mfTrackPendingShareLoad(initPromise.then(() => {
-          exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
+	const readDeferredShare = getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer);
+	const deferredEntryLoad = `Promise.race([
+          initPromise.then(() => ${readDeferredShare}),
+          new Promise((resolve) => {
+            const current = ${readDeferredShare};
+            if (current !== undefined) resolve(current);
+            else __mfSubscribeSharedCache(__mfModuleCache.share, ${cacheDescriptor}, resolve);
+          })
+        ]).then((cached) => {
+          exportModule = cached;
           if (exportModule !== undefined) {
             __mfApplyLazyShareExports(exportModule);
             return;
@@ -3307,8 +3588,32 @@ function generateLazyWorkspaceSingletonExports(namedExports, importSource, cache
             exportModule = __mfNormalizeShareModule(mod);
             __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});
           });
-        }));
-      }
+        })`;
+	const deferredInitLoad = `initPromise.then(() => {
+          exportModule = ${readDeferredShare};
+          if (exportModule !== undefined) {
+            __mfApplyLazyShareExports(exportModule);
+            return;
+          }
+          return import(${escapeGeneratedStringLiteral(importSource)}).then((mod) => {
+            exportModule = __mfNormalizeShareModule(mod);
+            __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});
+          });
+        })`;
+	const synchronousFallbackConditions = [...deferredEntryFallback ? [] : ["import.meta.env.SSR"], ...serveLocalFallback ? ["(import.meta.env.DEV && typeof __mfLocalShare !== 'undefined')"] : []];
+	const trackPendingLoad = `__mfTrackPendingShareLoad(${deferredEntryFallback ? deferredEntryLoad : deferredInitLoad});`;
+	return `${declarations}
+    const __mfApplyLazyShareExports = (mod) => {
+      ${assignments}
+    };
+    __mfSubscribeSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfApplyLazyShareExports);
+    let exportModule = ${readDeferredShare};
+    if (exportModule === undefined) {
+      ${synchronousFallbackConditions.length > 0 ? `if (${synchronousFallbackConditions.join(" || ")}) {
+        ${applyLocalFallback}
+      } else {
+        ${trackPendingLoad}
+      }` : trackPendingLoad}
     } else {
       __mfApplyLazyShareExports(exportModule);
     }
@@ -3344,6 +3649,14 @@ function generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor,
     if (exportModule === undefined) {
       __mfTrackPendingShareLoad(initPromise.then(() => {
         exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
+        // A share init() left to its dynamic import is normally bridged before that import runs;
+        // bridge it here when this wrapper is reached another way.
+        if (exportModule === undefined && typeof __mfPromiseState.loadLazyShares === "function") {
+          return __mfPromiseState.loadLazyShares([${escapeGeneratedStringLiteral(pkg)}]).then(() => {
+            exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
+          });
+        }
+      }).then(() => {
         if (exportModule === undefined) {
           throw new Error("[Module Federation] Shared module ${pkg} was imported before federation bootstrap finished.");
         }
@@ -3352,7 +3665,7 @@ function generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor,
     } else {
       __mfApplyHostProvidedExports(exportModule);
     }
-    export { __mf_default as default };${namedExportLine}`;
+    export { __mf_default as default, exportModule as __moduleExports };${namedExportLine}`;
 }
 function selectImportFalseNamedExports(detectedNamedExports, usage) {
 	if (!detectedNamedExports || usage?.kind !== "exports") return detectedNamedExports ?? [];
@@ -3391,9 +3704,49 @@ const initializedLocalShareModuleCode = `const __mfInitializedLocalShare = (mod)
         throw error;
       }
     };`;
+function createLocalPayloadEdges() {
+	let edges = 0;
+	return {
+		importNamespace(source) {
+			edges++;
+			return `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(source)};`;
+		},
+		reExportAll(source) {
+			edges++;
+			return `export * from ${escapeGeneratedStringLiteral(source)}`;
+		},
+		reExportNames(names, source) {
+			if (names.length === 0) return "";
+			edges++;
+			return `export { ${names.join(", ")} } from ${escapeGeneratedStringLiteral(source)};`;
+		},
+		get none() {
+			return edges === 0;
+		}
+	};
+}
+function recordCoalescability(pkg, hasNoLocalPayloadEdge, command, shareConfig, coalescableLoadShares) {
+	const coalescable = command === "build" && shareConfig.eager !== true && shareConfig.import !== false && hasNoLocalPayloadEdge;
+	if (coalescable) coalescableLoadShares.add(pkg);
+	else coalescableLoadShares.delete(pkg);
+	return coalescable;
+}
+/**
+* `prependWorkspaceSingletonSsrImport` adds a local-payload edge in the server
+* build's load hook, after this module has generated the wrapper. `id` names
+* the owning instance when the hook belongs to a different one.
+*/
+function markLoadShareWrapperNotCoalescable(pkg, options, id) {
+	getSharedVirtualModuleStateForId(id, options).coalescableLoadShares.delete(pkg);
+}
+/** With `id`, answers from the owning instance's state, whichever instance asks. */
+function isCoalescableLoadShareWrapper(pkg, options, id) {
+	return getSharedVirtualModuleStateForId(id, options).coalescableLoadShares.has(pkg);
+}
 function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exportConditions, importFalseExportUsage) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
-	const { loadShareCacheMap } = getSharedVirtualModuleState(options);
+	const { loadShareCacheMap, coalescableLoadShares } = getSharedVirtualModuleState(options);
+	const edges = createLocalPayloadEdges();
 	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = createScopedSharedVirtualModule(pkg, LOAD_SHARE_TAG, options);
 	let importLine = getRuntimeModuleCacheBootstrapCode(exportConditions);
 	const cacheDescriptor = getSharedCacheDescriptorLiteral(pkg, shareItem);
@@ -3413,6 +3766,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 			}
 			exportLine = generateDeferredHostProvidedExports([], pkg, cacheDescriptor, treeShakingConsumer);
 		}
+		recordCoalescability(pkg, edges.none, command, shareItem.shareConfig, coalescableLoadShares);
 		loadShareCacheMap[pkg].writeSync(`
     ${getRuntimeInitPromiseBootstrapCode(false, runtimeInitOwnerImportId)}
     ${importLine}
@@ -3434,13 +3788,14 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	const mutableExports = new Set(isLocalOnlyContainer(resolvedOptions) ? getSharedMutableExports(pkg, shareItem, exportConditions) : []);
 	const copiedNamedExports = namedExports.filter((name) => !mutableExports.has(name));
 	const liveNamedExports = namedExports.filter((name) => mutableExports.has(name));
-	const liveNamedExportLine = liveNamedExports.length ? `export { ${liveNamedExports.join(", ")} } from ${escapeGeneratedStringLiteral(sharedImportSource)};` : "";
+	const liveNamedExportLine = edges.reExportNames(liveNamedExports, sharedImportSource);
 	const hasCompleteExportCoverage = detectedNamedExports !== void 0;
 	const isWorkspaceSingleton = isWorkspacePackage && shareItem.shareConfig.singleton === 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 && isRemoteContainer(resolvedOptions) && shareItem.shareConfig.singleton === true && resolvedOptions.hostInitInjectLocation === "entry" && (command === "build" || isConsumedByPeerSingleton);
+	const usesDeferredEntryInjectedSingletonFallback = usesEntryInjectedRemoteFallback && !isReactCoreShare(pkg) && (pkg === "react-dom/client" || shareItem.shareConfig.eager !== true && !isSharedSingletonConsumedByPeer(pkg, resolvedOptions, true));
 	const usesEagerWorkspaceFallback = hasCompleteExportCoverage && isWorkspaceSingleton && !servesRemoteSingletonFallback && (isConsumedByPeerSingleton || shareItem.shareConfig.eager === true);
 	const usesDeferredTreeShakingFallback = hasCompleteExportCoverage && Boolean(treeShakingConsumer);
 	const reactMixedModeGuard = pkg === "react" ? createReactMixedModeRuntimeGuard() : "";
@@ -3448,11 +3803,14 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	let initBlock = "";
 	if (usesDeferredTreeShakingFallback) {
 		importLine = `${getRuntimeInitPromiseBootstrapCode(false, runtimeInitOwnerImportId)}\n    ${importLine}`;
-		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && !servesRemoteSingletonFallback && (isWorkspaceSingleton || isWorkspacePackage), liveNamedExports);
-	} else if (usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback) exportLine = generateEagerWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, liveNamedExports);
+		exportLine = generateLazyWorkspaceSingletonExports(edges, namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && !servesRemoteSingletonFallback && (isWorkspaceSingleton || isWorkspacePackage), liveNamedExports);
+	} else if (usesDeferredEntryInjectedSingletonFallback) {
+		importLine = `${getRuntimeInitPromiseBootstrapCode(false, runtimeInitOwnerImportId)}\n    ${importLine}`;
+		exportLine = generateLazyWorkspaceSingletonExports(edges, namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, false, liveNamedExports, true);
+	} else if (usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback) exportLine = generateEagerWorkspaceSingletonExports(edges, namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, liveNamedExports);
 	else if (usesDeferredSingletonFallback) {
 		importLine = `${getRuntimeInitPromiseBootstrapCode(false, runtimeInitOwnerImportId)}\n    ${importLine}`;
-		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && !servesRemoteSingletonFallback && (isWorkspaceSingleton || isWorkspacePackage), liveNamedExports);
+		exportLine = generateLazyWorkspaceSingletonExports(edges, namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && !servesRemoteSingletonFallback && (isWorkspaceSingleton || isWorkspacePackage), liveNamedExports);
 	} else if (detectedNamedExports === void 0) {
 		exportLine = `const __mfDefaultExport = (() => {
       ${generateShareModuleUnwrapCode({
@@ -3462,7 +3820,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 		})}
     })();
     export default __mfDefaultExport;
-    export * from ${escapeGeneratedStringLiteral(coherentLocalSource)}`;
+    ${edges.reExportAll(coherentLocalSource)}`;
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
       __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
 	} else if (namedExports.length > 0 && shareItem.shareConfig.singleton === true) {
@@ -3513,21 +3871,23 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
     __mfSubscribeSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfApplySharedDefaultExport);
     __mfApplySharedDefaultExport(exportModule);
     export { __mfDefaultExport as default };
-    export * from ${escapeGeneratedStringLiteral(sharedImportSource)}`;
+    ${edges.reExportAll(sharedImportSource)}`;
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
       __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
 	} else {
-		exportLine = `export default exportModule.default ?? exportModule\n    export * from ${escapeGeneratedStringLiteral(sharedImportSource)}`;
+		exportLine = `export default exportModule.default ?? exportModule\n    ${edges.reExportAll(sharedImportSource)}`;
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
       __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
 	}
-	const prebuildImportLine = usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback ? "" : usesDeferredSingletonFallback || usesDeferredTreeShakingFallback ? !servesRemoteSingletonFallback && usesDeferredSingletonFallback && command !== "build" && (isWorkspaceSingleton || isWorkspacePackage) ? `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(lazyLocalFallbackSource)};` : "" : `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(detectedNamedExports === void 0 ? coherentLocalSource : skipServePrebuildWarmup ? devImportSource : sharedImportSource)};`;
-	const devDynamicImportLine = isWorkspacePackage ? "" : usesDeferredSingletonFallback || usesDeferredTreeShakingFallback ? "" : command !== "build" && !skipServePrebuildWarmup ? `;() => import(${escapeGeneratedStringLiteral(devImportSource)}).catch(() => {});` : "";
-	const moduleBody = usesDeferredSingletonFallback || usesDeferredTreeShakingFallback || usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback ? `
-    ${prebuildImportLine}
+	const staticLocalShareSource = detectedNamedExports === void 0 ? coherentLocalSource : skipServePrebuildWarmup ? devImportSource : sharedImportSource;
+	const prebuildImportLine = usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback ? "" : usesDeferredSingletonFallback || usesDeferredTreeShakingFallback ? !servesRemoteSingletonFallback && usesDeferredSingletonFallback && command !== "build" && (isWorkspaceSingleton || isWorkspacePackage) ? edges.importNamespace(lazyLocalFallbackSource) : "" : edges.importNamespace(staticLocalShareSource);
+	const devDynamicImportLine = isWorkspacePackage ? "" : usesDeferredSingletonFallback || usesDeferredTreeShakingFallback || usesDeferredEntryInjectedSingletonFallback ? "" : command !== "build" && !skipServePrebuildWarmup ? `;() => import(${escapeGeneratedStringLiteral(devImportSource)}).catch(() => {});` : "";
+	const cacheHelpers = recordCoalescability(pkg, edges.none, command, shareItem.shareConfig, coalescableLoadShares) ? getSharedCacheHelpersImportCode(resolvedOptions) : sharedCacheHelperCode;
+	const moduleBody = usesDeferredSingletonFallback || usesDeferredTreeShakingFallback || usesDeferredEntryInjectedSingletonFallback || usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback ? `
+    ${usesDeferredEntryInjectedSingletonFallback ? "" : prebuildImportLine}
     ${devDynamicImportLine}
     ${importLine}
-    ${sharedCacheHelperCode}
+    ${cacheHelpers}
     ${normalizeLocalShareModuleCode}
     ${initializedLocalShareModuleCode}
     ${exportLine}
@@ -3535,7 +3895,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
     ${prebuildImportLine}
     ${devDynamicImportLine}
     ${importLine}
-    ${sharedCacheHelperCode}
+    ${cacheHelpers}
     ${normalizeLocalShareModuleCode}
     let exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)}
     if (exportModule === undefined) {
@@ -3579,6 +3939,7 @@ function addConfiguredShare(pkg, options) {
 	if (options) getScopedUsedShares(options).add(pkg);
 }
 const LOCAL_SHARED_IMPORT_MAP_ID = "virtual:mf-localSharedImportMap";
+const LAZY_CONSUME_ONLY_SHARES_PLACEHOLDER = "__MF_LAZY_CONSUME_ONLY_SHARES__";
 const localOwnerIds = /* @__PURE__ */ new WeakMap();
 let nextLocalOwnerId = 1;
 function getLocalOwnerKey(options) {
@@ -3616,6 +3977,10 @@ function getLocalSharedPackagePath(pkg, shareItem, options) {
 	if (shouldUseDirectReactImport() && pkg === "react") return "react";
 	return getConcreteSharedImportSource(pkg, shareItem) || getLocalProviderImportPath(pkg) || getSharedImportSource(pkg, shareItem, options);
 }
+function getCanonicalSharedKey(pkg, shareItem) {
+	const { request, shareKey } = shareItem.shareConfig;
+	return request !== void 0 || shareKey !== void 0 ? getSharedRuntimeKey(pkg, shareItem) : pkg;
+}
 function getDirectSharedCacheSeedImportPath(pkg, shareItem) {
 	return getConcreteSharedImportSource(pkg, shareItem) || getProjectResolvedImportPath(pkg) || getLocalProviderImportPath(pkg) || pkg;
 }
@@ -3629,7 +3994,7 @@ function generateLocalSharedImportMap(options) {
     import {loadShare} from "@module-federation/runtime";
     ${orderedShares.map((pkg, index) => {
 		const shareItem = getNormalizeShareItem(pkg, resolvedOptions);
-		if (!shareItem?.shareConfig.eager || shareItem.shareConfig.import === false) return "";
+		if (!shareItem || !shareItem.shareConfig.eager || shareItem.shareConfig.import === false) return "";
 		return `import * as __mfEagerShare_${index} from ${toSafeJsLiteral(getLocalSharedPackagePath(pkg, shareItem, options))};`;
 	}).filter(Boolean).join("\n")}
     ${normalizeRuntimeShareCode}
@@ -3654,12 +4019,17 @@ function generateLocalSharedImportMap(options) {
     const __mfHostOnly = (name) => async () => {
       throw new Error(\`[Module Federation] Shared module '\${name}' must be provided by host\`);
     };
+    // Replaced by the lazy consume-only share plugin with the keys that only a dynamic
+    // import() reaches, so init() leaves them to that import; an unreplaced string matches no key.
+    const __mfLazyShares = ${JSON.stringify(LAZY_CONSUME_ONLY_SHARES_PLACEHOLDER)};
+    const __mfIsLazyShare = (name) => Array.isArray(__mfLazyShares) && __mfLazyShares.includes(name);
     const __mfConsumeOnly = (name, version, scope, materialize, shareConfig) => ({
       name,
       version,
       scope: [scope],
       loaded: false,
-      materialize,
+      materialize: materialize && !__mfIsLazyShare(name),
+      lazy: __mfIsLazyShare(name),
       eager: shareConfig.eager,
       from: ${toSafeJsLiteral(resolvedOptions.name)},
       canLiveRebind: true,
@@ -3669,7 +4039,8 @@ function generateLocalSharedImportMap(options) {
     const importMap = {
       ${orderedShares.map((pkg, index) => {
 		const shareItem = getNormalizeShareItem(pkg, resolvedOptions);
-		if (shareItem?.shareConfig.import === false) return `
+		if (!shareItem) return "";
+		if (shareItem.shareConfig.import === false) return `
         ${toSafeJsLiteral(pkg)}: __mfHostOnly(${toSafeJsLiteral(pkg)})`;
 		return `
         ${toSafeJsLiteral(pkg)}: async () => {
@@ -3685,7 +4056,7 @@ function generateLocalSharedImportMap(options) {
 		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 cacheKeys = [key, ...key === "react-dom/client" ? [getPackageName(REACT_DOM_CLIENT_SHARE)] : []].flatMap((pkg) => {
 			const descriptor = getSharedCacheDescriptor(pkg, shareItem);
 			return [descriptor.canonical, ...descriptor.aliases ?? []];
 		});
@@ -3697,7 +4068,7 @@ function generateLocalSharedImportMap(options) {
 		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)}})`;
+          ${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)}, ${shareItem.shareConfig.request !== void 0 ? `request: ${toSafeJsLiteral(shareItem.shareConfig.request)},` : ""} ${shareItem.shareConfig.shareKey !== void 0 ? `shareKey: ${toSafeJsLiteral(shareItem.shareConfig.shareKey)},` : ""}})`;
 		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;
@@ -3768,6 +4139,8 @@ function generateLocalSharedImportMap(options) {
               requiredVersion: ${toSafeJsLiteral(shareItem.shareConfig.requiredVersion)},
               strictVersion: ${shareItem.shareConfig.strictVersion},
               eager: ${Boolean(shareItem.shareConfig.eager)},
+              ${shareItem.shareConfig.request !== void 0 ? `request: ${toSafeJsLiteral(shareItem.shareConfig.request)},` : ""}
+              ${shareItem.shareConfig.shareKey !== void 0 ? `shareKey: ${toSafeJsLiteral(shareItem.shareConfig.shareKey)},` : ""}
               ${shareItem.shareConfig.import === false ? "import: false," : ""}
             },
             ${treeShakingConfig ? `treeShaking: {
@@ -3806,10 +4179,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);
@@ -3819,11 +4193,17 @@ function expandSharedPrefixKey(prefixKey, used) {
 function getOrderedUsedShares(options) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const used = getUsedShares(options);
-	const shares = new Set(used);
+	const shares = /* @__PURE__ */ new Set();
+	const addShare = (pkg) => {
+		const shareItem = getNormalizeShareItem(pkg, resolvedOptions);
+		shares.add(shareItem ? getCanonicalSharedKey(pkg, shareItem) : pkg);
+	};
+	used.forEach(addShare);
 	Object.keys(resolvedOptions.shared ?? {}).forEach((pkg) => {
-		if (!pkg.endsWith("/")) shares.add(pkg);
+		const share = resolvedOptions.shared?.[pkg];
+		if (share && !getSharedRequest(pkg, share).endsWith("/")) addShare(pkg);
 	});
-	for (const [pkg, share] of Object.entries(resolvedOptions.shared ?? {})) if (pkg.endsWith("/") && share.shareConfig?.eager) for (const concrete of expandSharedPrefixKey(pkg, used)) shares.add(concrete);
+	for (const [pkg, share] of Object.entries(resolvedOptions.shared ?? {})) if (share.shareConfig?.eager && getSharedRequest(pkg, share).endsWith("/")) for (const concrete of expandSharedPrefixKey(getSharedRequest(pkg, share), used)) addShare(concrete);
 	return orderSharedDependenciesFirst(Array.from(shares).sort((a, b) => {
 		const priority = (pkg) => pkg === "react" ? 0 : pkg === "react-dom" ? 1 : pkg.startsWith("react/") ? 2 : 3;
 		return priority(a) - priority(b) || a.localeCompare(b);
@@ -3836,7 +4216,8 @@ function getMaterializedShares(options) {
 	const usedForEager = options ? usedSharesByOptions.get(options) ?? [] : usedShares;
 	for (const [pkg, share] of Object.entries(resolvedOptions.shared ?? {})) {
 		if (!share.shareConfig?.eager) continue;
-		if (pkg.endsWith("/")) for (const concrete of expandSharedPrefixKey(pkg, usedForEager)) shares.add(concrete);
+		const request = getSharedRequest(pkg, share);
+		if (request.endsWith("/")) for (const concrete of expandSharedPrefixKey(request, usedForEager)) shares.add(concrete);
 		else shares.add(pkg);
 	}
 	const configured = /* @__PURE__ */ new Map();
@@ -3864,10 +4245,14 @@ function getMaterializedShares(options) {
 			}
 		}
 	}
-	return orderSharedDependenciesFirst([...shares].sort((a, b) => {
+	const sorted = [...shares].sort((a, b) => {
 		const priority = (pkg) => pkg === "react" ? 0 : pkg === "react-dom" ? 1 : pkg.startsWith("react/") ? 2 : 3;
 		return priority(a) - priority(b) || a.localeCompare(b);
-	}));
+	});
+	return orderSharedDependenciesFirst([...new Set(sorted.map((pkg) => {
+		const shareItem = getNormalizeShareItem(pkg, resolvedOptions);
+		return shareItem ? getCanonicalSharedKey(pkg, shareItem) : pkg;
+	}))]);
 }
 /** Shared keys a share's package.json depends on (roots stand in for their subpaths, subpaths for their root), keyed by share. */
 function getSharePrerequisites(ordered) {
@@ -3955,9 +4340,30 @@ function orderSharedDependenciesFirst(sharedPackages) {
 }
 function getShareItemForPreload(pkg, options = getNormalizeModuleFederationOptions()) {
 	const shared = options.shared;
-	const wildcardKey = `${getPackageName(pkg)}/`;
+	const packageName = getPackageName(pkg);
+	const wildcardKey = `${packageName}/`;
 	if (isExplicitSharedKey(pkg, options)) return shared[pkg];
 	if (isExplicitSharedKey(wildcardKey, options)) return shared[wildcardKey];
+	if (pkg !== packageName && isExplicitSharedKey(packageName, options) && shared[packageName]?.shareConfig.import !== false && getCommonSharedSubpaths(packageName).includes(pkg)) return shared[packageName];
+	const shareItem = getNormalizeShareItem(pkg, options);
+	if (!shareItem) return void 0;
+	if (shareItem.shareConfig.request === void 0 && shareItem.shareConfig.shareKey === void 0) return;
+	const runtimeKey = getSharedRuntimeKey(pkg, shareItem);
+	if (runtimeKey === pkg || runtimeKey.endsWith("/") && (pkg === runtimeKey.slice(0, -1) || pkg.startsWith(runtimeKey))) return shareItem;
+}
+/**
+* Entry-injected renderer wrappers (see `REACT_DOM_CLIENT_SHARE`) assign
+* `createRoot` only after `initPromise` and a dynamic import, so a standalone
+* remote must evaluate that wrapper before the app entry. The subpath is often
+* absent from `getMaterializedShares()` when pending shares is emitted:
+* `react-dom/` collapses to `react-dom`, and the entry import may not be
+* recorded yet.
+*/
+function shouldPreloadEntryDeferredReactDomClient(options) {
+	if (options.hostInitInjectLocation !== "entry" || !isRemoteContainer(options)) return false;
+	const shareItem = getShareItemForPreload(REACT_DOM_CLIENT_SHARE, options);
+	if (!shareItem || shareItem.shareConfig.singleton !== true) return false;
+	return shareItem.shareConfig.import !== false && !shareItem.shareConfig.treeShaking;
 }
 function generateSharedCacheSeedItem(pkg, shareItem, importPath, options = getNormalizeModuleFederationOptions()) {
 	const cacheDescriptor = getSharedCacheDescriptor(pkg, shareItem);
@@ -3987,6 +4393,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 = {};
@@ -4028,7 +4436,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) {
@@ -4140,7 +4548,28 @@ const externalSharedProviderSelectionHelperCode = `const __mfSelectExternalShare
             ) return undefined;
             return { provider, scopeRootProvider };
           };`;
-function generateRuntimeSharedCacheSeedCode(shareStrategy, options) {
+/**
+* A consume-only stub never outranks a provider: when registering this container's
+* `import: false` share replaces an unloaded provider of the same version (#1311),
+* the `afterRegisterShare` hook restores the provider. Registered once per instance.
+*/
+function generateKeepProvidersOverStubsCode(runtimeVar) {
+	return `if (!${runtimeVar}.__mfKeepAdoptedProviders) {
+      ${runtimeVar}.__mfKeepAdoptedProviders = true;
+      ${runtimeVar}.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 = ${runtimeVar}.shareScopeMap?.[args.scope]?.[args.pkgName];
+        if (versions && versions[shared.version] === shared) versions[shared.version] = previousShared;
+      });
+    }`;
+}
+function generateRuntimeSharedCacheSeedCode(shareStrategy, options, command = "build") {
 	const seedBatches = getShareBatches(options, false);
 	const seedOrder = seedBatches.flat();
 	const seedIndex = new Map(seedOrder.map((pkg, index) => [pkg, index]));
@@ -4154,7 +4583,7 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy, options) {
     // import and set materialize. An import:false share has no local fallback
     // though, so on a cold request (materialize not set yet) it must still be
     // attempted here, or it is never seeded and its consumer reads it undefined.
-    const __mfSeedKeys = __mfSeedOrder.filter((pkg) => usedShared[pkg] && (usedShared[pkg].materialize !== false || usedShared[pkg].shareConfig?.import === false));
+    const __mfSeedKeys = __mfSeedOrder.filter((pkg) => usedShared[pkg] && (usedShared[pkg].materialize !== false || (usedShared[pkg].shareConfig?.import === false && !usedShared[pkg].lazy)));
     __mfModuleCache.providerInit ||= new Map();
     const __mfInitializeProviderOnce = (key, initialize) => {
       const existing = __mfModuleCache.providerInit.get(key);
@@ -4187,6 +4616,16 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy, options) {
           );
           return;
         }
+        ${command === "serve" ? `// A pending webpack provider for this share, or for its package when this
+        // is a subpath, is only bridged after init(). Seeding the local fallback now
+        // would evaluate the package's dev proxy, which snapshots its exports, before
+        // the bridge runs and pin a second copy. The proxy seeds itself on first import.
+        if (
+          typeof __mfGetPendingExternalSharedProvider === 'function' &&
+          __mfGetPendingExternalSharedProvider(pkg, share)
+        ) {
+          return;
+        }` : ""}
         const externalProvider = typeof __mfGetExternalSharedProvider === 'function'
           ? __mfGetExternalSharedProvider(pkg, share)
           : undefined;
@@ -4215,6 +4654,12 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy, options) {
           const mod = typeof factory === "function" ? factory() : factory;
           return Promise.resolve(mod);
         });
+        // The seeded local copy is what this container's consumers are bound to.
+        // Flag the Runtime's provider as eager so a same-version sibling cannot
+        // take over the share scope slot via the Runtime's name tie-break.
+        for (const provider of initRes.options.shared?.[pkg] || []) {
+          if (provider.get === share.get) provider.eager = true;
+        }
         ${normalizeRuntimeShareCode}
         const normalizedModule = __mfNormalizeRuntimeShare(resolved);
         const exportModule = normalizedModule === resolved ? {...resolved} : normalizedModule;
@@ -4487,8 +4932,8 @@ function generateTreeShakingSnapshotPluginCode(enabled) {
     },
   });`;
 }
-function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(options), command = "build", exportConditions) {
-	const needsSharedProviderSelectionHelper = Object.keys(options.shared ?? {}).length > 0;
+function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(options), command = "build", exportConditions, isSsrBuild = false) {
+	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" && isRemoteContainer(options) && hasRemotes(options);
@@ -4499,7 +4944,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
 		...hasTreeShakingShared ? ["getRemoteEntry"] : []
 	].join(", ");
 	const runtimeHelperImports = [...hasTreeShakingShared ? ["global as runtimeGlobal"] : [], ...needsSharedProviderSelectionHelper ? ["share as runtimeShare"] : []];
-	const pluginImportNames = options.runtimePlugins.map((p, i) => {
+	const pluginImportNames = filterRuntimePluginsForTarget(options.runtimePlugins, SSR_ONLY_RUNTIME_PLUGINS, isSsrBuild).map((p, i) => {
 		if (typeof p === "string") return [
 			`$runtimePlugin_${i}`,
 			`import $runtimePlugin_${i} from "${p}";`,
@@ -4822,13 +5267,36 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       };
     }
     const runtimeResolveShareHook = initRes.sharedHandler.hooks.lifecycle.resolveShare;
+    // Registering this container's shares lets its consume-only stub displace the parent's
+    // unloaded same-version provider whenever this container's name sorts after the parent's
+    // (the Runtime keeps the higher name). Nothing can be loaded from a stub, so put the
+    // provider back; a share bridged later, e.g. from a lazy import(), still finds it.
+    ${generateKeepProvidersOverStubsCode("initRes")}
     const __mfRuntimeProviderOrigins = new WeakMap();
     runtimeResolveShareHook.on((args) => {
       const loadId = args.shareInfo?.[__mfRuntimeShareLoadIdKey];
       const resolver = args.resolver;
       if (typeof resolver !== "function") return args;
       const instrumentedResolver = (...resolverArgs) => {
-        const resolved = resolver(...resolverArgs);
+        let resolved = resolver(...resolverArgs);
+        // A consume-only stub can never be loaded. The Runtime still settles on one when
+        // it carries the highest version, e.g. a parent that registers its provider under
+        // "0.0.0"; hand back the provider this container selects for itself instead.
+        if (
+          resolved?.shared?.shareConfig?.import === false &&
+          typeof __mfSelectSharedProvider === "function" &&
+          usedShared[args.pkgName]
+        ) {
+          const provider = __mfSelectSharedProvider(
+            args.shareScopeMap?.[args.scope]?.[args.pkgName],
+            args.pkgName,
+            usedShared[args.pkgName],
+            '${options.shareStrategy}'
+          );
+          if (provider && provider.shareConfig?.import !== false) {
+            resolved = { shared: provider, useTreesShaking: resolved.useTreesShaking };
+          }
+        }
         const selectedProvider = resolved?.shared;
         if (
           selectedProvider &&
@@ -5241,7 +5709,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
         );
       }
     }
-    ${generateRuntimeSharedCacheSeedCode(options.shareStrategy, options)}
+    ${generateRuntimeSharedCacheSeedCode(options.shareStrategy, options, command)}
     ${initializeSharingCode}
     __mfRestoreForeignSharedProviders();
     // Calling provider.get() marks a provider as loaded. Wait until the Runtime has
@@ -5259,9 +5727,13 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
         );
       }));
     };
-    await __mfBridgeSharedProviders();
     if (__mfUsesWebpackShareScope) {
+      // A webpack host's loadShare() awaits initializeSharing(), which awaits this
+      // init(). Bridging here would call the host's provider.get() and re-enter
+      // loadShare(), so both promises wait on each other forever (#1326).
       __mfLateBridgeShared = __mfBridgeSharedProviders;
+    } else {
+      await __mfBridgeSharedProviders();
     }
     try {
       const allInstances = globalThis.__FEDERATION__?.__SHARE__;
@@ -5415,6 +5887,29 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       (pkg) => !__mfBlockedSeedKeys.has(__mfSeedIndex.get(pkg))
     ));
     await __mfSeedLocalShared(__mfReadyDeferredSeedKeys);
+    ${command === "build" ? `// A consume-only share reached only through import() is bridged when that import runs
+    // (see pluginLazyConsumeOnlyShares), through the same provider selection init() uses.
+    const __mfLazyShareLoads = new Map();
+    __mfResolveState.loadLazyShares = async (names) => {
+      const requested = new Set(names);
+      for (const batch of __mfMaterializedShareBatches) await Promise.all(batch.filter((pkg) => requested.has(pkg)).map((pkg) => {
+        const share = usedShared[pkg];
+        if (!share || !share.lazy || !__mfIsRuntimeOnlySharePending(pkg)) return;
+        let load = __mfLazyShareLoads.get(pkg);
+        if (!load) {
+          load = __mfBridgeExternalSharedProvider(
+            pkg,
+            share,
+            ${hasMultipleShareScopes ? "getShareVersions(pkg, share)" : "shared[pkg]"},
+            initialShared[pkg],
+            undefined
+          ).then(() => __mfIsRuntimeOnlySharePending(pkg) ? __mfResolveImportFalseShared(pkg, share) : undefined);
+          load.catch(() => __mfLazyShareLoads.delete(pkg));
+          __mfLazyShareLoads.set(pkg, load);
+        }
+        return load;
+      }));
+    };` : ""}
     initResolve(initRes)
     return initRes
   }
@@ -5431,8 +5926,13 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   ${guardHostAutoInit ? `let __mfInitPromise;
   function __mfGuardedInit(shared, initScope, remoteEntryInitOptions) {
     if (shared === undefined && __mfInitPromise) return __mfInitPromise;
-    __mfInitPromise = init(shared, initScope, remoteEntryInitOptions);
-    return __mfInitPromise;
+    // A call skipped by the circular-init guard resolves to undefined and must not
+    // replace the cached result of the call that actually initialized the container.
+    const prev = __mfInitPromise;
+    const next = init(shared, initScope, remoteEntryInitOptions);
+    __mfInitPromise = prev ? next.then((res) => (res === undefined ? prev : res)) : next;
+    if (prev) __mfInitPromise.catch(() => {});
+    return next;
   }
   export { __mfGuardedInit as init, getExposes as get }` : `export { init, getExposes as get }`}
   `;
@@ -5468,7 +5968,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() {
@@ -5482,16 +6003,18 @@ 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];
-              if (!share || share.materialize === false) return;
+              // A standalone container has no dynamic-import boundary to load a lazy share behind.
+              if (!share || (share.materialize === false && !share.lazy)) return;
               // remoteEntry.init resolves tree-enabled shares into the
               // coverage-aware cache. Never republish that selected partial under
               // a generic full-module key here.
@@ -5505,18 +6028,44 @@ 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.
+                  ${generateKeepProvidersOverStubsCode("runtime")}
+                  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 (
@@ -5596,22 +6145,32 @@ function getPendingSharesState(options) {
 }
 function generatePendingSharesCode(command = "build", options) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
-	const pendingShareImports = command === "build" ? getMaterializedShares(options).filter((pkg) => {
+	const pendingSharePkgs = 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))})]`) : [];
+	}) : [];
+	if (command === "build" && shouldPreloadEntryDeferredReactDomClient(resolvedOptions) && !pendingSharePkgs.includes("react-dom/client")) pendingSharePkgs.push(REACT_DOM_CLIENT_SHARE);
+	const pendingShareImports = pendingSharePkgs.map((pkg) => `[${toSafeJsLiteral(pkg)}, () => import(${toSafeJsLiteral(getLoadShareModulePath(pkg, false, options))})]`);
 	return `
     ${getRuntimeModuleCacheBootstrapCode()}
     ${sharedCacheHelperCode}
     const __mfPendingShareImports = [${pendingShareImports.join(", ")}];
     export async function preloadPendingShares() {
       if (__mfPendingShareImports.length === 0) return;
+      const __mfRendererShare = ${toSafeJsLiteral(REACT_DOM_CLIENT_SHARE)};
+      const __mfRendererParent = ${toSafeJsLiteral(getPackageName(REACT_DOM_CLIENT_SHARE))};
       const {usedShared} = await import("${getLocalSharedImportMapPath(options)}");
       await Promise.all(__mfPendingShareImports.map(async ([pkg, load]) => {
-        const share = usedShared[pkg];
-        if (!share || share.materialize === false || share.treeShaking || share.shareConfig?.import === false) return;
+        const exactShare = usedShared[pkg];
+        const share = exactShare ?? (pkg === __mfRendererShare ? usedShared[__mfRendererParent] : undefined);
+        if (!share || share.treeShaking || share.shareConfig?.import === false) return;
+        // The collapsed parent does not mark the renderer subpath materialized until the entry
+        // imports it, and that import map can be emitted first. The deferred renderer wrapper
+        // still has to run before a standalone entry reads createRoot. A cache hit (the host
+        // renderer) skips load(), so a nested leaf does not import its own client.
+        if (exactShare && exactShare.materialize === false && pkg !== __mfRendererShare) return;
         const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
         if (__mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined) return;
         await load().catch((err) => console.warn("[module-federation] shared preload failed:", pkg, err));
@@ -6100,9 +6659,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);
 }
@@ -6153,6 +6709,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;
@@ -6229,6 +6786,28 @@ const __mfCurrentScript = document.currentScript;
 			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'
@@ -6255,7 +6834,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 }
 ` : "";
 		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 shareItem = getNormalizeShareItem(pkg, federationOptions);
 			const isExplicitShare = Object.hasOwn(federationOptions.shared, pkg);
 			return shareItem?.shareConfig?.singleton === true && shareItem?.shareConfig?.import !== false && !shareItem?.shareConfig?.treeShaking && (isExplicitShare || typeof shareItem?.shareConfig?.import === "string" || Boolean(getProjectResolvedImportPath(pkg)));
 		}).map((pkg) => toViteEncodedId(getLoadShareModulePath(pkg, false, federationOptions))) : [];
@@ -6345,7 +6924,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 	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));
@@ -6367,7 +6946,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));
@@ -6375,7 +6954,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)) {
@@ -6402,6 +6981,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)) {
@@ -6411,9 +6991,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;
 					}
 				}
@@ -6461,7 +7044,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;
@@ -6679,17 +7263,20 @@ function checkAliasConflicts(options) {
 				}
 				return false;
 			};
-			for (const sharedKey of sharedKeys) for (const aliasEntry of userAliases) {
-				const replacement = aliasEntry.replacement;
-				if (!matchesSharedKey(aliasEntry, sharedKey)) continue;
-				if (replacement === "$1") break;
-				if (typeof replacement === "string") {
-					if (getPackageNameFromNodeModulePath(replacement) === (sharedKey.endsWith("/") ? sharedKey.slice(0, -1) : sharedKey)) continue;
-					conflicts.push({
-						sharedModule: sharedKey,
-						alias: String(aliasEntry.find),
-						target: replacement
-					});
+			for (const sharedKey of sharedKeys) {
+				const request = getSharedRequest(sharedKey, shared[sharedKey]);
+				for (const aliasEntry of userAliases) {
+					const replacement = aliasEntry.replacement;
+					if (!matchesSharedKey(aliasEntry, request)) continue;
+					if (replacement === "$1") break;
+					if (typeof replacement === "string") {
+						if (getPackageNameFromNodeModulePath(replacement) === (request.endsWith("/") ? request.slice(0, -1) : request)) continue;
+						conflicts.push({
+							sharedModule: sharedKey,
+							alias: String(aliasEntry.find),
+							target: replacement
+						});
+					}
 				}
 			}
 			if (conflicts.length > 0) {
@@ -7404,9 +7991,6 @@ function pluginExternalRuntimeCore() {
 	};
 }
 //#endregion
-//#region package.json
-var version$1 = "1.22.0";
-//#endregion
 //#region src/virtualModules/index.ts
 function initVirtualModules(command, remoteEntryId, enableSsrInit = false, options) {
 	writeLocalSharedImportMap(options);
@@ -7424,6 +8008,11 @@ const JS_EXTENSIONS = [
 	".mjs",
 	".cjs"
 ];
+/** A module path without its JS extension, so `./src/App` matches `/root/src/App.tsx`. */
+const stripKnownJsExtension = (file) => {
+	const ext = path$1.extname(file);
+	return JS_EXTENSIONS.includes(ext) ? path$1.join(path$1.dirname(file), path$1.basename(file, ext)) : file;
+};
 /**
 * Creates an empty asset map structure for tracking JS and CSS assets
 * @returns Initialized asset map with sync/async arrays for JS and CSS
@@ -7494,16 +8083,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 ?? []),
@@ -7527,8 +8131,8 @@ const processModuleAssets = (bundle, filesMap, moduleMatcher, options = {}) => {
 			const comparableModulePath = options.root ? path$1.resolve(options.root, modulePath) : modulePath;
 			const comparableModulePaths = [comparableModulePath];
 			if (options.stripKnownJsExtensions) {
-				const ext = path$1.extname(comparableModulePath);
-				if (JS_EXTENSIONS.includes(ext)) comparableModulePaths.push(path$1.join(path$1.dirname(comparableModulePath), path$1.basename(comparableModulePath, ext)));
+				const stripped = stripKnownJsExtension(comparableModulePath);
+				if (stripped !== comparableModulePath) comparableModulePaths.push(stripped);
 			}
 			const matchKey = comparableModulePaths.map(moduleMatcher).find(Boolean);
 			if (!matchKey) continue;
@@ -7589,6 +8193,118 @@ const buildFileToShareKeyMap = async (shareKeys, resolveFn, options) => {
 	return fileToShareKey;
 };
 //#endregion
+//#region src/plugins/pluginLazyConsumeOnlyShares.ts
+const chunkModuleIds = (chunk) => [...chunk.facadeModuleId ? [chunk.facadeModuleId] : [], ...chunk.moduleIds ?? Object.keys(chunk.modules ?? {})];
+function buildLazyShareGraph(chunks, wrapperShares, exposeModules) {
+	const sharesInChunk = /* @__PURE__ */ new Map();
+	const startupRoots = [];
+	for (const [fileName, chunk] of Object.entries(chunks)) {
+		if (chunk.type !== "chunk") continue;
+		const moduleIds = chunkModuleIds(chunk);
+		sharesInChunk.set(fileName, new Set(moduleIds.map((id) => wrapperShares.get(normalizeVirtualModuleId(id))).filter((share) => share !== void 0)));
+		if (chunk.isEntry || moduleIds.some((id) => exposeModules.has(stripKnownJsExtension(id)))) startupRoots.push(fileName);
+	}
+	const sharesInClosure = (roots) => new Set(collectStaticChunks(chunks, roots).flatMap((chunk) => [...sharesInChunk.get(chunk.fileName) ?? []]));
+	const lazyShares = new Set([...sharesInChunk.values()].flatMap((shares) => [...shares]));
+	for (const share of sharesInClosure(startupRoots)) lazyShares.delete(share);
+	const sharesByChunk = /* @__PURE__ */ new Map();
+	if (lazyShares.size > 0) for (const fileName of sharesInChunk.keys()) {
+		const shares = [...sharesInClosure([fileName])].filter((share) => lazyShares.has(share));
+		if (shares.length > 0) sharesByChunk.set(fileName, shares.sort());
+	}
+	return {
+		lazyShares,
+		sharesByChunk
+	};
+}
+const COMMENTS = String.raw`(?:\s|\/\*[\s\S]*?\*\/|\/\/[^\n]*\n)*`;
+const DYNAMIC_IMPORT_REGEX = new RegExp(String.raw`\bimport\(${COMMENTS}(["'` + "`" + String.raw`])([^"'` + "`" + String.raw`\n]+)\1${COMMENTS}\)`, "g");
+const QUOTES = [
+	"\"",
+	"'",
+	"`"
+];
+/**
+* A consume-only (`import: false`) share that only a dynamic `import()` reaches is
+* left out of `init()` and bridged when that import runs: the import expression is
+* wrapped so the share is in the cache before the chunk evaluates. There is no
+* other async boundary in an ESM graph without top-level await, so a wrapper
+* reached statically from an entry or an expose keeps loading during `init()`.
+*/
+function pluginLazyConsumeOnlyShares(options) {
+	let viteConfig;
+	const graphs = /* @__PURE__ */ new WeakMap();
+	const helperName = `__mfLoadLazyShares_${options.internalName.replace(/[^A-Za-z0-9_$]/g, "_")}`;
+	return {
+		name: "module-federation:lazy-consume-only-shares",
+		apply: "build",
+		configResolved(config) {
+			viteConfig = config;
+		},
+		renderChunk(code, chunk, _outputOptions, meta) {
+			const renderedChunk = chunk;
+			const chunks = meta?.chunks;
+			if (!chunks || Object.keys(options.exposes).length === 0) return null;
+			if (isServerBuildContext(this, viteConfig)) return null;
+			let graph = graphs.get(chunks);
+			if (!graph) {
+				const isRolldown = getIsRolldown(this);
+				const wrapperShares = /* @__PURE__ */ new Map();
+				for (const shareKey of getUsedShares(options)) {
+					const shareConfig = getNormalizeShareItem(shareKey, options)?.shareConfig;
+					if (shareConfig?.import !== false || shareConfig.eager || shareConfig.treeShaking) continue;
+					wrapperShares.set(normalizeVirtualModuleId(getLoadShareModulePath(shareKey, isRolldown, options)), shareKey);
+				}
+				const root = viteConfig?.root ?? process.cwd();
+				graph = buildLazyShareGraph(chunks, wrapperShares, new Set(Object.values(options.exposes).map((expose) => stripKnownJsExtension(path$1.resolve(root, expose.import)))));
+				graphs.set(chunks, graph);
+			}
+			if (graph.lazyShares.size === 0) return null;
+			const rewriter = new CodeRewriter(code);
+			let edited = false;
+			const importMapId = normalizeVirtualModuleId(getLocalSharedImportMapPath(options));
+			if (chunkModuleIds(renderedChunk).some((id) => normalizeVirtualModuleId(id) === importMapId)) for (const quote of QUOTES) {
+				const literal = `${quote}${LAZY_CONSUME_ONLY_SHARES_PLACEHOLDER}${quote}`;
+				const start = code.indexOf(literal);
+				if (start === -1) continue;
+				rewriter.overwrite(start, start + literal.length, JSON.stringify([...graph.lazyShares].sort()));
+				edited = true;
+				break;
+			}
+			const chunkDir = path$1.posix.dirname(renderedChunk.fileName);
+			const codePositions = createCodePositionMap(code);
+			let usesHelper = false;
+			for (const match of code.matchAll(DYNAMIC_IMPORT_REGEX)) {
+				const [expression, , specifier] = match;
+				const start = match.index;
+				if (!codePositions[start]) continue;
+				const target = path$1.posix.normalize(path$1.posix.join(chunkDir, specifier));
+				const shares = graph.sharesByChunk.get(target);
+				if (!shares || !renderedChunk.dynamicImports.includes(target)) continue;
+				rewriter.overwrite(start, start + expression.length, `${helperName}(${JSON.stringify(shares)}).then(() => ${expression})`);
+				usesHelper = edited = true;
+			}
+			if (!edited) return null;
+			if (usesHelper) {
+				const stateKey = JSON.stringify(getRuntimeInitGlobalKey(getRuntimeInitStatusImportId(options)));
+				rewriter.overwrite(code.length, code.length, `
+function ${helperName}(names) {
+  const state = globalThis[${stateKey}];
+  return state ? state.initPromise.then(() => (typeof state.loadLazyShares === "function" ? state.loadLazyShares(names) : undefined)) : Promise.resolve();
+}
+`);
+			}
+			return {
+				code: rewriter.toString(),
+				map: rewriter.generateMap(renderedChunk.fileName)
+			};
+		}
+	};
+}
+//#endregion
+//#region package.json
+var version$1 = "1.23.0";
+//#endregion
 //#region src/virtualModules/virtualExposesSSR.ts
 /**
 * Virtual module ID for the SSR exposes map.
@@ -7643,7 +8359,8 @@ function getSsrFileNameParts(browserFilename) {
 		ext
 	};
 }
-function getSsrRemoteEntryFileName(browserFilename) {
+function getSsrRemoteEntryFileName(options, browserFilename = options.filename) {
+	if (options.ssrFilename) return options.ssrFilename;
 	const { base, ext } = getSsrFileNameParts(browserFilename);
 	return `${base}.ssr${ext ?? ".js"}`;
 }
@@ -7657,14 +8374,15 @@ function getSsrSharedSingletons(options) {
 	const result = {};
 	for (const [pkg, share] of Object.entries(options.shared)) {
 		if (!share.shareConfig.singleton) continue;
-		if (pkg.endsWith("/")) {
-			for (const concrete of expandSharedPrefixKey(pkg, used)) result[concrete] = {
+		const request = getSharedRequest(pkg, share);
+		if (request.endsWith("/")) {
+			for (const concrete of expandSharedPrefixKey(request, used)) result[getSharedRuntimeKey(concrete, share)] = {
 				...share,
 				name: concrete
 			};
 			continue;
 		}
-		result[pkg] = share;
+		result[getSharedRuntimeKey(pkg, share)] = share;
 	}
 	return result;
 }
@@ -8009,7 +8727,7 @@ const Manifest = (providedOptions) => {
 									type: "module"
 								},
 								ssrRemoteEntry: {
-									name: getSsrRemoteEntryFileName(devRemoteEntryFile),
+									name: getSsrRemoteEntryFileName(mfOptions, devRemoteEntryFile),
 									path: "/__mf_ssr__/",
 									type: "module"
 								},
@@ -8052,6 +8770,33 @@ const Manifest = (providedOptions) => {
 			publicPath = mfOptions.publicPath === "auto" ? "auto" : resolvePublicPath(mfOptions, base, _originalConfigBase);
 		},
 		/**
+		* A standalone `vite build --ssr` may run with its own `filename`, e.g.
+		* `defineConfig(({ isSsrBuild }) => ...)`. The manifest written by the
+		* earlier client build then advertises an SSR entry derived from the
+		* browser filename, which is not the file this build emitted. Point the
+		* manifest and stats on disk at the emitted SSR entry.
+		*/
+		writeBundle(outputOptions) {
+			if (!mfManifestName || _command !== "build" || isConsumerProject) return;
+			const environment = this.environment;
+			if (!(environment ? environment.name === "ssr" : Boolean(viteConfig?.build?.ssr))) return;
+			const ssrEntryName = getSsrRemoteEntryFileName(mfOptions);
+			const outDirs = [...new Set([outputOptions.dir, viteConfig?.environments?.client?.build?.outDir].filter((dir) => typeof dir === "string").map((dir) => path$1.resolve(root, dir)))];
+			if (!outDirs.some((dir) => fs$1.existsSync(path$1.resolve(dir, ssrEntryName)))) return;
+			for (const dir of outDirs) for (const fileName of [mfManifestName, mfManifestStatsName]) {
+				if (!fileName) continue;
+				const file = path$1.resolve(dir, fileName);
+				if (!fs$1.existsSync(file)) continue;
+				try {
+					const data = JSON.parse(fs$1.readFileSync(file, "utf8"));
+					const entry = data?.metaData?.ssrRemoteEntry;
+					if (!entry || typeof entry !== "object" || entry.name === ssrEntryName) continue;
+					entry.name = ssrEntryName;
+					fs$1.writeFileSync(file, JSON.stringify(data));
+				} catch {}
+			}
+		},
+		/**
 		* Generates the module federation manifest file
 		* @param options - Rollup output options
 		* @param bundle - Generated bundle assets
@@ -8061,10 +8806,10 @@ const Manifest = (providedOptions) => {
 			if (this.environment?.name === "ssr") return;
 			let filesMap = {};
 			const foundRemoteEntryFile = findRemoteEntryFile(mfOptions.filename, bundle);
-			const expectedSsrRemoteEntryFile = getSsrRemoteEntryFileName(mfOptions.filename);
+			const expectedSsrRemoteEntryFile = getSsrRemoteEntryFileName(mfOptions);
 			const foundSsrRemoteEntryFile = Object.values(bundle).find((file) => file.fileName === expectedSsrRemoteEntryFile)?.fileName;
 			if (foundRemoteEntryFile) remoteEntryFile = foundRemoteEntryFile;
-			ssrRemoteEntryFile = foundSsrRemoteEntryFile || (_command === "serve" ? getSsrRemoteEntryFileName(resolveHashPlaceholderFileName(mfOptions.filename)) : expectedSsrRemoteEntryFile);
+			ssrRemoteEntryFile = foundSsrRemoteEntryFile || (_command === "serve" ? getSsrRemoteEntryFileName(mfOptions, resolveHashPlaceholderFileName(mfOptions.filename)) : expectedSsrRemoteEntryFile);
 			const allCssAssets = mfOptions.bundleAllCSS && !disableAssetsAnalyze ? collectCssAssets(bundle) : /* @__PURE__ */ new Set();
 			if (allCssAssets.size > 0) {
 				const secondaryCss = /* @__PURE__ */ new Set();
@@ -8089,14 +8834,25 @@ const Manifest = (providedOptions) => {
 				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);
@@ -8130,7 +8886,7 @@ const Manifest = (providedOptions) => {
 			type: "module"
 		};
 		const ssrRemoteEntry = {
-			name: ssrRemoteEntryFile || getSsrRemoteEntryFileName(_command === "serve" ? resolveHashPlaceholderFileName(filename) : filename),
+			name: ssrRemoteEntryFile || getSsrRemoteEntryFileName(mfOptions, _command === "serve" ? resolveHashPlaceholderFileName(filename) : filename),
 			path: _command === "serve" ? "/__mf_ssr__/" : "",
 			type: "module"
 		};
@@ -8447,6 +9203,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		return cleanId.includes(getHostAutoInitPath(options)) || cleanId.includes(getHostAutoInitPath());
 	};
 	const getEnvironmentConditions = (context) => context.environment?.config?.resolve?.conditions;
+	const isSsrBuild = (context) => isServerBuildContext(context, viteConfig);
 	function isRemoteImport(source) {
 		return Object.keys(options.remotes).some((name) => source === name || source.startsWith(name + "/"));
 	}
@@ -8550,7 +9307,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 			}
 		},
 		async load(id) {
-			if (id === remoteEntryId) return getParsePromise().then((_) => generateRemoteEntry(options, virtualExposesId, _command, getEnvironmentConditions(this)));
+			if (id === remoteEntryId) return getParsePromise().then((_) => generateRemoteEntry(options, virtualExposesId, _command, getEnvironmentConditions(this), isSsrBuild(this)));
 			if (id === virtualExposesId) {
 				await refreshExposeRemoteDependencies(this);
 				return generateExposes(options, exposeRemoteDependencies, _command, reactIslandExposes);
@@ -8560,7 +9317,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		async transform(code, id) {
 			return mapCodeToCodeWithSourcemap(await (async () => {
 				if (!filterId(id)) return;
-				if (id.includes(remoteEntryId)) return getParsePromise().then((_) => generateRemoteEntry(options, virtualExposesId, _command, getEnvironmentConditions(this)));
+				if (id.includes(remoteEntryId)) return getParsePromise().then((_) => generateRemoteEntry(options, virtualExposesId, _command, getEnvironmentConditions(this), isSsrBuild(this)));
 				if (id === virtualExposesId) {
 					await refreshExposeRemoteDependencies(this);
 					return generateExposes(options, exposeRemoteDependencies, _command, reactIslandExposes);
@@ -8658,7 +9415,7 @@ function pluginProxyRemotes_default(options) {
 		const remoteModule = getRemoteVirtualModule(source, command, enableSsrInit, consumer, options);
 		addUsedRemote(remoteName, source, options);
 		refreshHostAutoInit(options);
-		return remoteModule.getImportId();
+		return remoteModule.getResolvedId();
 	}
 	return {
 		name: "proxyRemotes",
@@ -8678,7 +9435,7 @@ function pluginProxyRemotes_default(options) {
 		},
 		configResolved(config) {
 			hasMultiEnvironment = Boolean(config.environments?.ssr);
-			enableSsrInit = getSsrCapabilities(parseInt(version, 10), command, Object.keys(remotes).length > 0).enableSsrInitBootstrap;
+			enableSsrInit = getSsrCapabilities(parseInt(version, 10), command, Object.keys(remotes).length > 0, isSsrConfig(config)).enableSsrInitBootstrap;
 		},
 		resolveId(source, importer) {
 			const resolvedIslandConsumerId = resolveReactIslandConsumerId(source);
@@ -8702,6 +9459,96 @@ function pluginProxyRemotes_default(options) {
 	};
 }
 //#endregion
+//#region src/utils/sharedSource.ts
+const pendingEntryLookups = /* @__PURE__ */ new Map();
+const getEntryLookupKey = (source, importer) => `${source}\0${importer}`;
+/** Whether a resolveId call is one of the shared source resolver's own entry lookups. */
+function isSharedEntryLookup(source, importer, options) {
+	return options.custom?.__mfSharedEntryLookup === true || pendingEntryLookups.has(getEntryLookupKey(source, importer));
+}
+/** 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)) {
+			const request = getSharedRequest(key, shared[key]);
+			if (getPackageName(request) !== packageName) continue;
+			if (!request.endsWith("/")) candidates.add(request);
+			for (const subpath of getCommonSharedSubpaths(request)) 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;
+			const allowNodeModulesSuffixMatch = shared[findSharedKey(candidate, shared) ?? candidate]?.shareConfig?.allowNodeModulesSuffixMatch === true;
+			if (normalizeNodeModulePath(entry) === normalizeNodeModulePath(resolvedSource) || allowNodeModulesSuffixMatch && 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;
+				const importer = path$1.join(root, "package.json");
+				const lookupKey = getEntryLookupKey(request, importer);
+				pendingEntryLookups.set(lookupKey, (pendingEntryLookups.get(lookupKey) ?? 0) + 1);
+				try {
+					const resolved = await context.resolve(request, importer, {
+						...options,
+						skipSelf: true,
+						custom: {
+							...options.custom,
+							__mfSharedEntryLookup: true
+						}
+					});
+					return resolved && !resolved.external ? resolved.id : void 0;
+				} catch {
+					return;
+				} finally {
+					const remaining = pendingEntryLookups.get(lookupKey) - 1;
+					if (remaining) pendingEntryLookups.set(lookupKey, remaining);
+					else pendingEntryLookups.delete(lookupKey);
+				}
+			});
+			cache?.set(normalizedSource, result);
+			return result;
+		}
+	};
+}
+//#endregion
 //#region src/utils/PromiseStore.ts
 /**
 * example:
@@ -8742,7 +9589,7 @@ function tryResolveFromProjectRoot(source) {
 	const browserEntry = getInstalledPackageEntry(source, { cwd: getPackageDetectionCwd() });
 	if (browserEntry) return browserEntry;
 	try {
-		return createRequire$1(pathToFileURL(path$1.join(getPackageDetectionCwd(), "package.json"))).resolve(source);
+		return resolveModulePath(source, path$1.join(getPackageDetectionCwd(), "package.json"));
 	} catch {
 		return;
 	}
@@ -8751,23 +9598,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.
 */
@@ -8785,9 +9615,13 @@ function getPackageDependencies(pkg) {
 */
 function excludeSharedSubDependencies(shared) {
 	const sharedKeys = new Set(Object.keys(shared));
-	const sharedKeyByBase = new Map(Object.keys(shared).map((key) => [key.endsWith("/") ? key.slice(0, -1) : key, key]));
+	const requestBase = (key) => {
+		const request = getSharedRequest(key, shared[key]);
+		return request.endsWith("/") ? request.slice(0, -1) : request;
+	};
+	const sharedKeyByBase = new Map(Object.keys(shared).map((key) => [requestBase(key), key]));
 	for (const parentKey of sharedKeys) {
-		const deps = getPackageDependencies(parentKey);
+		const deps = getPackageDependencies(requestBase(parentKey));
 		for (const dep of deps) {
 			const depKey = sharedKeyByBase.get(dep);
 			if (depKey && depKey !== parentKey) {
@@ -9114,6 +9948,7 @@ function isSharedPackageRuntimeDependency(sharedKey, dependency, conditions) {
 function proxySharedModule(options) {
 	const { shared = {}, federationOptions, getParsePromise = () => Promise.resolve() } = options;
 	let _config;
+	const getBuildImportAnalysis = (environment) => getImportAnalysis(environment ?? _config ?? options);
 	let _command = "serve";
 	let useDirectReactImport = false;
 	let useRolldown = false;
@@ -9131,7 +9966,7 @@ function proxySharedModule(options) {
 	const getRuntimeDependencyConditions = (context, resolveOptions) => {
 		const environment = context.environment;
 		const environmentConfig = environment?.config;
-		const isSsr = resolveOptions.ssr === true || Boolean(_config?.build?.ssr) || environmentConfig?.consumer === "server" || Boolean(environmentConfig?.build?.ssr) || environment?.name === "ssr" || environment?.name === "server";
+		const isSsr = resolveOptions.ssr === true || Boolean(_config?.build?.ssr) || isServerEnvironment(environment?.name, environmentConfig);
 		return getSharedExportConditions({
 			environmentConditions: environmentConfig?.resolve?.conditions,
 			isProduction: environmentConfig?.isProduction ?? isProduction,
@@ -9141,6 +9976,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);
@@ -9183,14 +10022,15 @@ function proxySharedModule(options) {
 				}, federationOptions);
 			},
 			resolveId(source) {
-				if (source === getLocalSharedImportMapPath(federationOptions)) return getResolvedLocalSharedImportMapId(federationOptions);
+				const resolvedId = getResolvedLocalSharedImportMapId(federationOptions);
+				if (source === getLocalSharedImportMapPath(federationOptions) || source === resolvedId) return resolvedId;
 			},
 			load(id) {
 				if (id === getResolvedLocalSharedImportMapId(federationOptions)) return getParsePromise().then((_) => {
 					refreshTreeShakingForEnvironment(this);
-					const providerPackages = /* @__PURE__ */ new Set([...Object.keys(shared).filter((pkg) => !pkg.endsWith("/")), ...getUsedShares(federationOptions)]);
+					const providerPackages = /* @__PURE__ */ new Set([...Object.keys(shared).filter((pkg) => !getSharedRequest(pkg, shared[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);
 					}
@@ -9210,6 +10050,7 @@ function proxySharedModule(options) {
 				setTreeShakingBuildMode(command === "build", federationOptions);
 				resetTreeShakingExports(federationOptions);
 				emittedTreeShakingProviders.clear();
+				sharedSourceResolver.clear();
 				sharedDependencyCache.clear();
 				dependencyManifestCache.clear();
 				sharedRuntimeDependencyCache.clear();
@@ -9232,30 +10073,42 @@ function proxySharedModule(options) {
 				const resolvedOptions = federationOptions ?? getNormalizeModuleFederationOptions();
 				const registerConfiguredShare = _command === "build" && Object.keys(resolvedOptions.exposes).length > 0 ? addUsedShares : addConfiguredShare;
 				Object.keys(shared).forEach((key) => {
-					if (key.endsWith("/")) return;
-					if (useDirectReactImport && key === "react") {
-						registerConfiguredShare(key, federationOptions);
+					if (key.endsWith("/") || getSharedRequest(key, shared[key]).endsWith("/")) return;
+					const runtimeKey = getSharedRuntimeKey(key, shared[key]);
+					if (useDirectReactImport && runtimeKey === "react") {
+						registerConfiguredShare(runtimeKey, federationOptions);
 						return;
 					}
-					writeLoadShareModule(key, shared[key], _command, isRolldown, federationOptions);
-					if (shared[key].shareConfig.import !== false) writePreBuildLibPath(key, shared[key], federationOptions);
-					registerConfiguredShare(key, federationOptions);
+					writeLoadShareModule(runtimeKey, shared[key], _command, isRolldown, federationOptions);
+					if (shared[key].shareConfig.import !== false) writePreBuildLibPath(runtimeKey, shared[key], federationOptions);
+					registerConfiguredShare(runtimeKey, federationOptions);
 				});
 				writeLocalSharedImportMap(federationOptions);
 				refreshHostAutoInit(federationOptions);
 			},
+			watchChange() {
+				sharedSourceResolver.clear();
+			},
 			buildStart() {
+				sharedSourceResolver.clear();
 				if (_command !== "build") return;
+				if (hasAnalyzableShares) getBuildImportAnalysis(this.environment).clear();
 				resetTreeShakingExports(federationOptions);
 				emittedTreeShakingProviders.clear();
 				refreshTreeShakingForEnvironment(this);
 			},
+			buildEnd() {
+				if (_command === "build" && hasAnalyzableShares) getBuildImportAnalysis(this.environment).clear();
+			},
 			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), getBuildImportAnalysis(this.environment));
 				refreshTreeShakingForEnvironment(this);
 			}
 		},
@@ -9264,6 +10117,7 @@ function proxySharedModule(options) {
 			enforce: "pre",
 			apply: "build",
 			async resolveId(source, importer, resolveOptions) {
+				if (isSharedEntryLookup(source, importer, resolveOptions)) return;
 				const sourceToken = getTreeShakingGraphToken(source);
 				const importerToken = getTreeShakingGraphToken(importer);
 				const token = sourceToken || importerToken;
@@ -9271,7 +10125,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
@@ -9298,21 +10153,24 @@ 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 (isSharedEntryLookup(source, importer, resolveOptions) || 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 && 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;
-					if (importerIsUnsharedWorkspacePackage ? isSharedPackageRuntimeDependency(runtimeDependencyRequest, importerPackage, getRuntimeDependencyConditions(this, resolveOptions)) : isSharedPackageDependency(key, importerPackage)) return;
+					const request = getSharedRequest(key, shared[key]);
+					const runtimeDependencyRequest = request.endsWith("/") && matchesSharedSource(sharedSource, key, shared[key]) ? sharedSource : request;
+					if (importerIsUnsharedWorkspacePackage ? isSharedPackageRuntimeDependency(runtimeDependencyRequest, importerPackage, getRuntimeDependencyConditions(this, resolveOptions)) : isSharedPackageDependency(request, importerPackage)) return;
 				}
 				if (useDirectReactImport && key === "react") return;
 				if (isAssetLikeImport(source)) return;
@@ -9322,8 +10180,8 @@ 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;
-				if (shouldKeepSharedImportLocal(source, importer, key, shared, importerPackage)) {
+				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;
 				}
@@ -9613,17 +10471,21 @@ function collectFromRegex(code, isRemoteImport) {
 }
 function pluginRemoteNamedExports(options) {
 	const remoteNames = Object.keys(options.remotes);
+	let root = process.cwd();
 	const isNodeModulesId = (id) => id.includes("/node_modules/") || id.includes("\\node_modules\\");
 	function isRemoteImport(source, importerId) {
 		return remoteNames.some((name) => {
 			if (source.startsWith(name + "/")) return true;
 			if (source !== name) return false;
-			return !isNodeModulesId(importerId);
+			return !isNodeModulesId(importerId) || !getInstalledPackageEntry(source, { cwd: root });
 		}) || source.includes("__loadRemote__");
 	}
 	return {
 		name: "module-federation-remote-named-exports",
 		enforce: "post",
+		configResolved(config) {
+			root = config.root || process.cwd();
+		},
 		async transform(code, id) {
 			if (remoteNames.length === 0) return;
 			if (id.includes("__loadRemote__") || id.includes("__loadShare__")) return;
@@ -9649,7 +10511,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);
 }
@@ -9668,12 +10529,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);
@@ -9717,8 +10572,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)) {
@@ -9782,18 +10637,25 @@ function pluginSSRRemoteEntry(options) {
 	const remoteEntrySSRId = getRemoteEntrySSRId(options);
 	const virtualExposesSSRId = getVirtualExposesSSRId(options);
 	let cachedSsrRemoteEntrySource;
-	const ssrOutputFilename = getSsrRemoteEntryFileName(options.filename);
+	const ssrOutputFilename = getSsrRemoteEntryFileName(options);
 	const ssrExposesFileName = getSsrExposesFileName(options.filename);
 	let ssrOutputFiles = /* @__PURE__ */ new Set();
 	let ssrOutputDir = "";
 	let clientOutputDir = "";
-	const ssrOnlyExternals = [
+	const mfRuntimePackages = [
 		"@module-federation/runtime",
 		"@module-federation/runtime-core",
-		"@module-federation/sdk",
-		...options.ssrExternals ?? []
+		"@module-federation/sdk"
 	];
+	const ssrOnlyExternals = [...mfRuntimePackages, ...options.ssrExternals ?? []];
 	const ssrOnlyExternalPattern = new RegExp(`^(${ssrOnlyExternals.map((e) => e.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&")).join("|")})(\\/.*)?$`);
+	let noExternal;
+	const isNoExternal = (id) => {
+		const pkg = ssrOnlyExternalPattern.exec(id)?.[1] ?? id;
+		if (!noExternal || !mfRuntimePackages.includes(pkg)) return false;
+		if (noExternal === true) return true;
+		return (Array.isArray(noExternal) ? noExternal : [noExternal]).some((rule) => typeof rule === "string" ? rule === pkg : rule.test(pkg));
+	};
 	const ssrModuleIds = /* @__PURE__ */ new Set([remoteEntrySSRId, virtualExposesSSRId]);
 	const resolvedAbsToPackage = /* @__PURE__ */ new Map();
 	let isServe = false;
@@ -9824,7 +10686,9 @@ function pluginSSRRemoteEntry(options) {
 		enforce: "pre",
 		configResolved(config) {
 			isServe = config.command === "serve";
+			noExternal = config.environments?.ssr?.resolve?.noExternal ?? config.ssr?.noExternal;
 			for (const pkg of ssrOnlyExternals) {
+				if (isNoExternal(pkg)) continue;
 				const aliasEntry = (config.resolve?.alias)?.find((a) => a.find === pkg || a.find instanceof RegExp && a.find.test(pkg));
 				if (aliasEntry?.replacement) resolvedAbsToPackage.set(aliasEntry.replacement, pkg);
 			}
@@ -9833,7 +10697,7 @@ function pluginSSRRemoteEntry(options) {
 			if (id === remoteEntrySSRId || id.startsWith(remoteEntrySSRId)) return id;
 			if (id === virtualExposesSSRId || id.startsWith(virtualExposesSSRId)) return id;
 			if (!importer || !ssrModuleIds.has(importer)) return;
-			if (ssrOnlyExternalPattern.test(id)) return {
+			if (ssrOnlyExternalPattern.test(id) && !isNoExternal(id)) return {
 				id,
 				external: true
 			};
@@ -9858,7 +10722,7 @@ function pluginSSRRemoteEntry(options) {
 		configureServer(server) {
 			const base = "/__mf_ssr__";
 			const basePath = getBasePath$1(viteConfig?.base);
-			const ssrEntryFileName = getSsrRemoteEntryFileName(options.filename);
+			const ssrEntryFileName = getSsrRemoteEntryFileName(options);
 			if (isNuxtProject || isNuxtClientBase(basePath)) server.middlewares.use((req, _res, next) => {
 				if (req.url?.replace(/\?.*/, "") === `${basePath}/${ssrEntryFileName}`) req.url = `${basePath}/__mf_ssr__/${ssrEntryFileName}`;
 				next();
@@ -9927,7 +10791,7 @@ function pluginSSRRemoteEntry(options) {
 		resolveId(id) {
 			if (id === remoteEntrySSRId || id.startsWith(remoteEntrySSRId)) return id;
 			if (id === virtualExposesSSRId || id.startsWith(virtualExposesSSRId)) return id;
-			if (id === `/__mf_ssr__/${getSsrRemoteEntryFileName(options.filename)}`) return remoteEntrySSRId;
+			if (id === `/__mf_ssr__/${getSsrRemoteEntryFileName(options)}`) return remoteEntrySSRId;
 			if (id === `/__mf_ssr__/${ssrExposesFileName}`) return virtualExposesSSRId;
 		},
 		load(id) {
@@ -10132,6 +10996,85 @@ var aliasToArrayPlugin_default = {
 	}
 };
 //#endregion
+//#region src/utils/deferredPrebuildHelper.ts
+function isExportAllHelper(code, exportName) {
+	try {
+		const ast = parseAst(code);
+		let localName;
+		for (const node of ast.body) {
+			if (node.type !== "ExportNamedDeclaration") continue;
+			for (const specifier of node.specifiers) if (specifier.type === "ExportSpecifier" && specifier.exported.type === "Identifier" && specifier.exported.name === exportName && specifier.local.type === "Identifier") localName = specifier.local.name;
+		}
+		if (!localName) return false;
+		for (const node of ast.body) {
+			if (node.type !== "VariableDeclaration") continue;
+			for (const declaration of node.declarations) {
+				if (declaration.id.type !== "Identifier" || declaration.id.name !== localName) continue;
+				const initializer = declaration.init;
+				if (!initializer) return false;
+				const source = code.slice(initializer.start, initializer.end);
+				return source.includes("Symbol.toStringTag") && source.includes("Module");
+			}
+		}
+	} catch {}
+	return false;
+}
+/**
+* Rolldown sometimes places its shared namespace helper in a local prebuild
+* chunk. A loadShare wrapper then imports that helper statically, evaluating the
+* fallback even when a host provider is already in the cache. Inline only the
+* recognized Rolldown helper; leave every other prebuild import untouched.
+*/
+function inlineDeferredPrebuildNamespaceHelper(bundle) {
+	for (const chunk of Object.values(bundle)) {
+		if (chunk.type !== "chunk" || !chunk.fileName.includes("__loadShare__")) continue;
+		let ast;
+		try {
+			ast = parseAst(chunk.code);
+		} catch {
+			continue;
+		}
+		const edits = [];
+		const deferredSources = /* @__PURE__ */ new Set();
+		forEachAstNode(ast, (node) => {
+			if (node.type !== "ImportExpression") return;
+			const source = getModuleSource(node.source);
+			if (source) deferredSources.add(source);
+		});
+		const retainedImports = /* @__PURE__ */ new Set();
+		const removedImports = /* @__PURE__ */ new Set();
+		for (const node of ast.body) {
+			if (node.type !== "ImportDeclaration") continue;
+			const source = getModuleSource(node.source);
+			if (!source) continue;
+			const targetName = path.posix.normalize(path.posix.join(path.posix.dirname(chunk.fileName), source));
+			const [specifier] = node.specifiers;
+			const exported = specifier?.type === "ImportSpecifier" && specifier.imported;
+			const target = bundle[targetName];
+			if (!source.includes("__prebuild__") || node.specifiers.length !== 1 || !exported || exported.type !== "Identifier" || target?.type !== "chunk" || !deferredSources.has(source) || !Object.keys(target.modules ?? {}).some((id) => id.includes("rolldown/runtime.js")) || !isExportAllHelper(target.code, exported.name)) {
+				retainedImports.add(targetName);
+				continue;
+			}
+			removedImports.add(targetName);
+			edits.push({
+				start: node.start,
+				end: node.end,
+				replacement: `const ${specifier.local.name} = (all, noSymbols) => {
+          const namespace = {};
+          for (const name in all) Object.defineProperty(namespace, name, {
+            get: all[name], enumerable: true,
+          });
+          if (!noSymbols) Object.defineProperty(namespace, Symbol.toStringTag, { value: 'Module' });
+          return namespace;
+        };`
+			});
+		}
+		if (edits.length === 0) continue;
+		for (const edit of edits.reverse()) chunk.code = chunk.code.slice(0, edit.start) + edit.replacement + chunk.code.slice(edit.end);
+		if (chunk.imports) chunk.imports = chunk.imports.filter((imported) => !removedImports.has(imported) || retainedImports.has(imported));
+	}
+}
+//#endregion
 //#region src/utils/controlChunkSanitizer.ts
 const FEDERATION_CONTROL_CHUNK_HINTS = ["hostInit", "localSharedImportMap"];
 function stripEmptyPreloadCalls(code) {
@@ -10253,7 +11196,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
@@ -10349,7 +11292,7 @@ function isFederationHtmlPreloadDependency(dep, includeSharedRuntime = false) {
 }
 function canResolveSharedSubpath(subpath, projectRoot) {
 	try {
-		return isViteOptimizableEntry(createRequire$1(pathToFileURL(path$1.join(projectRoot, "package.json"))).resolve(subpath));
+		return isViteOptimizableEntry(resolveModulePath(subpath, path$1.join(projectRoot, "package.json")));
 	} catch (error) {
 		if (error?.code === "ERR_PACKAGE_PATH_NOT_EXPORTED" && !isBarePackageSubpath(subpath)) {
 			const entry = resolveViteImportPackageEntry(subpath, projectRoot);
@@ -10564,6 +11507,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);
@@ -10576,21 +11520,31 @@ 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 || {};
 					config.optimizeDeps.include = config.optimizeDeps.include || [];
 					const optimizeDeps = config.optimizeDeps;
+					const preparedShares = /* @__PURE__ */ new Map();
+					const writeSharedModules = (source, shareItem) => {
+						if (preparedShares.get(source) === shareItem) return;
+						writeLoadShareModule(source, shareItem, _command, isRolldown, options);
+						if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(source, shareItem, options);
+						preparedShares.set(source, shareItem);
+					};
 					if (isRolldown) {
 						optimizeDeps.rolldownOptions ??= {};
 						optimizeDeps.rolldownOptions.plugins ??= [];
 						optimizeDeps.rolldownOptions.plugins.push({
 							name: "module-federation:optimize-shared-resolver",
+							buildStart() {
+								preparedShares.clear();
+							},
 							load(id) {
 								if (!id.startsWith("module-federation:optimized-require-")) return;
 								const sourcePackage = id.slice(36);
@@ -10618,13 +11572,11 @@ function createEarlyVirtualModulesPlugin(options) {
 								if (isCommonJsImporter(importer) && !isReactSingleton && !isReactDomRequire) return;
 								if (resolveOptions?.kind !== "entry-point") addUsedShares(source, options);
 								if (isReactRequire || isReactDomRequire) {
-									writeLoadShareModule(source, shareItem, _command, isRolldown, options);
-									if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(source, shareItem, options);
+									writeSharedModules(source, shareItem);
 									return { id: `module-federation:optimized-require-${source}` };
 								}
 								const loadSharePath = getLoadShareModulePath(source, isRolldown, options);
-								writeLoadShareModule(source, shareItem, _command, isRolldown, options);
-								if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(source, shareItem, options);
+								writeSharedModules(source, shareItem);
 								return {
 									id: loadSharePath,
 									external: true
@@ -10637,6 +11589,9 @@ function createEarlyVirtualModulesPlugin(options) {
 						optimizeDeps.esbuildOptions.plugins.push({
 							name: "module-federation:optimize-shared-proxy",
 							setup(build) {
+								build.onStart(() => {
+									preparedShares.clear();
+								});
 								build.onResolve({ filter: createViteEncodedIdPrefixRegExp("virtual:mf:") }, (args) => ({
 									path: args.path,
 									external: true
@@ -10654,8 +11609,7 @@ function createEarlyVirtualModulesPlugin(options) {
 									if (args.kind === "import-statement" || args.kind === "dynamic-import") {
 										const shareItem = shared[key];
 										const loadSharePath = getLoadShareModulePath(args.path, isRolldown, options);
-										writeLoadShareModule(args.path, shareItem, _command, isRolldown, options);
-										if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(args.path, shareItem, options);
+										writeSharedModules(args.path, shareItem);
 										return {
 											path: loadSharePath,
 											external: true
@@ -10674,8 +11628,7 @@ function createEarlyVirtualModulesPlugin(options) {
 									if (!key) return;
 									const shareItem = shared[key];
 									const loadSharePath = getLoadShareModulePath(args.path, isRolldown, options);
-									writeLoadShareModule(args.path, shareItem, _command, isRolldown, options);
-									if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(args.path, shareItem, options);
+									writeSharedModules(args.path, shareItem);
 									return {
 										loader: "js",
 										resolveDir: root,
@@ -10690,12 +11643,14 @@ export default __mfShared.default ?? __mfShared;`
 				}
 				for (const key of Object.keys(shared)) {
 					const shareItem = shared[key];
-					if (key.endsWith("/")) {
+					const request = getSharedRequest(key, shareItem);
+					const runtimeKey = getSharedRuntimeKey(key, shareItem);
+					if (key.endsWith("/") || request.endsWith("/") || runtimeKey.endsWith("/")) {
 						if (_command === "serve" && shareItem.shareConfig?.import !== false) {
 							const optimizeDeps = config.optimizeDeps ??= {};
 							optimizeDeps.include ??= [];
 							optimizeDeps.exclude ??= [];
-							for (const subpath of getCommonSharedSubpaths(key)) {
+							for (const subpath of getCommonSharedSubpaths(request)) {
 								writePreBuildLibPath(subpath, shareItem, options);
 								if (canResolveSharedSubpath(subpath, root)) optimizeDeps.include.push(subpath);
 								else optimizeDeps.exclude.push(subpath);
@@ -10703,23 +11658,24 @@ export default __mfShared.default ?? __mfShared;`
 						}
 						continue;
 					}
-					if (isVinext && key === "react") {
-						addConfiguredShare(key, options);
+					if (isVinext && runtimeKey === "react") {
+						addConfiguredShare(runtimeKey, options);
 						continue;
 					}
-					getLoadShareModulePath(key, isRolldown, options);
-					writeLoadShareModule(key, shareItem, _command, isRolldown, options);
-					if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(key, shareItem, options);
-					addConfiguredShare(key, options);
+					getLoadShareModulePath(runtimeKey, isRolldown, options);
+					writeLoadShareModule(runtimeKey, shareItem, _command, isRolldown, options);
+					if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(runtimeKey, shareItem, options);
+					addConfiguredShare(runtimeKey, options);
 					if (_command === "serve" && shareItem.shareConfig?.import !== false) {
 						const optimizeDeps = config.optimizeDeps ??= {};
 						optimizeDeps.include ??= [];
 						optimizeDeps.exclude ??= [];
-						const shouldBypassOptimizeDep = isLitShare(key) || !canResolveSharedSubpath(key, root);
-						if (optimizeDeps.include.includes(key)) optimizeDeps.exclude = optimizeDeps.exclude.filter((dep) => dep !== key);
-						else if (shouldBypassOptimizeDep || optimizeDeps.exclude.includes(key)) optimizeDeps.exclude.push(key);
-						else optimizeDeps.include.push(key);
-						for (const subpath of getCommonSharedSubpaths(key)) {
+						const shouldBypassOptimizeDep = isLitShare(runtimeKey) || !canResolveSharedSubpath(runtimeKey, root);
+						if (optimizeDeps.include.includes(runtimeKey)) optimizeDeps.exclude = optimizeDeps.exclude.filter((dep) => dep !== runtimeKey);
+						else if (shouldBypassOptimizeDep || optimizeDeps.exclude.includes(runtimeKey)) optimizeDeps.exclude.push(runtimeKey);
+						else optimizeDeps.include.push(runtimeKey);
+						const commonSubpaths = shareItem.shareConfig.request === void 0 && shareItem.shareConfig.shareKey === void 0 ? getCommonSharedSubpaths(runtimeKey) : [];
+						for (const subpath of commonSubpaths) {
 							const canResolveSubpath = canResolveSharedSubpath(subpath, root);
 							if ([
 								"react/compiler-runtime",
@@ -10735,7 +11691,7 @@ export default __mfShared.default ?? __mfShared;`
 							addConfiguredShare(subpath, options);
 							if (canResolveSubpath) {
 								optimizeDeps.include.push(subpath);
-								if (key === "react-dom") optimizeDeps.include.push(`${key} > ${subpath}`);
+								if (runtimeKey === "react-dom") optimizeDeps.include.push(`${runtimeKey} > ${subpath}`);
 							} else optimizeDeps.exclude.push(subpath);
 						}
 					}
@@ -10753,10 +11709,8 @@ export default __mfShared.default ?? __mfShared;`
 				const automaticJsxRuntime = getAutomaticJsxRuntime(config);
 				if (automaticJsxRuntime && materializeAutomaticJsxRuntime(options, automaticJsxRuntime)) writeLocalSharedImportMap(options);
 			}
-			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;
+			if (!getSsrCapabilities(parseInt(version, 10), config.command, hasRemotes(options), isSsrConfig(config)).injectSsrEntryLoader) return;
+			if (options.runtimePlugins.some((p) => getRuntimePluginSpecifier(p) === "@module-federation/vite/ssrEntryLoader")) return;
 			const projectRequire = createRequire$1(pathToFileURL(path$1.join(config.root, "package.json")));
 			const sharedKeys = Object.keys(options.shared ?? {});
 			const commonSharedPkgs = [
@@ -10799,16 +11753,14 @@ function applyBuildTimeRuntimeDefines(define, options, { target, isAstro, defaul
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-D7Faa4NJ.js").then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-VSLhAx6d.js").then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {
 	return specifier === INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN || specifier.includes("injectExternalRuntimeCorePlugin") || specifier.includes("inject-external-runtime-core-plugin");
 }
 function hasInjectExternalRuntimeCorePlugin(runtimePlugins) {
-	return runtimePlugins.some((plugin) => {
-		return isInjectExternalRuntimeCorePlugin(typeof plugin === "string" ? plugin : plugin[0]);
-	});
+	return runtimePlugins.some((plugin) => isInjectExternalRuntimeCorePlugin(getRuntimePluginSpecifier(plugin)));
 }
 function resolveInjectExternalRuntimeCorePlugin() {
 	try {
@@ -10855,7 +11807,7 @@ function federation(mfUserOptions) {
 	const emittedRuntimeCapabilityWarnings = /* @__PURE__ */ new Set();
 	const getLoadHookExportConditions = (context, loadOptions) => {
 		const environment = context.environment;
-		const isSsr = loadOptions?.ssr === true || isSsrBuild || environment?.config?.consumer === "server" || Boolean(environment?.config?.build?.ssr) || environment?.name === "ssr" || environment?.name === "server";
+		const isSsr = loadOptions?.ssr === true || isSsrBuild || isServerEnvironment(environment?.name, environment?.config);
 		return getSharedExportConditions({
 			environmentConditions: environment?.config?.resolve?.conditions,
 			isProduction: environment?.config?.isProduction ?? isProduction,
@@ -10979,7 +11931,8 @@ function federation(mfUserOptions) {
 				ssrResolveConditions = config.ssr?.resolve?.conditions ? [...config.ssr.resolve.conditions] : void 0;
 				ssrTarget = config.ssr?.target ?? "node";
 				isProduction = config.isProduction;
-				const ssrCapabilities = getSsrCapabilities(parseInt(version, 10), command, Object.keys(options.remotes).length > 0);
+				const ssrCapabilities = getSsrCapabilities(parseInt(version, 10), command, Object.keys(options.remotes).length > 0, isSsrConfig(config));
+				resolveSharedVersions(shared, config.root);
 				initVirtualModules(command, remoteEntryId, ssrCapabilities.enableSsrInitBootstrap, options);
 			}
 		},
@@ -11028,6 +11981,7 @@ function federation(mfUserOptions) {
 			federationOptions: options,
 			getParsePromise: () => moduleParseController.parsePromise
 		}),
+		pluginLazyConsumeOnlyShares(options),
 		{
 			name: "module-federation-esm-shims",
 			enforce: "pre",
@@ -11079,6 +12033,7 @@ function federation(mfUserOptions) {
 						priority: USER_GROUP_MAX_PRIORITY
 					};
 				};
+				const federationGroupDebugName = supportsCodeSplittingGroupDebugName(this) ? { debugName: "module-federation" } : {};
 				let warnedAboutManualChunks = false;
 				let warnedAboutObjectManualChunks = false;
 				const applyManualChunks = (output, useCodeSplitting) => {
@@ -11086,11 +12041,13 @@ function federation(mfUserOptions) {
 					const isPatchedByPlugin = typeof output.manualChunks === "function" && patchedManualChunks.has(output.manualChunks);
 					const mfChunkName = function(id) {
 						if (id.includes(runtimeInitId) || id.includes("__mf_v__runtimeInit__mf_v__")) return "runtimeInit";
+						if (isSharedCacheHelpersId(id)) return getSharedChunkName(id);
 						if (id.includes("__loadShare__")) {
 							const pkg = getCachedLoadSharePkg(id);
 							const key = pkg && findSharedKey(pkg, shared);
-							if (useCodeSplitting && key && shared[key].shareConfig.eager === true) return "loadShare-eager";
+							if (key && shared[key].shareConfig.eager === true) return "loadShare-eager";
 							if (key && shared[key].shareConfig.import === false) return null;
+							if (pkg && !id.includes("commonjs-proxy") && isCoalescableLoadShareWrapper(pkg, options, id)) return getSharedChunkName(id);
 							const match = id.match(/([^/\\]+__loadShare__[^/\\]+)/);
 							return match ? match[1] : "loadShare";
 						}
@@ -11127,7 +12084,8 @@ function federation(mfUserOptions) {
 					};
 					const mfNameGroup = {
 						name: mfChunkName,
-						priority: MF_GROUP_PRIORITY
+						priority: MF_GROUP_PRIORITY,
+						...federationGroupDebugName
 					};
 					federationGroups.add(mfPreloadGroup);
 					federationGroups.add(mfNameGroup);
@@ -11200,7 +12158,14 @@ function federation(mfUserOptions) {
 					if (!virtualModule?.code) return null;
 					let code = virtualModule.code;
 					const consumerTarget = resolveEnvironmentConsumerTarget(this);
-					if (consumerTarget === "server" || !consumerTarget && isSsrBuild) code = prependWorkspaceSingletonSsrImport(code);
+					if (consumerTarget === "server" || !consumerTarget && isSsrBuild) {
+						const withSsrImport = prependWorkspaceSingletonSsrImport(code);
+						if (withSsrImport !== code) {
+							const pkg = getCachedLoadSharePkg(id);
+							if (pkg) markLoadShareWrapperNotCoalescable(pkg, options, id);
+							code = withSsrImport;
+						}
+					}
 					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))) {
@@ -11218,6 +12183,9 @@ function federation(mfUserOptions) {
 				return loadVirtualModule();
 			},
 			generateBundle(_outputOptions, bundle, _isWrite) {
+				inlineDeferredPrebuildNamespaceHelper(bundle);
+				for (const [fileName, fallbacks] of findEagerFallbacksInSharedChunk(bundle)) mfWarn(`A shared-dependency fallback was merged into the loadShare chunk ${fileName}: ${fallbacks.join(", ")}.\n  That fallback is no longer lazy, so consumers download their local copy even when a peer provides the share, and the container can deadlock.
+  Stop the shared module from statically importing another share.`);
 				for (const [fileName, chunk] of Object.entries(bundle)) {
 					if (!isOutputChunk(chunk)) continue;
 					if (!isFederationControlChunk(fileName, filename)) continue;
@@ -11266,7 +12234,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)
@@ -11283,7 +12251,7 @@ function federation(mfUserOptions) {
 				config.optimizeDeps.include.push("@module-federation/runtime");
 				if (needsRuntimeHelpers) config.optimizeDeps.include.push("@module-federation/runtime/helpers");
 				options.runtimePlugins.forEach((p) => {
-					const pluginPath = typeof p === "string" ? p : p[0];
+					const pluginPath = getRuntimePluginSpecifier(p);
 					if (SSR_ONLY_RUNTIME_PLUGINS.has(pluginPath)) return;
 					if (pluginPath && !pluginPath.startsWith(".") && !pluginPath.startsWith("/") && !pluginPath.startsWith("\0") && !pluginPath.startsWith("virtual:")) {
 						let optimizeDep = pluginPath;
@@ -11319,7 +12287,7 @@ function federation(mfUserOptions) {
 				if (prematureExit) prematureExit.closeBundle = void 0;
 			},
 			configEnvironment(name, config) {
-				if (!(config.consumer === "server" || name === "ssr" || name === "server" || config.build?.ssr === true)) return;
+				if (!isServerEnvironment(name, config)) return;
 				const isAstro = hasPackageDependency("astro");
 				config.define = { ...config.define ?? {} };
 				applyBuildTimeRuntimeDefines(config.define, options, {