@module-federation/vite 1.22.1 → 1.23.0

package/lib/index.js

@@ -1,6 +1,6 @@
-import { _ as stripViteFsPrefix, a as ensureTrailingSlash, c as getCommonSharedSubpaths, d as isNodeModulePath, f as isNuxtClientBase, g as stripQueryAndHash, h as resolvePublicPath, l as getNodeModulesSuffix, m as normalizeNodeModulePath, n as invalidateSharedKeyMatcher, o as filterId, p as isViteOptimizableEntry, r as matchesSharedSource, s as getBasePath$1, t as findSharedKey, u as isAssetLikeImport } from "./sharedKeyMatcher-BRzBCbuR.js";
+import { _ 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 { _ as sharedCacheHelperCode, a as getPackageDetectionCwd, b as mfWarn, c as getSharedCacheDescriptor, d as isPackageExportAvailable, f as isPackageInstalled, g as setPackageDetectionCwd, h as resolveImportPath, i as getIsRolldown, l as hasPackageDependency, m as packageNameEncode, n as getInstalledPackageEntry, o as getPackageName, p as packageNameDecode, r as getInstalledPackageJson, s as getPackageNameFromNodeModulePath, u as isNuxtProjectRoot, v as createModuleFederationError } from "./dtsConstants-dDsHZFC1.js";
+import { 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";
@@ -862,6 +873,11 @@ function normalizeShareItem(key, shareItem) {
 	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 config = typeof shareItem === "object" ? shareItem : {};
 	const { version, requiredVersion } = resolveSharedVersion(key, config, getPackageDetectionCwd());
@@ -892,6 +908,9 @@ function normalizeShareItem(key, shareItem) {
 			eager: shareItem.eager || false,
 			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 } } : {}
 		}
@@ -941,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]);
 	});
@@ -1018,7 +1038,12 @@ function isExplicitSharedKey(key, options) {
 }
 function getNormalizeShareItem(key, options = getNormalizeModuleFederationOptions()) {
 	const matchedKey = findSharedKey(key, options.shared);
-	return options.shared[key] || (matchedKey ? options.shared[matchedKey] : void 0) || options.shared[getPackageName(key)] || options.shared[getPackageName(key) + "/"];
+	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");
@@ -1026,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,
@@ -1131,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}`;
@@ -1162,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
@@ -1276,106 +1327,48 @@ function isParsableExpression(source) {
 	}
 }
 //#endregion
-//#region src/utils/treeShaking.ts
-function shouldAnalyzeSharedExports(shareItem) {
-	return !!(shareItem && (shareItem.shareConfig.treeShaking || shareItem.shareConfig.import === false));
+//#region src/utils/runtimePluginSpecifier.ts
+function getRuntimePluginSpecifier(plugin) {
+	return typeof plugin === "string" ? plugin : plugin[0];
 }
-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;
+/** 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();
 /**
-* 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.
+* 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 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 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 analysis;
 }
-function getTreeShakingExportUsage(request, shareItem, sharedKey, options) {
-	if (!shareItem?.shareConfig.treeShaking) return void 0;
-	return getSharedExportUsage(request, shareItem, sharedKey, options);
+function isRecord(value) {
+	return value !== null && typeof value === "object";
 }
 function getModuleSource(node) {
-	if (!node || typeof node !== "object") return void 0;
+	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;
@@ -1383,11 +1376,13 @@ function getModuleSource(node) {
 	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;
+	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 getExportedName(node) {
-	if (!node || typeof node !== "object") return void 0;
+	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;
@@ -1400,7 +1395,7 @@ function forEachAstNode(root, visit) {
 	const seen = /* @__PURE__ */ new Set();
 	while (stack.length > 0) {
 		const value = stack.pop();
-		if (!value || typeof value !== "object") continue;
+		if (!isRecord(value)) continue;
 		if (seen.has(value)) continue;
 		seen.add(value);
 		if (Array.isArray(value)) {
@@ -1414,18 +1409,22 @@ function forEachAstNode(root, visit) {
 		});
 	}
 }
-function collectImportDeclaration(node, source, record, markUnsafe) {
+function collectImportDeclaration(node, source, record, requireAllExports) {
 	if (isTypeOnly(node)) return;
 	const specifiers = Array.isArray(node.specifiers) ? node.specifiers : [];
 	if (specifiers.length === 0) {
-		markUnsafe(source);
+		requireAllExports(source);
 		return;
 	}
 	const names = [];
 	for (const specifier of specifiers) {
+		if (!isRecord(specifier)) {
+			requireAllExports(source);
+			return;
+		}
 		if (isTypeOnly(specifier)) continue;
 		if (specifier.type === "ImportNamespaceSpecifier") {
-			markUnsafe(source);
+			requireAllExports(source);
 			return;
 		}
 		if (specifier.type === "ImportDefaultSpecifier") {
@@ -1434,118 +1433,246 @@ function collectImportDeclaration(node, source, record, markUnsafe) {
 		}
 		if (specifier.type === "ImportSpecifier") {
 			const imported = specifier.imported;
-			if (imported?.type === "Literal" || imported?.type === "StringLiteral") {
-				markUnsafe(source);
+			if (isRecord(imported) && (imported.type === "Literal" || imported.type === "StringLiteral")) {
+				requireAllExports(source);
 				return;
 			}
 			const name = getExportedName(specifier.imported);
 			if (!name) {
-				markUnsafe(source);
+				requireAllExports(source);
 				return;
 			}
 			names.push(name);
 			continue;
 		}
-		markUnsafe(source);
+		requireAllExports(source);
 		return;
 	}
 	record(names, source);
 }
-function collectReExport(node, source, record, markUnsafe) {
+function collectReExport(node, source, record, requireAllExports) {
 	if (isTypeOnly(node)) return;
 	if (node.type === "ExportAllDeclaration") {
-		markUnsafe(source);
+		requireAllExports(source);
 		return;
 	}
 	const specifiers = Array.isArray(node.specifiers) ? node.specifiers : [];
 	if (specifiers.length === 0) {
-		markUnsafe(source);
+		requireAllExports(source);
 		return;
 	}
 	const names = [];
 	for (const specifier of specifiers) {
+		if (!isRecord(specifier)) {
+			requireAllExports(source);
+			return;
+		}
 		if (isTypeOnly(specifier)) continue;
 		if (specifier.type !== "ExportSpecifier") {
-			markUnsafe(source);
+			requireAllExports(source);
 			return;
 		}
 		const local = specifier.local;
-		if (local?.type === "Literal" || local?.type === "StringLiteral") {
-			markUnsafe(source);
+		if (isRecord(local) && (local.type === "Literal" || local.type === "StringLiteral")) {
+			requireAllExports(source);
 			return;
 		}
 		const name = getExportedName(specifier.local);
 		if (!name) {
-			markUnsafe(source);
+			requireAllExports(source);
 			return;
 		}
 		names.push(name);
 	}
 	record(names, source);
 }
-/**
-* Collect the exports required by a consumer's ESM graph.
-*
-* Parsing the module avoids treating import-looking text in comments, strings,
-* templates, or regular expressions as real dependencies. If parsing fails,
-* every configured share whose exports are analyzed is conservatively marked
-* as requiring its full export surface instead of guessing from source text.
-*
-* Generated federation wrappers are excluded because their imports describe
-* the wrapper implementation, not the consumer's requirements.
-*/
-async function collectTreeShakingImports(code, id, shared, findSharedKey, record, markUnsafe) {
-	const normalizedId = normalizePathForImport(id);
-	if (normalizedId.includes("__prebuild__") || normalizedId.includes("__loadShare__") || normalizedId.includes("__mf_tree_shaking_graph__")) return;
+function analyzeImports(code) {
 	let ast;
 	try {
-		ast = parseAst(code);
+		ast = vite.parseAst(code);
 	} catch {
-		Object.entries(shared).forEach(([sharedKey, shareItem]) => {
-			if (shouldAnalyzeSharedExports(shareItem)) markUnsafe(sharedKey, "*");
-		});
-		return;
+		return null;
 	}
-	const pending = [];
-	const withSharedSource = (source, use) => {
-		const apply = (key) => {
-			if (key && shouldAnalyzeSharedExports(shared[key])) use(key);
-		};
-		const key = findSharedKey(source, shared);
-		if (key instanceof Promise) pending.push(key.then(apply));
-		else apply(key);
-	};
-	const recordSource = (names, source) => {
-		withSharedSource(source, (key) => record(key, names, source));
-	};
-	const markSourceUnsafe = (source) => {
-		withSharedSource(source, (key) => markUnsafe(key, source));
-	};
-	forEachAstNode(ast, (node) => {
+	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, markSourceUnsafe);
+			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, markSourceUnsafe);
+			if (source) collectReExport(node, source, recordSource, requireAllExports);
 			return;
 		}
 		if (node.type === "ImportExpression") {
 			const source = getModuleSource(node.source);
-			if (source) markSourceUnsafe(source);
+			if (source) requireAllExports(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) {
+			if (isRecord(callee) && callee.type === "Identifier" && callee.name === "require" && args.length > 0) {
 				const source = getModuleSource(args[0]);
-				if (source) markSourceUnsafe(source);
+				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
@@ -2162,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", {
@@ -2252,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,
@@ -2287,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;
 	}
@@ -2445,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;
 	}
@@ -2500,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;
 	}
@@ -2828,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;
@@ -2871,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, {
@@ -2892,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;
 	}
@@ -2948,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;
@@ -2975,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;
 	}
@@ -3026,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 = {
@@ -3037,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();
@@ -3056,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);
 }
@@ -3178,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 };
@@ -3256,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);
@@ -3316,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(() => {
@@ -3351,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;
@@ -3381,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);
     }
@@ -3418,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.");
         }
@@ -3426,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 ?? [];
@@ -3465,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);
@@ -3487,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}
@@ -3508,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() : "";
@@ -3522,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({
@@ -3536,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) {
@@ -3587,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}
@@ -3609,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) {
@@ -3653,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) {
@@ -3690,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;
 }
@@ -3703,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}
@@ -3728,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,
@@ -3743,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 () => {
@@ -3759,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 ?? []];
 		});
@@ -3771,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;
@@ -3842,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: {
@@ -3894,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);
@@ -3911,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();
@@ -3939,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) {
@@ -4030,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);
@@ -4217,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]));
@@ -4231,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);
@@ -4264,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;
@@ -4292,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;
@@ -4564,7 +4932,7 @@ function generateTreeShakingSnapshotPluginCode(enabled) {
     },
   });`;
 }
-function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(options), command = "build", exportConditions) {
+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);
@@ -4576,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}";`,
@@ -4899,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 &&
@@ -5318,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
@@ -5336,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__;
@@ -5492,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
   }
@@ -5508,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 }`}
   `;
@@ -5590,7 +6013,8 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
           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.
@@ -5621,20 +6045,7 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
                   // container's own stub and lets it displace an unloaded adopted
                   // provider whenever this container's name sorts after the provider's
                   // (#1311). Put the provider back: a stub never outranks a provider.
-                  if (!runtime.__mfKeepAdoptedProviders) {
-                    runtime.__mfKeepAdoptedProviders = true;
-                    runtime.sharedHandler?.hooks?.lifecycle?.afterRegisterShare?.on?.((args) => {
-                      const { shared, previousShared, registeredShared } = args || {};
-                      if (
-                        shared?.shareConfig?.import !== false ||
-                        registeredShared !== shared ||
-                        !previousShared ||
-                        previousShared.shareConfig?.import === false
-                      ) return;
-                      const versions = runtime.shareScopeMap?.[args.scope]?.[args.pkgName];
-                      if (versions && versions[shared.version] === shared) versions[shared.version] = previousShared;
-                    });
-                  }
+                  ${generateKeepProvidersOverStubsCode("runtime")}
                   for (const instance of globalThis.__FEDERATION__?.__INSTANCES__ || []) {
                     for (const scopeName of __mfScopeNames) {
                       const versions = instance?.shareScopeMap?.[scopeName]?.[pkg];
@@ -5734,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));
@@ -6413,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))) : [];
@@ -6842,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) {
@@ -7567,9 +7991,6 @@ function pluginExternalRuntimeCore() {
 	};
 }
 //#endregion
-//#region package.json
-var version$1 = "1.22.1";
-//#endregion
 //#region src/virtualModules/index.ts
 function initVirtualModules(command, remoteEntryId, enableSsrInit = false, options) {
 	writeLocalSharedImportMap(options);
@@ -7587,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
@@ -7705,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;
@@ -7767,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.
@@ -7821,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"}`;
 }
@@ -7835,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;
 }
@@ -8187,7 +8727,7 @@ const Manifest = (providedOptions) => {
 									type: "module"
 								},
 								ssrRemoteEntry: {
-									name: getSsrRemoteEntryFileName(devRemoteEntryFile),
+									name: getSsrRemoteEntryFileName(mfOptions, devRemoteEntryFile),
 									path: "/__mf_ssr__/",
 									type: "module"
 								},
@@ -8230,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
@@ -8239,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();
@@ -8319,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"
 		};
@@ -8636,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 + "/"));
 	}
@@ -8739,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);
@@ -8749,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);
@@ -8847,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",
@@ -8867,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);
@@ -8892,6 +9460,12 @@ 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();
@@ -8902,9 +9476,10 @@ function createSharedSourceResolver(shared, getResolutionConfig) {
 		if (findSharedKey(packageName, shared)) candidates.add(packageName);
 		if (findSharedKey(suffix, shared)) candidates.add(suffix);
 		for (const key of Object.keys(shared)) {
-			if (getPackageName(key) !== packageName) continue;
-			if (!key.endsWith("/")) candidates.add(key);
-			for (const subpath of getCommonSharedSubpaths(key)) if (findSharedKey(subpath, shared)) candidates.add(subpath);
+			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);
@@ -8912,7 +9487,8 @@ function createSharedSourceResolver(shared, getResolutionConfig) {
 		for (const candidate of candidates) {
 			const entry = await resolveEntry(candidate);
 			if (!entry) continue;
-			if (normalizeNodeModulePath(entry) === normalizeNodeModulePath(resolvedSource) || getNodeModulesSuffix(entry) === suffix) return candidate;
+			const allowNodeModulesSuffixMatch = shared[findSharedKey(candidate, shared) ?? candidate]?.shareConfig?.allowNodeModulesSuffixMatch === true;
+			if (normalizeNodeModulePath(entry) === normalizeNodeModulePath(resolvedSource) || allowNodeModulesSuffixMatch && getNodeModulesSuffix(entry) === suffix) return candidate;
 		}
 	}
 	return {
@@ -8946,8 +9522,11 @@ function createSharedSourceResolver(shared, getResolutionConfig) {
 					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, path$1.join(root, "package.json"), {
+					const resolved = await context.resolve(request, importer, {
 						...options,
 						skipSelf: true,
 						custom: {
@@ -8958,6 +9537,10 @@ function createSharedSourceResolver(shared, getResolutionConfig) {
 					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);
@@ -9006,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;
 	}
@@ -9032,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) {
@@ -9361,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;
@@ -9378,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,
@@ -9434,12 +10022,13 @@ 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 = findSharedKey(pkg, shared);
 						const shareItem = shared[pkg] || (sharedKey ? shared[sharedKey] : void 0);
@@ -9484,14 +10073,15 @@ 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);
@@ -9502,10 +10092,14 @@ function proxySharedModule(options) {
 			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;
 			},
@@ -9514,7 +10108,7 @@ function proxySharedModule(options) {
 				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));
+				}, (sharedKey, exports, request) => recordTreeShakingExports(sharedKey, exports, request, federationOptions), (sharedKey, request) => markTreeShakingPackageUnsafe(sharedKey, request, federationOptions), getBuildImportAnalysis(this.environment));
 				refreshTreeShakingForEnvironment(this);
 			}
 		},
@@ -9523,7 +10117,7 @@ function proxySharedModule(options) {
 			enforce: "pre",
 			apply: "build",
 			async resolveId(source, importer, resolveOptions) {
-				if (resolveOptions.custom?.__mfSharedEntryLookup) return;
+				if (isSharedEntryLookup(source, importer, resolveOptions)) return;
 				const sourceToken = getTreeShakingGraphToken(source);
 				const importerToken = getTreeShakingGraphToken(importer);
 				const token = sourceToken || importerToken;
@@ -9559,7 +10153,7 @@ function proxySharedModule(options) {
 			name: "proxyPreBuildShared:resolve-shared-loadShare",
 			enforce: "pre",
 			async resolveId(source, importer, resolveOptions) {
-				if (resolveOptions.custom?.__mfSharedEntryLookup || resolveOptions.custom?.__mfTreeShakingGraph) return;
+				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);
@@ -9574,8 +10168,9 @@ function proxySharedModule(options) {
 				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(sharedSource, key) ? sharedSource : 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;
@@ -9876,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;
@@ -10038,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;
@@ -10080,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);
 			}
@@ -10089,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
 			};
@@ -10114,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();
@@ -10183,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) {
@@ -10388,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) {
@@ -10605,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);
@@ -10843,11 +11530,21 @@ function createEarlyVirtualModulesPlugin(options) {
 					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);
@@ -10875,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
@@ -10894,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
@@ -10911,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
@@ -10931,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,
@@ -10947,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);
@@ -10960,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",
@@ -10992,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);
 						}
 					}
@@ -11010,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 = [
@@ -11056,16 +11753,14 @@ function applyBuildTimeRuntimeDefines(define, options, { target, isAstro, defaul
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-CQ088qGF.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 {
@@ -11112,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,
@@ -11236,7 +11931,7 @@ 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);
 			}
@@ -11286,6 +11981,7 @@ function federation(mfUserOptions) {
 			federationOptions: options,
 			getParsePromise: () => moduleParseController.parsePromise
 		}),
+		pluginLazyConsumeOnlyShares(options),
 		{
 			name: "module-federation-esm-shims",
 			enforce: "pre",
@@ -11337,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) => {
@@ -11344,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 (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";
 						}
@@ -11385,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);
@@ -11458,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))) {
@@ -11476,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;
@@ -11541,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;
@@ -11577,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, {