@module-federation/vite 1.16.16 → 1.17.1

package/lib/index.js

@@ -1,4 +1,4 @@
-import { _ as createModuleFederationError, a as getIsRolldown, b as rebaseImport, c as getPackageNameFromNodeModulePath, d as isNuxtProjectRoot, f as packageNameDecode, g as sharedCacheHelperCode, h as setPackageDetectionCwd, i as getInstalledPackageJson, l as getSharedCacheDescriptor, m as resolveImportPath, o as getPackageDetectionCwd, p as packageNameEncode, r as getInstalledPackageEntry, s as getPackageName, u as hasPackageDependency, v as mfWarn, y as normalizePathForImport } from "./pluginDts-Bo95ELmX.js";
+import { _ as createModuleFederationError, a as getIsRolldown, b as rebaseImport, c as getPackageNameFromNodeModulePath, d as isNuxtProjectRoot, f as packageNameDecode, g as sharedCacheHelperCode, h as setPackageDetectionCwd, i as getInstalledPackageJson, l as getSharedCacheDescriptor, m as resolveImportPath, o as getPackageDetectionCwd, p as packageNameEncode, r as getInstalledPackageEntry, s as getPackageName, u as hasPackageDependency, v as mfWarn, y as normalizePathForImport } from "./pluginDts-CGDIZCsD.js";
 import { createRequire } from "node:module";
 import * as fs$2 from "fs";
 import { existsSync, readFileSync, realpathSync, statSync, writeFileSync } from "fs";
@@ -6,7 +6,7 @@ import { createRequire as createRequire$1 } from "module";
 import * as path$1 from "node:path";
 import path, { basename } from "node:path";
 import { fileURLToPath, pathToFileURL } from "url";
-import { version } from "vite";
+import { parseAst, version } from "vite";
 import { createHash } from "node:crypto";
 import * as fs$1 from "node:fs";
 import { existsSync as existsSync$1, readFileSync as readFileSync$1 } from "node:fs";
@@ -373,6 +373,10 @@ function normalizeShareItem(key, shareItem) {
 	const isImportFalse = typeof shareItem === "object" && shareItem.import === false;
 	const explicitVersion = typeof shareItem === "object" ? shareItem.version : void 0;
 	const inferredVersion = typeof shareItem === "object" ? inferVersionFromRequiredVersion(shareItem.requiredVersion) : void 0;
+	const treeShaking = typeof shareItem === "object" ? shareItem.treeShaking : void 0;
+	if (treeShaking && treeShaking.mode !== "server-calc" && treeShaking.mode !== "runtime-infer") throw createModuleFederationError(`Invalid shared config for "${key}": treeShaking.mode must be either "server-calc" or "runtime-infer".`);
+	if (treeShaking && typeof shareItem === "object" && shareItem.eager) throw createModuleFederationError(`Invalid shared config for "${key}": cannot use both "eager: true" and "treeShaking.mode" simultaneously. Choose one strategy.`);
+	if (treeShaking?.mode === "runtime-infer" && typeof shareItem === "object" && shareItem.singleton) mfWarn(`Shared singleton "${key}" uses runtime-infer tree shaking, which may load both a tree-shaken bundle and a full bundle when consumers require different exports. Prefer server-calc for singleton dependencies. If runtime-infer is required, expand usedExports to reduce this risk.`);
 	const version = explicitVersion || searchPackageVersion(key) || inferredVersion;
 	if (typeof shareItem === "string") return {
 		name: shareItem,
@@ -382,6 +386,7 @@ function normalizeShareItem(key, shareItem) {
 		shareConfig: {
 			import: void 0,
 			singleton: false,
+			eager: false,
 			requiredVersion: version ? `^${version}` : "*"
 		}
 	};
@@ -393,8 +398,10 @@ function normalizeShareItem(key, shareItem) {
 		shareConfig: {
 			import: shareItem.import,
 			singleton: shareItem.singleton || false,
+			eager: shareItem.eager || false,
 			requiredVersion: shareItem.requiredVersion !== void 0 ? shareItem.requiredVersion : isImportFalse || shareItem.version ? "*" : version ? `^${version}` : "*",
-			strictVersion: !!shareItem.strictVersion
+			strictVersion: !!shareItem.strictVersion,
+			...treeShaking ? { treeShaking: { ...treeShaking } } : {}
 		}
 	};
 }
@@ -519,7 +526,7 @@ function normalizeModuleFederationOptions(options) {
 		shareScope: options.shareScope || "default",
 		shared: normalizeShared(options.shared),
 		runtimePlugins: options.runtimePlugins || [],
-		implementation: options.implementation || resolveRuntimeImplementation(),
+		implementation: normalizePathForImport(options.implementation || resolveRuntimeImplementation()),
 		manifest: normalizeManifest(options.manifest),
 		dev: options.dev,
 		dts: options.dts,
@@ -530,6 +537,10 @@ function normalizeModuleFederationOptions(options) {
 		virtualModuleDir: options.virtualModuleDir || "__mf__virtual",
 		hostInitInjectLocation: options.hostInitInjectLocation || "html",
 		bundleAllCSS: options.bundleAllCSS || false,
+		treeShakingDir: options.treeShakingDir,
+		injectTreeShakingUsedExports: options.injectTreeShakingUsedExports,
+		treeShakingSharedPlugins: options.treeShakingSharedPlugins,
+		treeShakingSharedExcludePlugins: options.treeShakingSharedExcludePlugins,
 		moduleParseTimeout: options.moduleParseTimeout || 10,
 		moduleParseIdleTimeout: options.moduleParseIdleTimeout,
 		varFilename: options.varFilename,
@@ -549,11 +560,11 @@ const cacheMap = {};
 const idCacheMap = {};
 const VITE_ID_PREFIX = "/@id/";
 const VITE_ENCODED_NULL_BYTE_PREFIX = `${VITE_ID_PREFIX}__x00__`;
-function escapeRegExp$1(value) {
+function escapeRegExp$2(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function createViteEncodedIdPrefixRegExp(sourcePrefix = "") {
-	return new RegExp(`^(?:${escapeRegExp$1(VITE_ENCODED_NULL_BYTE_PREFIX)})?${sourcePrefix}`);
+	return new RegExp(`^(?:${escapeRegExp$2(VITE_ENCODED_NULL_BYTE_PREFIX)})?${sourcePrefix}`);
 }
 function toViteEncodedId(id) {
 	return `${VITE_ENCODED_NULL_BYTE_PREFIX}${id}`;
@@ -928,6 +939,396 @@ ${exportStatement}
 `);
 }
 //#endregion
+//#region src/utils/codePositionMap.ts
+const REGEX_PREFIX_KEYWORDS = new Set([
+	"await",
+	"case",
+	"delete",
+	"in",
+	"instanceof",
+	"new",
+	"return",
+	"throw",
+	"typeof",
+	"void",
+	"yield"
+]);
+function isJsxClosingTagSlash(code, slashIndex) {
+	if (code[slashIndex - 1] !== "<") return false;
+	let cursor = slashIndex + 1;
+	while (/\s/.test(code[cursor] || "")) cursor++;
+	if (code[cursor] === ">") return true;
+	const tagStart = cursor;
+	while (/[-:.$_\u200C\u200D\p{ID_Continue}]/u.test(code[cursor] || "")) cursor++;
+	if (cursor === tagStart) return false;
+	while (/\s/.test(code[cursor] || "")) cursor++;
+	return code[cursor] === ">";
+}
+/** Mark comments, string/template literals, and regular expressions as non-code. */
+function createCodePositionMap(code) {
+	const positions = Array(code.length).fill(true);
+	const mask = (start, end) => {
+		for (let index = start; index < end; index++) positions[index] = false;
+	};
+	let canStartRegex = true;
+	for (let index = 0; index < code.length;) {
+		const char = code[index];
+		const next = code[index + 1];
+		if (/\s/.test(char)) {
+			index++;
+			continue;
+		}
+		if (char === "/" && next === "/") {
+			const start = index;
+			index += 2;
+			while (index < code.length && code[index] !== "\n" && code[index] !== "\r") index++;
+			mask(start, index);
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			const start = index;
+			index += 2;
+			while (index < code.length && !(code[index] === "*" && code[index + 1] === "/")) index++;
+			index = Math.min(code.length, index + 2);
+			mask(start, index);
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			const quote = char;
+			const start = index++;
+			while (index < code.length) {
+				if (code[index] === "\\") {
+					index += 2;
+					continue;
+				}
+				if (code[index] === quote) {
+					index++;
+					break;
+				}
+				index++;
+			}
+			mask(start, index);
+			canStartRegex = false;
+			continue;
+		}
+		const closesJsxTag = isJsxClosingTagSlash(code, index);
+		if (char === "/" && canStartRegex && !closesJsxTag) {
+			const start = index;
+			let cursor = index + 1;
+			let escaped = false;
+			let inCharacterClass = false;
+			let closed = false;
+			for (; cursor < code.length; cursor++) {
+				const regexChar = code[cursor];
+				if (regexChar === "\n" || regexChar === "\r") break;
+				if (escaped) {
+					escaped = false;
+					continue;
+				}
+				if (regexChar === "\\") {
+					escaped = true;
+					continue;
+				}
+				if (regexChar === "[") {
+					inCharacterClass = true;
+					continue;
+				}
+				if (regexChar === "]" && inCharacterClass) {
+					inCharacterClass = false;
+					continue;
+				}
+				if (regexChar === "/" && !inCharacterClass) {
+					cursor++;
+					while (/[$_\p{ID_Continue}]/u.test(code[cursor] || "")) cursor++;
+					closed = true;
+					break;
+				}
+			}
+			if (closed) {
+				mask(start, cursor);
+				index = cursor;
+				canStartRegex = false;
+				continue;
+			}
+		}
+		if (/[$_\p{ID_Start}]/u.test(char)) {
+			const start = index++;
+			while (/[$_\u200C\u200D\p{ID_Continue}]/u.test(code[index] || "")) index++;
+			canStartRegex = REGEX_PREFIX_KEYWORDS.has(code.slice(start, index));
+			continue;
+		}
+		if (/\d/.test(char)) {
+			index++;
+			while (/[\w.]/.test(code[index] || "")) index++;
+			canStartRegex = false;
+			continue;
+		}
+		if ((char === "+" || char === "-") && next === char) {
+			index += 2;
+			continue;
+		}
+		if (char === "!" && next !== "=") {
+			index++;
+			continue;
+		}
+		if (char === ")" || char === "]" || char === "}") canStartRegex = false;
+		else if (char !== ".") canStartRegex = true;
+		index++;
+	}
+	return positions;
+}
+//#endregion
+//#region src/utils/treeShaking.ts
+/**
+* Analysis is scoped by both the configured share key and the concrete module
+* request. A prefix share such as `lodash/` may materialize separate wrappers
+* for `lodash/get` and `lodash/debounce`; combining those export sets would
+* generate invalid wrappers and defeat per-subpath tree shaking.
+*/
+const inferredTreeShakingUsage = /* @__PURE__ */ new Map();
+let treeShakingBuildMode = false;
+function setTreeShakingBuildMode(enabled) {
+	treeShakingBuildMode = enabled;
+}
+function resetTreeShakingExports() {
+	inferredTreeShakingUsage.clear();
+}
+function getOrCreateExportRecord(sharedKey, request) {
+	let byRequest = inferredTreeShakingUsage.get(sharedKey);
+	if (!byRequest) {
+		byRequest = /* @__PURE__ */ new Map();
+		inferredTreeShakingUsage.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) {
+	const record = getOrCreateExportRecord(sharedKey, request);
+	exports.forEach((name) => record.usedExports.add(name));
+}
+function markTreeShakingPackageUnsafe(sharedKey, request = sharedKey) {
+	getOrCreateExportRecord(sharedKey, request).requiresFullBundle = true;
+}
+function getExportRecords(sharedKey, request) {
+	if (sharedKey) {
+		const records = inferredTreeShakingUsage.get(sharedKey);
+		const wildcard = records?.get("*");
+		const exact = records?.get(request);
+		return [wildcard, exact === wildcard ? void 0 : exact].filter((record) => !!record);
+	}
+	const records = [];
+	inferredTreeShakingUsage.forEach((byRequest, configuredKey) => {
+		const wildcard = byRequest.get("*");
+		const exact = byRequest.get(request);
+		const keyBase = configuredKey.endsWith("/") ? configuredKey.slice(0, -1) : configuredKey;
+		const requestMatchesConfiguredKey = request === keyBase || request.startsWith(`${keyBase}/`);
+		if (wildcard && requestMatchesConfiguredKey) records.push(wildcard);
+		if (exact && exact !== wildcard) records.push(exact);
+	});
+	return records;
+}
+/**
+* Return the analyzed requirement for one concrete shared request.
+*
+* Callers that know the configured share key should pass it explicitly. The
+* fallback lookup across keys keeps aliases/backwards-compatible callers
+* working, while still keeping each concrete request's exports isolated.
+*/
+function getTreeShakingExportUsage(request, shareItem, sharedKey) {
+	const treeShaking = shareItem?.shareConfig.treeShaking;
+	if (!treeShaking || !treeShakingBuildMode) return void 0;
+	const records = getExportRecords(sharedKey, request);
+	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 getModuleSource(node) {
+	if (!node || typeof node !== "object") return void 0;
+	const source = node;
+	if (source.type === "Literal" && typeof source.value === "string") return source.value;
+	if (source.type === "StringLiteral" && typeof source.value === "string") return source.value;
+	if (source.type !== "TemplateLiteral") return void 0;
+	const expressions = Array.isArray(source.expressions) ? source.expressions : [];
+	const quasis = Array.isArray(source.quasis) ? source.quasis : [];
+	if (expressions.length > 0 || quasis.length !== 1) return void 0;
+	const value = quasis[0]?.value;
+	return typeof value?.cooked === "string" ? value.cooked : typeof value?.raw === "string" ? value.raw : void 0;
+}
+function getExportedName(node) {
+	if (!node || typeof node !== "object") return void 0;
+	const exported = node;
+	if (exported.type === "Identifier" && typeof exported.name === "string") return exported.name;
+	if ((exported.type === "Literal" || exported.type === "StringLiteral") && typeof exported.value === "string") return exported.value;
+}
+function isTypeOnly(node) {
+	return node.importKind === "type" || node.exportKind === "type";
+}
+function forEachAstNode(root, visit) {
+	const stack = [root];
+	const seen = /* @__PURE__ */ new Set();
+	while (stack.length > 0) {
+		const value = stack.pop();
+		if (!value || typeof value !== "object") continue;
+		if (seen.has(value)) continue;
+		seen.add(value);
+		if (Array.isArray(value)) {
+			for (let index = value.length - 1; index >= 0; index--) stack.push(value[index]);
+			continue;
+		}
+		const node = value;
+		if (typeof node.type === "string") visit(node);
+		Object.entries(node).forEach(([key, child]) => {
+			if (key !== "parent" && key !== "loc") stack.push(child);
+		});
+	}
+}
+function collectImportDeclaration(node, source, record, markUnsafe) {
+	if (isTypeOnly(node)) return;
+	const specifiers = Array.isArray(node.specifiers) ? node.specifiers : [];
+	if (specifiers.length === 0) {
+		markUnsafe(source);
+		return;
+	}
+	const names = [];
+	for (const specifier of specifiers) {
+		if (isTypeOnly(specifier)) continue;
+		if (specifier.type === "ImportNamespaceSpecifier") {
+			markUnsafe(source);
+			return;
+		}
+		if (specifier.type === "ImportDefaultSpecifier") {
+			names.push("default");
+			continue;
+		}
+		if (specifier.type === "ImportSpecifier") {
+			const imported = specifier.imported;
+			if (imported?.type === "Literal" || imported?.type === "StringLiteral") {
+				markUnsafe(source);
+				return;
+			}
+			const name = getExportedName(specifier.imported);
+			if (!name) {
+				markUnsafe(source);
+				return;
+			}
+			names.push(name);
+			continue;
+		}
+		markUnsafe(source);
+		return;
+	}
+	record(names, source);
+}
+function collectReExport(node, source, record, markUnsafe) {
+	if (isTypeOnly(node)) return;
+	if (node.type === "ExportAllDeclaration") {
+		markUnsafe(source);
+		return;
+	}
+	const specifiers = Array.isArray(node.specifiers) ? node.specifiers : [];
+	if (specifiers.length === 0) {
+		markUnsafe(source);
+		return;
+	}
+	const names = [];
+	for (const specifier of specifiers) {
+		if (isTypeOnly(specifier)) continue;
+		if (specifier.type !== "ExportSpecifier") {
+			markUnsafe(source);
+			return;
+		}
+		const local = specifier.local;
+		if (local?.type === "Literal" || local?.type === "StringLiteral") {
+			markUnsafe(source);
+			return;
+		}
+		const name = getExportedName(specifier.local);
+		if (!name) {
+			markUnsafe(source);
+			return;
+		}
+		names.push(name);
+	}
+	record(names, source);
+}
+/**
+* Collect the exports required by a consumer's ESM graph.
+*
+* Parsing the module avoids treating import-looking text in comments, strings,
+* templates, or regular expressions as real dependencies. If parsing fails,
+* every configured tree-shaken share is conservatively marked as requiring its
+* full bundle instead of guessing from source text.
+*
+* Generated federation wrappers are excluded because their imports describe
+* the wrapper implementation, not the consumer's requirements.
+*/
+function collectTreeShakingImports(code, id, shared, findSharedKey, record, markUnsafe) {
+	const normalizedId = normalizePathForImport(id);
+	if (normalizedId.includes("__prebuild__") || normalizedId.includes("__loadShare__") || normalizedId.includes("__mf_tree_shaking_graph__")) return;
+	let ast;
+	try {
+		ast = parseAst(code);
+	} catch {
+		Object.entries(shared).forEach(([sharedKey, shareItem]) => {
+			if (shareItem.shareConfig.treeShaking) markUnsafe(sharedKey, "*");
+		});
+		return;
+	}
+	const matchShared = (source) => {
+		const sharedKey = findSharedKey(source, shared);
+		return sharedKey && shared[sharedKey]?.shareConfig.treeShaking ? sharedKey : void 0;
+	};
+	const recordSource = (names, source) => {
+		const sharedKey = matchShared(source);
+		if (sharedKey) record(sharedKey, names, source);
+	};
+	const markSourceUnsafe = (source) => {
+		const sharedKey = matchShared(source);
+		if (sharedKey) markUnsafe(sharedKey, source);
+	};
+	forEachAstNode(ast, (node) => {
+		if (node.type === "ImportDeclaration") {
+			const source = getModuleSource(node.source);
+			if (source) collectImportDeclaration(node, source, recordSource, markSourceUnsafe);
+			return;
+		}
+		if ((node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") && node.source) {
+			const source = getModuleSource(node.source);
+			if (source) collectReExport(node, source, recordSource, markSourceUnsafe);
+			return;
+		}
+		if (node.type === "ImportExpression") {
+			const source = getModuleSource(node.source);
+			if (source) markSourceUnsafe(source);
+			return;
+		}
+		if (node.type === "CallExpression") {
+			const callee = node.callee;
+			const args = Array.isArray(node.arguments) ? node.arguments : [];
+			if (callee?.type === "Identifier" && callee.name === "require" && args.length > 0) {
+				const source = getModuleSource(args[0]);
+				if (source) markSourceUnsafe(source);
+			}
+		}
+	});
+}
+//#endregion
 //#region src/virtualModules/virtualShared_preBuild.ts
 /**
 * Even the resolveId hook cannot interfere with vite pre-build,
@@ -979,17 +1380,30 @@ function getPackageEsmEntryPath(pkg) {
 		resolveSubpathWithRequire: false
 	}) || resolvePackageEntryFromProjectRoot(pkg);
 }
-function getEsmNamedExportsFromFile(entryPath) {
+function hasCodeMatch(source, regex, codePositions) {
+	regex.lastIndex = 0;
+	let match;
+	while ((match = regex.exec(source)) !== null) if (codePositions[match.index]) return true;
+	return false;
+}
+function hasCommonJsExports(source) {
+	return hasCodeMatch(source, /\bmodule\s*(?:\.exports|\[\s*['"]exports['"]\s*\])|\bexports\s*(?:\.|\[|[,)]|=(?!=|>))/g, createCodePositionMap(source));
+}
+function inspectSharedExportsFromFile(entryPath) {
 	try {
-		if (!entryPath) return [];
-		return getNamedExportsViaRegex(readFileSync(entryPath, "utf-8"), entryPath);
+		if (!entryPath) return void 0;
+		const source = readFileSync(entryPath, "utf-8");
+		const scanState = { complete: true };
+		const namedExports = getNamedExportsViaRegex(source, entryPath, void 0, scanState);
+		const commonJs = hasCommonJsExports(source);
+		return {
+			namedExports: scanState.complete && !commonJs ? namedExports : void 0,
+			commonJs
+		};
 	} catch {
-		return [];
+		return;
 	}
 }
-function getEsmNamedExports(pkg) {
-	return getEsmNamedExportsFromFile(getPackageEsmEntryPath(pkg));
-}
 function resolveConfiguredImportPath(importSource) {
 	if (path$1.isAbsolute(importSource)) return resolveFileLikeModule(importSource);
 	const projectRoot = getPackageDetectionCwd();
@@ -1070,19 +1484,156 @@ function resolveReExportModule(filePath, specifier) {
 		return;
 	}
 }
-function getNamedExportsViaRegex(source, filePath, visited) {
+function hasTopLevelDeclaratorComma(source, start) {
+	let depth = 0;
+	let quote;
+	let escaped = false;
+	let canStartRegex = true;
+	for (let index = start; index < source.length; index++) {
+		const char = source[index];
+		if (quote) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === quote) quote = void 0;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			quote = char;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "/" && source[index + 1] === "/") {
+			index = source.indexOf("\n", index + 2);
+			if (index === -1) return false;
+			continue;
+		}
+		if (char === "/" && source[index + 1] === "*") {
+			const commentEnd = source.indexOf("*/", index + 2);
+			if (commentEnd === -1) return true;
+			index = commentEnd + 1;
+			continue;
+		}
+		if (char === "/" && canStartRegex) {
+			let regexEscaped = false;
+			let inCharacterClass = false;
+			let closed = false;
+			for (index++; index < source.length; index++) {
+				const regexChar = source[index];
+				if (regexEscaped) {
+					regexEscaped = false;
+					continue;
+				}
+				if (regexChar === "\\") {
+					regexEscaped = true;
+					continue;
+				}
+				if (regexChar === "[") {
+					inCharacterClass = true;
+					continue;
+				}
+				if (regexChar === "]" && inCharacterClass) {
+					inCharacterClass = false;
+					continue;
+				}
+				if (regexChar === "/" && !inCharacterClass) {
+					closed = true;
+					while (/[$_\p{ID_Continue}]/u.test(source[index + 1] || "")) index++;
+					break;
+				}
+				if (regexChar === "\n" || regexChar === "\r") return true;
+			}
+			if (!closed) return true;
+			canStartRegex = false;
+			continue;
+		}
+		if (char === "/") {
+			canStartRegex = true;
+			continue;
+		}
+		if (/[$_\p{ID_Start}]/u.test(char)) {
+			const tokenStart = index;
+			while (/[$_\u200C\u200D\p{ID_Continue}]/u.test(source[index + 1] || "")) index++;
+			const token = source.slice(tokenStart, index + 1);
+			canStartRegex = /^(?:await|case|delete|in|instanceof|new|return|throw|typeof|void|yield)$/.test(token);
+			continue;
+		}
+		if (/\d/.test(char)) {
+			while (/[\w.]/.test(source[index + 1] || "")) index++;
+			canStartRegex = false;
+			continue;
+		}
+		if ((char === "+" || char === "-") && source[index + 1] === char) {
+			index++;
+			continue;
+		}
+		if (char === "!" && source[index + 1] !== "=") continue;
+		if (char === "(" || char === "[" || char === "{") {
+			depth++;
+			canStartRegex = true;
+			continue;
+		}
+		if (char === ")" || char === "]" || char === "}") {
+			depth = Math.max(0, depth - 1);
+			canStartRegex = false;
+			continue;
+		}
+		if (depth === 0 && char === ",") return true;
+		if (depth === 0 && char === ";") return false;
+		if (!/\s/.test(char)) canStartRegex = char !== ".";
+	}
+	return false;
+}
+function hasUnsupportedBindingPattern(source, start) {
+	const opening = source[start];
+	if (opening !== "{" && opening !== "[") return false;
+	let depth = 0;
+	for (let index = start; index < source.length; index++) {
+		const char = source[index];
+		if (char === "\"" || char === "'" || char === "`") return true;
+		if (char === "(" || char === "/" || char === ":" && opening === "[") return true;
+		if (char === "{" || char === "[") {
+			depth++;
+			if (depth > 1) return true;
+			continue;
+		}
+		if (char === "}" || char === "]") {
+			depth--;
+			if (depth === 0) {
+				let next = index + 1;
+				while (/\s/.test(source[next] || "")) next++;
+				return source[next] !== "=";
+			}
+		}
+	}
+	return true;
+}
+function getNamedExportsViaRegex(source, filePath, visited, scanState = { complete: true }) {
 	const names = /* @__PURE__ */ new Set();
+	const codePositions = createCodePositionMap(source);
+	const recognizedExportStarts = /* @__PURE__ */ new Set();
 	visited = visited || /* @__PURE__ */ new Set();
 	if (filePath) visited.add(filePath);
-	const declRegex = new RegExp(`export\\s+(?:async\\s+)?(?:function(?:\\*\\s*|\\s+\\*?\\s*)|const\\s+|let\\s+|var\\s+|class\\s+|enum\\s+|namespace\\s+)(${JS_IDENTIFIER_PATTERN})`, "gu");
+	const declRegex = new RegExp(`export\\s+(?:async\\s+)?(?:function(?:\\*\\s*|\\s+\\*?\\s*)|const\\s+enum\\s+|const\\s+|let\\s+|var\\s+|class\\s+|abstract\\s+class\\s+|enum\\s+|namespace\\s+|module\\s+)(${JS_IDENTIFIER_PATTERN})`, "gu");
 	let match;
 	while ((match = declRegex.exec(source)) !== null) {
+		if (!codePositions[match.index]) continue;
+		recognizedExportStarts.add(match.index);
 		const name = match[1];
 		if (isValidEsmExportName(name)) names.add(name);
 	}
+	const exportedVariableDeclarationRegex = /export\s+(?:const|let|var)\s+/g;
+	while ((match = exportedVariableDeclarationRegex.exec(source)) !== null) {
+		if (!codePositions[match.index]) continue;
+		if (hasTopLevelDeclaratorComma(source, exportedVariableDeclarationRegex.lastIndex)) scanState.complete = false;
+		if (hasUnsupportedBindingPattern(source, exportedVariableDeclarationRegex.lastIndex)) scanState.complete = false;
+	}
+	if (hasCodeMatch(source, /export\s+import\s+/g, codePositions) || hasCodeMatch(source, /export\s*=/g, codePositions)) scanState.complete = false;
+	if (hasCodeMatch(source, /export\s+@/g, codePositions)) scanState.complete = false;
 	const destructureRegex = /export\s+(?:const|let|var)\s+(\{[^}]*\}|\[[^\]]*\])\s*=/g;
 	const bindingNameRegex = new RegExp(`^(${JS_IDENTIFIER_PATTERN})`, "u");
 	while ((match = destructureRegex.exec(source)) !== null) {
+		if (!codePositions[match.index]) continue;
+		recognizedExportStarts.add(match.index);
 		const inner = match[1].slice(1, -1);
 		for (const part of inner.split(",")) {
 			let token = part.split("=")[0].trim();
@@ -1097,45 +1648,109 @@ function getNamedExportsViaRegex(source, filePath, visited) {
 	const typeOnlySpecifierRegex = new RegExp(`^type\\s+${JS_IDENTIFIER_PATTERN}(?:\\s+as\\s+${JS_IDENTIFIER_PATTERN})?$`, "u");
 	const exportSpecifierRegex = new RegExp(`(?:\\S+\\s+as\\s+)?(${JS_IDENTIFIER_PATTERN})$`, "u");
 	while ((match = listRegex.exec(source)) !== null) {
+		if (!codePositions[match.index]) continue;
+		recognizedExportStarts.add(match.index);
 		const specifiers = match[1].split(",");
 		for (const specifier of specifiers) {
 			const trimmed = specifier.trim();
 			if (typeOnlySpecifierRegex.test(trimmed)) continue;
 			const asMatch = trimmed.match(exportSpecifierRegex);
-			if (!asMatch) continue;
+			if (!asMatch) {
+				scanState.complete = false;
+				continue;
+			}
 			const name = asMatch[1];
 			if (isValidEsmExportName(name)) names.add(name);
+			else scanState.complete = false;
 		}
 	}
 	const namespaceReExportRegex = new RegExp(`export\\s+\\*\\s+as\\s+(${JS_IDENTIFIER_PATTERN})\\s+from\\s+['"][^'"]+['"]`, "gu");
-	while ((match = namespaceReExportRegex.exec(source)) !== null) if (isValidEsmExportName(match[1])) names.add(match[1]);
+	while ((match = namespaceReExportRegex.exec(source)) !== null) {
+		if (!codePositions[match.index]) continue;
+		recognizedExportStarts.add(match.index);
+		if (isValidEsmExportName(match[1])) names.add(match[1]);
+	}
+	if (hasCodeMatch(source, /export\s+\*\s+as\s+['"]/g, codePositions)) scanState.complete = false;
 	if (filePath) {
 		const starExportRegex = /export\s+\*\s+from\s+['"]([^'"]+)['"]/g;
 		while ((match = starExportRegex.exec(source)) !== null) {
+			if (!codePositions[match.index]) continue;
+			recognizedExportStarts.add(match.index);
 			const specifier = match[1];
 			const resolvedPath = resolveReExportModule(filePath, specifier);
-			if (!resolvedPath || visited.has(resolvedPath)) continue;
+			if (!resolvedPath) {
+				scanState.complete = false;
+				continue;
+			}
+			if (visited.has(resolvedPath)) continue;
+			if (path$1.extname(resolvedPath) === ".cjs") {
+				scanState.complete = false;
+				continue;
+			}
 			try {
-				const reExportNames = getNamedExportsViaRegex(readFileSync(resolvedPath, "utf-8"), resolvedPath, visited);
+				const reExportSource = readFileSync(resolvedPath, "utf-8");
+				if (hasCommonJsExports(reExportSource)) {
+					scanState.complete = false;
+					continue;
+				}
+				const reExportNames = getNamedExportsViaRegex(reExportSource, resolvedPath, visited, scanState);
 				for (const name of reExportNames) names.add(name);
-			} catch {}
+			} catch {
+				scanState.complete = false;
+			}
+		}
+	}
+	const noNamedExportRegex = /export(?:\s+default\b|\s*\{\s*\}|\s+(?:type|interface|declare)\b)/g;
+	while ((match = noNamedExportRegex.exec(source)) !== null) {
+		if (!codePositions[match.index]) continue;
+		recognizedExportStarts.add(match.index);
+	}
+	const exportKeywordRegex = /\bexport\b/g;
+	while ((match = exportKeywordRegex.exec(source)) !== null) {
+		if (!codePositions[match.index]) continue;
+		if (!recognizedExportStarts.has(match.index)) {
+			scanState.complete = false;
+			break;
 		}
 	}
 	return Array.from(names);
 }
-function getPackageNamedExports(pkg) {
+function getRequiredNamedExports(specifier) {
 	try {
-		const mod = createRequire$1(pathToFileURL(path$1.join(getPackageDetectionCwd(), "package.json")))(pkg);
-		return Object.keys(mod).filter((k) => isValidEsmExportName(k));
+		const mod = createRequire$1(pathToFileURL(path$1.join(getPackageDetectionCwd(), "package.json")))(specifier);
+		const runtimeNamedKeys = Object.keys(mod).filter((key) => key !== "default" && key !== "__esModule");
+		if (runtimeNamedKeys.some((key) => !isValidEsmExportName(key))) return void 0;
+		return runtimeNamedKeys;
 	} catch {
-		return getEsmNamedExports(pkg);
+		return;
 	}
 }
+function getPackageNamedExports(pkg) {
+	const esmEntryPath = getInstalledPackageEntry(pkg, {
+		conditions: [
+			"browser",
+			"import",
+			"module",
+			"default"
+		],
+		resolveSubpathWithRequire: false
+	});
+	if (esmEntryPath) {
+		const inspection = inspectSharedExportsFromFile(esmEntryPath);
+		if (!inspection || inspection.commonJs || path$1.extname(esmEntryPath) === ".cjs") return getRequiredNamedExports(esmEntryPath);
+		if (inspection.namedExports !== void 0) return inspection.namedExports;
+		return;
+	}
+	return getRequiredNamedExports(pkg);
+}
 function getSharedNamedExports(pkg, shareItem) {
 	const configuredImport = shareItem?.shareConfig.import;
 	if (typeof configuredImport === "string") {
-		const configuredNamedExports = getEsmNamedExportsFromFile(resolveConfiguredImportPath(configuredImport));
-		if (configuredNamedExports.length > 0) return configuredNamedExports;
+		const configuredImportPath = resolveConfiguredImportPath(configuredImport);
+		const inspection = inspectSharedExportsFromFile(configuredImportPath);
+		if (configuredImportPath && (inspection?.commonJs || path$1.extname(configuredImportPath) === ".cjs")) return getRequiredNamedExports(configuredImportPath);
+		if (inspection?.namedExports !== void 0) return inspection.namedExports;
+		return;
 	}
 	return getPackageNamedExports(pkg);
 }
@@ -1173,7 +1788,7 @@ function isWorkspaceFilePath(resolved) {
 	try {
 		realResolved = realpathSync.native(resolved);
 	} catch {}
-	return !realResolved.includes("/node_modules/") && !realResolved.includes("\\node_modules\\");
+	return !normalizeNodeModulePath(realResolved).includes("/node_modules/");
 }
 /**
 * When createRequire resolves a workspace package to a CJS entry (e.g. dist/index.cjs),
@@ -1285,10 +1900,104 @@ function getConcreteSharedImportSource(pkg, shareItem) {
 const preBuildCacheMap = {};
 const preBuildShareItemMap = {};
 const PREBUILD_TAG = "__prebuild__";
+const treeShakingProviderCacheMap = {};
+const materializedTreeShakingProviders = /* @__PURE__ */ new Set();
+const TREE_SHAKING_PROVIDER_TAG = "__treeShakingProvider__";
+const TREE_SHAKING_GRAPH_QUERY = "__mf_tree_shaking_graph__";
+function getTreeShakingGraphToken(id) {
+	if (!id) return void 0;
+	const queryStart = id.indexOf("?");
+	if (queryStart === -1) return void 0;
+	const hashStart = id.indexOf("#", queryStart);
+	const entry = id.slice(queryStart + 1, hashStart === -1 ? void 0 : hashStart).split("&").find((part) => part.split("=", 1)[0] === TREE_SHAKING_GRAPH_QUERY);
+	if (!entry) return void 0;
+	const value = entry.slice(26);
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+function stripTreeShakingGraphQuery(id) {
+	const queryStart = id.indexOf("?");
+	if (queryStart === -1) return id;
+	const hashStart = id.indexOf("#", queryStart);
+	const pathname = id.slice(0, queryStart);
+	const hash = hashStart === -1 ? "" : id.slice(hashStart);
+	const remaining = id.slice(queryStart + 1, hashStart === -1 ? void 0 : hashStart).split("&").filter(Boolean).filter((part) => part.split("=", 1)[0] !== TREE_SHAKING_GRAPH_QUERY);
+	return `${pathname}${remaining.length ? `?${remaining.join("&")}` : ""}${hash}`;
+}
+function addTreeShakingGraphQuery(id, token) {
+	const cleanId = stripTreeShakingGraphQuery(id);
+	const hashStart = cleanId.indexOf("#");
+	const base = hashStart === -1 ? cleanId : cleanId.slice(0, hashStart);
+	const hash = hashStart === -1 ? "" : cleanId.slice(hashStart);
+	return `${base}${base.includes("?") ? "&" : "?"}${TREE_SHAKING_GRAPH_QUERY}=${encodeURIComponent(token)}${hash}`;
+}
+function getConcreteTreeShakingExportUsage(pkg, shareItem) {
+	return getTreeShakingExportUsage(pkg, shareItem, shareItem?.name);
+}
+function getTreeShakingSharedProviderName(pkg) {
+	const { internalName, name } = getNormalizeModuleFederationOptions();
+	return `${internalName || name}__tree_shaking__${packageNameEncode(pkg)}`;
+}
+function getTreeShakingSharedProviderImportId(pkg) {
+	if (!treeShakingProviderCacheMap[pkg]) treeShakingProviderCacheMap[pkg] = new VirtualModule(pkg, TREE_SHAKING_PROVIDER_TAG, ".js");
+	return treeShakingProviderCacheMap[pkg].getImportId();
+}
+function hasTreeShakingSharedProvider(pkg, shareItem) {
+	const usage = getConcreteTreeShakingExportUsage(pkg, shareItem);
+	return materializedTreeShakingProviders.has(pkg) && usage?.kind === "exports";
+}
+/**
+* Materialize the locally optimized provider as a small ESM container.
+*
+* The normal prebuild module remains the complete fallback. This container only
+* retains the selected exports and is installed as `treeShaking.get` by the
+* generated runtime record. Keeping the two getters distinct lets the Runtime
+* perform its normal usedExports compatibility check and safely choose the full
+* provider when the optimized one is insufficient.
+*/
+function writeTreeShakingSharedProvider(pkg, shareItem) {
+	const usage = getConcreteTreeShakingExportUsage(pkg, shareItem);
+	if (usage?.kind !== "exports" || !usage.usedExports.length || shareItem?.shareConfig.import === false) {
+		materializedTreeShakingProviders.delete(pkg);
+		return;
+	}
+	const usedExports = usage.usedExports;
+	const unsupportedExport = usedExports.find((name) => name !== "default" && !isValidEsmExportName(name));
+	if (unsupportedExport) {
+		materializedTreeShakingProviders.delete(pkg);
+		mfWarn(`Tree-shaking shared dependency "${pkg}" was disabled because export "${unsupportedExport}" cannot be represented by the generated ESM provider.`);
+		return;
+	}
+	const provider = treeShakingProviderCacheMap[pkg] || (treeShakingProviderCacheMap[pkg] = new VirtualModule(pkg, "__treeShakingProvider__", ".js"));
+	const optimizedImportSource = addTreeShakingGraphQuery(getConcreteSharedImportSource(pkg, shareItem) || pkg, pkg);
+	const namedExports = usedExports.filter((name) => name !== "default");
+	const namedImports = namedExports.map((name, index) => `${name} as __mfTreeShaken_${index}`).join(", ");
+	const importLines = [namedImports ? `import { ${namedImports} } from ${escapeGeneratedStringLiteral(optimizedImportSource)};` : "", usedExports.includes("default") ? `import __mfTreeShakenDefault from ${escapeGeneratedStringLiteral(optimizedImportSource)};` : ""].filter(Boolean).join("\n");
+	const namespaceEntries = [...namedExports.map((name, index) => `[${JSON.stringify(name)}]: __mfTreeShaken_${index}`), ...usedExports.includes("default") ? ["default: __mfTreeShakenDefault"] : [`default: { ${namedExports.map((name, index) => `[${JSON.stringify(name)}]: __mfTreeShaken_${index}`).join(", ")} }`]];
+	provider.writeSync(`${importLines}
+const __mfTreeShakenModule = { ${namespaceEntries.join(", ")} };
+Object.defineProperty(__mfTreeShakenModule, "__esModule", {
+  value: true,
+  enumerable: false,
+});
+async function init() {}
+function get() {
+  return () => __mfTreeShakenModule;
+}
+const usedExports = ${JSON.stringify([...usedExports].sort())};
+export { get, init, usedExports };
+export default { get, init };
+`, true);
+	materializedTreeShakingProviders.add(pkg);
+}
 function writePreBuildLibPath(pkg, shareItem) {
 	if (!preBuildCacheMap[pkg]) preBuildCacheMap[pkg] = new VirtualModule(pkg, PREBUILD_TAG, ".js");
 	preBuildShareItemMap[pkg] = shareItem;
 	const importSource = getConcreteSharedImportSource(pkg, shareItem) || pkg;
+	writeTreeShakingSharedProvider(pkg, shareItem);
 	if (pkg === "react/compiler-runtime") {
 		const reactCacheDescriptor = getSharedCacheDescriptorLiteral("react", shareItem ?? {
 			name: "react",
@@ -1333,7 +2042,7 @@ function writePreBuildLibPath(pkg, shareItem) {
   `, true);
 		return;
 	}
-	const namedExports = getSharedNamedExports(pkg, shareItem);
+	const namedExports = getSharedNamedExports(pkg, shareItem) ?? [];
 	if (namedExports.length > 0) {
 		const namedExportVars = namedExports.map((_name, i) => `__mf_${i}`);
 		const declarations = namedExports.map((name, i) => `const ${namedExportVars[i]} = __mfPrebuildExports[${escapeGeneratedStringLiteral(name)}];`).join("\n    ");
@@ -1343,16 +2052,27 @@ function writePreBuildLibPath(pkg, shareItem) {
     const __mfPrebuildExports = __mfPrebuildNamespace;
     ${declarations}
     ${namedExportLine}
-    export default __mfPrebuildNamespace.default ?? __mfPrebuildNamespace;
+    export default Reflect.get(__mfPrebuildNamespace, "default") ?? __mfPrebuildNamespace;
   `, true);
 		return;
 	}
 	preBuildCacheMap[pkg].writeSync(`
     import * as __mfPrebuildExports from ${escapeGeneratedStringLiteral(importSource)};
     export * from ${escapeGeneratedStringLiteral(importSource)};
-    export default __mfPrebuildExports.default ?? __mfPrebuildExports;
+    // Reflect access avoids bundler warnings for ESM packages without a
+    // default export (for example antd/es/index.js), while preserving the
+    // namespace fallback for packages that do provide one.
+    export default Reflect.get(__mfPrebuildExports, "default") ?? __mfPrebuildExports;
   `, true);
 }
+/** Re-render already materialized wrappers after import analysis discovers exports. */
+function refreshTreeShakingModules() {
+	for (const [pkg, shareItem] of Object.entries(preBuildShareItemMap)) {
+		if (!shareItem?.shareConfig.treeShaking) continue;
+		writePreBuildLibPath(pkg, shareItem);
+		writeLoadShareModule(pkg, shareItem, "build", false);
+	}
+}
 function getPreBuildLibImportId(pkg) {
 	if (!preBuildCacheMap[pkg]) preBuildCacheMap[pkg] = new VirtualModule(pkg, PREBUILD_TAG, ".js");
 	return preBuildCacheMap[pkg].getImportId();
@@ -1398,49 +2118,58 @@ function materializeCachedLoadShareModule(options) {
 	options.addUsedShares(pkg);
 	options.writeLocalSharedImportMap();
 }
-function generateEagerWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor) {
+function getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer) {
+	return treeShakingConsumer ? `__mfReadTreeShakingSharedSelection(__mfModuleCache.share, ${cacheDescriptor}, ${JSON.stringify(treeShakingConsumer)})` : `__mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor})`;
+}
+function generateEagerWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer) {
 	const namedExportVars = namedExports.map((_name, i) => `__mf_${i}`);
-	const namedExportAssignments = namedExports.length > 0 ? `\n    ${namedExports.map((name, i) => `const ${namedExportVars[i]} = exportModule[${escapeGeneratedStringLiteral(name)}];`).join("\n    ")}` : "";
+	const declarations = namedExports.length > 0 ? ["let __mf_default;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ") : "let __mf_default;";
+	const assignments = [...namedExports.map((name, i) => `${namedExportVars[i]} = mod[${escapeGeneratedStringLiteral(name)}];`), "__mf_default = mod.default ?? mod;"].join("\n      ");
 	const namedExportLine = namedExports.length > 0 ? `\n    export { ${namedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : "";
 	return `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(importSource)};
-    let exportModule = __mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor});
+    let exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
     if (exportModule === undefined) {
       Promise.resolve().then(() => {
         if (__mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor}) === undefined) {
-          __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfNormalizeShareModule(__mfLocalShare));
+          __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfNormalizeShareModule(__mfLocalShare), ${cacheOwner});
         }
       });
       exportModule = __mfLocalShare;
     }
-    const __mf_default = exportModule.default ?? exportModule;${namedExportAssignments}
+    ${declarations}
+    const __mfApplyEagerShareExports = (mod) => {
+      ${assignments}
+    };
+    __mfSubscribeSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfApplyEagerShareExports);
+    __mfApplyEagerShareExports(exportModule);
     export { __mf_default as default };${namedExportLine}`;
 }
-function generateLazyWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor) {
+function generateLazyWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer) {
 	const namedExportVars = namedExports.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 = namedExports.length > 0 ? [...namedExports.map((name, i) => `${namedExportVars[i]} = mod[${escapeGeneratedStringLiteral(name)}];`), "__mf_default = mod.default ?? mod;"].join("\n      ") : "__mf_default = mod.default ?? mod;";
 	const namedExportLine = namedExports.length > 0 ? `\n    export { ${namedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : "";
+	const applyLocalFallback = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
+      __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
 	return `${declarations}
     const __mfApplyLazyShareExports = (mod) => {
       ${assignments}
     };
-    let exportModule = __mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor});
+    __mfSubscribeSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfApplyLazyShareExports);
+    let exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
     if (exportModule === undefined) {
       if (import.meta.env.SSR) {
-        ${`exportModule = __mfNormalizeShareModule(__mfLocalShare);
-      __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule);
-      __mfApplyLazyShareExports(exportModule);`}
+        ${applyLocalFallback}
       } else {
         (__mfModuleCache.pendingShareLoads ||= []).push(initPromise.then(() => {
-          exportModule = __mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor});
+          exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
           if (exportModule !== undefined) {
             __mfApplyLazyShareExports(exportModule);
             return;
           }
           return import(${escapeGeneratedStringLiteral(importSource)}).then((mod) => {
             exportModule = __mfNormalizeShareModule(mod);
-            __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule);
-            __mfApplyLazyShareExports(exportModule);
+            __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});
           });
         }));
       }
@@ -1459,16 +2188,19 @@ function prependWorkspaceSingletonSsrImport(code) {
 	const quote = importMatch[1];
 	return `import * as __mfLocalShare from ${quote}${importMatch[2]}${quote};\n${code}`;
 }
-function generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor) {
+function generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor, treeShakingConsumer) {
 	const namedExportVars = namedExports.map((_name, i) => `__mf_${i}`);
-	return `${["let __mf_default;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ")}
+	const declarations = ["let __mf_default;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ");
+	const assignments = [...namedExports.map((name, i) => `${namedExportVars[i]} = exportModule[${escapeGeneratedStringLiteral(name)}];`), "__mf_default = exportModule.default ?? exportModule;"].join("\n      ");
+	const namedExportLine = namedExports.length > 0 ? `\n    export { ${namedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : "";
+	return `${declarations}
     const __mfApplyHostProvidedExports = (exportModule) => {
-      ${[...namedExports.map((name, i) => `${namedExportVars[i]} = exportModule[${escapeGeneratedStringLiteral(name)}];`), "__mf_default = exportModule.default ?? exportModule;"].join("\n      ")}
+      ${assignments}
     };
-    let exportModule = __mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor});
+    let exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
     if (exportModule === undefined) {
       (__mfModuleCache.pendingShareLoads ||= []).push(initPromise.then(() => {
-        exportModule = __mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor});
+        exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
         if (exportModule === undefined) {
           throw new Error("[Module Federation] Shared module ${pkg} was imported before federation bootstrap finished.");
         }
@@ -1477,7 +2209,7 @@ function generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor)
     } else {
       __mfApplyHostProvidedExports(exportModule);
     }
-    export { __mf_default as default };${namedExports.length > 0 ? `\n    export { ${namedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : ""}`;
+    export { __mf_default as default };${namedExportLine}`;
 }
 function generateShareModuleUnwrapCode({ source, preserveNamedExports, stopWithReturn }) {
 	return `let current = ${source};
@@ -1500,13 +2232,16 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
 	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = new VirtualModule(pkg, LOAD_SHARE_TAG, ".js");
 	let importLine = getRuntimeModuleCacheBootstrapCode();
 	const cacheDescriptor = getSharedCacheDescriptorLiteral(pkg, shareItem);
+	const cacheOwner = JSON.stringify(getNormalizeModuleFederationOptions().name);
+	const treeShakingConsumer = command === "build" && shareItem.shareConfig.treeShaking ? getNormalizeModuleFederationOptions().name : void 0;
 	if (shareItem.shareConfig.import === false) {
-		const namedExports = getPackageNamedExports(pkg);
+		const detectedNamedExports = getPackageNamedExports(pkg);
+		const namedExports = detectedNamedExports ?? [];
 		let exportLine;
-		if (namedExports.length > 0) exportLine = generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor);
+		if (namedExports.length > 0) exportLine = generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor, treeShakingConsumer);
 		else {
-			mfWarn(`Shared dependency "${pkg}" has import: false but is not installed locally.\n  Named imports (e.g. import { ... } from '${pkg}') will not work in production builds.\n  Install it as a devDependency to enable named export detection.`);
-			exportLine = generateDeferredHostProvidedExports([], pkg, cacheDescriptor);
+			if (detectedNamedExports === void 0) mfWarn(`Shared dependency "${pkg}" has import: false but is not installed locally.\n  Named imports (e.g. import { ... } from '${pkg}') will not work in production builds.\n  Install it as a devDependency to enable named export detection.`);
+			exportLine = generateDeferredHostProvidedExports([], pkg, cacheDescriptor, treeShakingConsumer);
 		}
 		loadShareCacheMap[pkg].writeSync(`
     ${getRuntimeInitPromiseBootstrapCode()}
@@ -1520,22 +2255,59 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
 	const sharedImportSource = concreteSharedImportSource || getPreBuildLibImportId(pkg);
 	const devImportSource = concreteSharedImportSource || pkg;
 	const localProviderPath = getLocalProviderImportPath(pkg);
+	const coherentLocalSource = concreteSharedImportSource || localProviderPath || devImportSource;
 	const isWorkspacePackage = isWorkspacePackageEntry(pkg, localProviderPath) || isWorkspacePackageEntry(pkg, concreteSharedImportSource);
 	const lazyLocalFallbackSource = command !== "build" ? concreteSharedImportSource || localProviderPath || devImportSource : concreteSharedImportSource || localProviderPath || sharedImportSource;
 	const skipServePrebuildWarmup = command !== "build" && (pkg === "lit" || pkg.startsWith("lit/"));
+	const detectedNamedExports = getSharedNamedExports(pkg, shareItem);
+	const namedExports = detectedNamedExports ?? [];
+	const hasCompleteExportCoverage = detectedNamedExports !== void 0;
 	const isWorkspaceSingleton = isWorkspacePackage && shareItem.shareConfig.singleton === true;
 	const isDefaultShareScope = shareItem.scope === void 0 || shareItem.scope === "default" || Array.isArray(shareItem.scope) && shareItem.scope[0] === "default";
-	const usesDeferredSingletonFallback = isWorkspaceSingleton || command !== "build" && isRemoteOnlyContainer() && shareItem.shareConfig.singleton === true || command === "build" && isRemoteOnlyContainer() && shareItem.shareConfig.singleton === true && !isDefaultShareScope;
+	const usesDeferredSingletonFallback = hasCompleteExportCoverage && (isWorkspaceSingleton || command !== "build" && isRemoteOnlyContainer() && shareItem.shareConfig.singleton === true || command === "build" && isRemoteOnlyContainer() && shareItem.shareConfig.singleton === true && !isDefaultShareScope);
 	const isConsumedByPeerSingleton = isSharedSingletonConsumedByPeer(pkg);
-	const usesEntryInjectedRemoteFallback = command !== "build" && !isWorkspaceSingleton && isRemoteOnlyContainer() && shareItem.shareConfig.singleton === true && getNormalizeModuleFederationOptions().hostInitInjectLocation === "entry" && isConsumedByPeerSingleton;
-	const usesEagerWorkspaceFallback = isWorkspaceSingleton && isConsumedByPeerSingleton;
-	const namedExports = getSharedNamedExports(pkg, shareItem);
+	const usesEntryInjectedRemoteFallback = hasCompleteExportCoverage && command !== "build" && !isWorkspaceSingleton && isRemoteOnlyContainer() && shareItem.shareConfig.singleton === true && getNormalizeModuleFederationOptions().hostInitInjectLocation === "entry" && isConsumedByPeerSingleton;
+	const usesEagerWorkspaceFallback = hasCompleteExportCoverage && isWorkspaceSingleton && isConsumedByPeerSingleton;
+	const usesDeferredTreeShakingFallback = hasCompleteExportCoverage && Boolean(treeShakingConsumer);
 	let exportLine;
 	let initBlock = "";
-	if (usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback) exportLine = generateEagerWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor);
+	if (usesDeferredTreeShakingFallback) {
+		importLine = `${getRuntimeInitPromiseBootstrapCode()}\n    ${importLine}`;
+		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer);
+	} else if (usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback) exportLine = generateEagerWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer);
 	else if (usesDeferredSingletonFallback) {
 		importLine = `${getRuntimeInitPromiseBootstrapCode()}\n    ${importLine}`;
-		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor);
+		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer);
+	} else if (detectedNamedExports === void 0) {
+		exportLine = `const __mfDefaultExport = (() => {
+      ${generateShareModuleUnwrapCode({
+			source: "__mfLocalShare",
+			preserveNamedExports: false,
+			stopWithReturn: "defaultExport ?? current"
+		})}
+    })();
+    export default __mfDefaultExport;
+    export * from ${escapeGeneratedStringLiteral(coherentLocalSource)}`;
+		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
+      __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
+	} else if (namedExports.length > 0 && shareItem.shareConfig.singleton === true) {
+		const namedExportVars = namedExports.map((_name, i) => `__mf_${i}`);
+		exportLine = `${["let __mfDefaultExport;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ")}
+    const __mfApplySharedExports = (mod) => {
+      ${[...namedExports.map((name, i) => `${namedExportVars[i]} = mod[${escapeGeneratedStringLiteral(name)}];`), `__mfDefaultExport = (() => {
+        ${generateShareModuleUnwrapCode({
+			source: "mod",
+			preserveNamedExports: false,
+			stopWithReturn: "defaultExport ?? current"
+		})}
+      })();`].join("\n      ")}
+    };
+    __mfSubscribeSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfApplySharedExports);
+    __mfApplySharedExports(exportModule);
+    export { __mfDefaultExport as default };
+    ${`export { ${namedExports.map((name, i) => `__mf_${i} as ${name}`).join(", ")} };`}`;
+		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
+      __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
 	} else if (namedExports.length > 0) {
 		const destructure = `const { ${namedExports.map((name, i) => `${name}: __mf_${i}`).join(", ")} } = exportModule;`;
 		const namedExportLine = `export { ${namedExports.map((name, i) => `__mf_${i} as ${name}`).join(", ")} };`;
@@ -1550,15 +2322,26 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
     ${destructure}
     ${namedExportLine}`;
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
-      __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule);`;
+      __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
+	} else if (shareItem.shareConfig.singleton === true) {
+		exportLine = `let __mfDefaultExport;
+    const __mfApplySharedDefaultExport = (mod) => {
+      __mfDefaultExport = mod.default ?? mod;
+    };
+    __mfSubscribeSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfApplySharedDefaultExport);
+    __mfApplySharedDefaultExport(exportModule);
+    export { __mfDefaultExport as default };
+    export * from ${escapeGeneratedStringLiteral(sharedImportSource)}`;
+		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
+      __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
 	} else {
 		exportLine = `export default exportModule.default ?? exportModule\n    export * from ${escapeGeneratedStringLiteral(sharedImportSource)}`;
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
-      __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule);`;
+      __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
 	}
-	const prebuildImportLine = usesDeferredSingletonFallback || isWorkspacePackage && command !== "build" ? "" : `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(skipServePrebuildWarmup ? devImportSource : sharedImportSource)};`;
-	const devDynamicImportLine = isWorkspacePackage ? "" : usesDeferredSingletonFallback ? "" : command !== "build" && !skipServePrebuildWarmup ? `;() => import(${escapeGeneratedStringLiteral(devImportSource)}).catch(() => {});` : "";
-	const moduleBody = usesDeferredSingletonFallback ? `
+	const prebuildImportLine = usesDeferredSingletonFallback || usesDeferredTreeShakingFallback ? "" : `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 ? `
     ${prebuildImportLine}
     ${devDynamicImportLine}
     ${importLine}
@@ -1571,7 +2354,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
     ${importLine}
     ${sharedCacheHelperCode}
     ${normalizeLocalShareModuleCode}
-    let exportModule = __mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor})
+    let exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)}
     if (exportModule === undefined) {
       ${initBlock}
     }
@@ -1618,14 +2401,21 @@ function getDirectSharedCacheSeedImportPath(pkg, shareItem) {
 function generateLocalSharedImportMap() {
 	const useDirectReactImport = shouldUseDirectReactImport();
 	const options = getNormalizeModuleFederationOptions();
+	const orderedShares = getOrderedUsedShares();
 	return `
     import {loadShare} from "@module-federation/runtime";
+    ${orderedShares.map((pkg, index) => {
+		const shareItem = getNormalizeShareItem(pkg);
+		if (!shareItem?.shareConfig.eager || shareItem.shareConfig.import === false) return "";
+		return `import * as __mfEagerShare_${index} from ${JSON.stringify(getLocalSharedPackagePath(pkg, shareItem))};`;
+	}).filter(Boolean).join("\n")}
     const importMap = {
-      ${getOrderedUsedShares().map((pkg) => {
+      ${orderedShares.map((pkg, index) => {
 		const shareItem = getNormalizeShareItem(pkg);
 		return `
         ${JSON.stringify(pkg)}: async () => {
-          ${shareItem?.shareConfig.import === false ? `throw new Error(\`[Module Federation] Shared module '\${${JSON.stringify(pkg)}}' must be provided by host\`);` : `let pkg = await import(${JSON.stringify(getLocalSharedPackagePath(pkg, shareItem))});
+          ${shareItem?.shareConfig.import === false ? `throw new Error(\`[Module Federation] Shared module '\${${JSON.stringify(pkg)}}' must be provided by host\`);` : shareItem?.shareConfig.eager ? `let pkg = __mfEagerShare_${index};
+            return pkg;` : `let pkg = await import(${JSON.stringify(getLocalSharedPackagePath(pkg, shareItem))});
             return pkg;`}
         }
       `;
@@ -1635,13 +2425,24 @@ function generateLocalSharedImportMap() {
       ${getOrderedUsedShares().map((key) => {
 		const shareItem = getNormalizeShareItem(key);
 		if (!shareItem) return null;
+		const detectedNamedExports = getSharedNamedExports(key, shareItem);
+		const canLiveRebind = shareItem.shareConfig.import === false || detectedNamedExports !== void 0;
+		const treeShakingConfig = canLiveRebind ? shareItem.shareConfig.treeShaking : void 0;
+		const treeShakingUsage = treeShakingConfig ? getTreeShakingExportUsage(key, shareItem, shareItem.name) : void 0;
+		const treeShakingProviderExports = treeShakingUsage?.kind === "exports" ? treeShakingUsage.usedExports : [];
+		const treeShakingUsedExports = options.injectTreeShakingUsedExports === false ? treeShakingConfig?.usedExports || [] : treeShakingProviderExports;
+		const disableRuntimeInference = treeShakingConfig?.mode === "runtime-infer" && options.injectTreeShakingUsedExports === false;
+		const treeShakingProviderImportId = treeShakingConfig && !disableRuntimeInference && hasTreeShakingSharedProvider(key, shareItem) ? getTreeShakingSharedProviderImportId(key) : void 0;
+		const treeShakingStatus = treeShakingUsage?.kind === "full" || disableRuntimeInference || treeShakingConfig?.mode === "runtime-infer" && !treeShakingProviderImportId && shareItem.shareConfig.import !== false ? 0 : 1;
 		return `
           ${JSON.stringify(key)}: {
             name: ${JSON.stringify(key)},
             version: ${JSON.stringify(shareItem.version)},
             scope: [${JSON.stringify(shareItem.scope)}],
             loaded: false,
+            eager: ${Boolean(shareItem.shareConfig.eager)},
             from: ${JSON.stringify(options.name)},
+            canLiveRebind: ${canLiveRebind},
             async get () {
               if (${shareItem.shareConfig.import === false}) {
                 throw new Error(\`[Module Federation] Shared module '\${${JSON.stringify(key)}}' must be provided by host\`);
@@ -1665,8 +2466,20 @@ function generateLocalSharedImportMap() {
               singleton: ${shareItem.shareConfig.singleton},
               requiredVersion: ${JSON.stringify(shareItem.shareConfig.requiredVersion)},
               strictVersion: ${shareItem.shareConfig.strictVersion},
+              eager: ${Boolean(shareItem.shareConfig.eager)},
               ${shareItem.shareConfig.import === false ? "import: false," : ""}
-            }
+            },
+            ${treeShakingConfig ? `treeShaking: {
+              mode: ${JSON.stringify(treeShakingConfig.mode)},
+              usedExports: ${JSON.stringify(treeShakingUsedExports)},
+              providedExports: ${JSON.stringify(treeShakingProviderExports)},
+              status: ${treeShakingStatus},
+              ${treeShakingProviderImportId ? `async get() {
+                const container = await import(${JSON.stringify(treeShakingProviderImportId)});
+                if (typeof container.init === "function") await container.init();
+                return container.get();
+              },` : ""}
+            }` : ""}
           }
         `;
 	}).filter((x) => x !== null).join(",")}
@@ -1676,6 +2489,7 @@ function generateLocalSharedImportMap() {
 		if (!remote) return null;
 		return `
                 {
+                  alias: ${JSON.stringify(key)},
                   entryGlobalName: ${JSON.stringify(remote.entryGlobalName)},
                   name: ${JSON.stringify(remote.name)},
                   type: ${JSON.stringify(remote.type)},
@@ -1752,6 +2566,7 @@ function getShareItemForPreload(pkg) {
 }
 function generateSharedCacheSeedItem(pkg, shareItem, importPath) {
 	const cacheDescriptor = getSharedCacheDescriptor(pkg, shareItem);
+	const cacheOwner = getNormalizeModuleFederationOptions().name;
 	return `if (__mfReadSharedCache(__mfModuleCache.share, ${JSON.stringify(cacheDescriptor)}) === undefined) {
         const mod = await import(${JSON.stringify(importPath)});
         ${normalizeRuntimeShareCode}
@@ -1761,7 +2576,7 @@ function generateSharedCacheSeedItem(pkg, shareItem, importPath) {
           value: true,
           enumerable: false
         });
-        __mfWriteSharedCache(__mfModuleCache.share, ${JSON.stringify(cacheDescriptor)}, exportModule);
+        __mfWriteSharedCache(__mfModuleCache.share, ${JSON.stringify(cacheDescriptor)}, exportModule, ${JSON.stringify(cacheOwner)});
       }`;
 }
 const normalizeRuntimeShareCode = `const __mfNormalizeRuntimeShare = (mod) => {
@@ -1782,15 +2597,33 @@ const sharedProviderSelectionHelperCode = `const __mfOriginalProviderKey = Symbo
             const selectionVersions = {};
             for (const [version, provider] of Object.entries(versions)) {
               selectionVersions[version] = Object.assign({}, provider, {
-                loaded: false,
-                loading: undefined,
-                lib: undefined,
                 [__mfOriginalProviderKey]: provider
               });
             }
             return selectionVersions;
           };
-          const __mfSelectSharedProvider = (versions, pkg, share, strategy) => {
+          const __mfFindSharedProviderEntry = (versions, provider) => {
+            if (!provider) return undefined;
+            const entries = Object.entries(versions || {});
+            const registeredEntry = entries.find(([, candidate]) => candidate === provider);
+            if (registeredEntry) {
+              return { version: registeredEntry[0], provider, registered: true };
+            }
+            if (typeof provider.version === "string" && provider.version) {
+              return { version: provider.version, provider, registered: false };
+            }
+            const provenanceEntries = entries.filter(([, candidate]) =>
+              candidate === provider || Boolean(provider.from && candidate?.from === provider.from)
+            );
+            if (provenanceEntries.length !== 1) return undefined;
+            return { version: provenanceEntries[0][0], provider, registered: false };
+          };
+          const __mfSelectSharedProvider = (
+            versions,
+            pkg,
+            share,
+            strategy
+          ) => {
             if (!versions || !share) return undefined;
             const scopes = Array.isArray(share.scope) ? share.scope : [share.scope || "default"];
             const selectionVersions = __mfCreateProviderSelectionVersions(versions, strategy);
@@ -1806,10 +2639,103 @@ const sharedProviderSelectionHelperCode = `const __mfOriginalProviderKey = Symbo
             )?.shared;
             return selected?.[__mfOriginalProviderKey] || selected;
           };`;
-function hasImportFalseShared$1(options) {
-	return Object.values(options.shared ?? {}).some((share) => share?.shareConfig?.import === false);
-}
-function generateRuntimeSharedCacheSeedCode() {
+const externalSharedProviderSelectionHelperCode = `const __mfSelectExternalSharedProvider = (
+            versions,
+            pkg,
+            localShare,
+            strategy
+          ) => {
+            const isLocalProvider = (provider) => __mfMatchesSharedProvider(provider, localShare);
+            const candidates = Object.fromEntries(
+              Object.entries(versions || {}).filter(([, provider]) => !isLocalProvider(provider))
+            );
+            if (localShare?.version) {
+              const sameVersionProvider = candidates[localShare.version];
+              // Runtime registration keeps an existing same-version record,
+              // even when it has only a getter and is not loaded yet. Model
+              // that retained provider here so pre-init seeding cannot choose
+              // the local module while loadShare() later chooses the parent.
+              if (!sameVersionProvider) {
+                candidates[localShare.version] = localShare;
+              }
+            }
+            const provider = __mfSelectSharedProvider(
+              candidates,
+              pkg,
+              localShare,
+              strategy
+            );
+            return isLocalProvider(provider) ? undefined : provider;
+          };
+          const __mfMatchesSharedProvider = (provider, expected) => provider === expected || Boolean(
+            expected?.from && provider?.from === expected.from
+          );
+          const __mfGetScopeRootProvider = (
+            instances,
+            scopeRoot,
+            shared,
+            scopeName,
+            pkg,
+            version,
+            provider,
+            passedProvider,
+            strategy
+          ) => {
+            if (strategy !== "version-first" || !passedProvider) return undefined;
+            const scopeRootProviders = scopeRoot?.options?.shared?.[pkg];
+            const configuredScopeRootProvider = Array.isArray(scopeRootProviders)
+              ? scopeRootProviders.find((candidate) => candidate?.version === version)
+              : undefined;
+            const registeredScopeRootProvider = passedProvider?.from === scopeRoot?.options?.name
+              ? passedProvider
+              : undefined;
+            const scopeRootProvider = registeredScopeRootProvider || (
+              __mfMatchesSharedProvider(configuredScopeRootProvider, passedProvider)
+                ? configuredScopeRootProvider
+                // A plain Webpack/Rspack host has no enhanced-runtime instance.
+                // Its pre-init snapshot is still authoritative when this remote's
+                // registration rewrites the same-version provider in-place.
+                : scopeRoot ? undefined : passedProvider
+            );
+            if (!scopeRootProvider) return undefined;
+            const selectedFromLaterInstance = instances.some((instance) =>
+              instance !== scopeRoot &&
+              instance?.options?.name === provider?.from &&
+              instance?.shareScopeMap?.[scopeName] === shared
+            );
+            return selectedFromLaterInstance ? scopeRootProvider : undefined;
+          };
+          const __mfResolveExternalSharedProvider = (
+            instances,
+            scopeRoot,
+            shared,
+            scopeName,
+            pkg,
+            providerEntry,
+            selectedExternalProvider,
+            passedProvider,
+            strategy
+          ) => {
+            const scopeRootProvider = providerEntry.registered ? __mfGetScopeRootProvider(
+              instances,
+              scopeRoot,
+              shared,
+              scopeName,
+              pkg,
+              providerEntry.version,
+              providerEntry.provider,
+              passedProvider,
+              strategy
+            ) : undefined;
+            const provider = scopeRootProvider || selectedExternalProvider;
+            if (!provider) return undefined;
+            if (
+              providerEntry.registered &&
+              !__mfMatchesSharedProvider(provider, passedProvider)
+            ) return undefined;
+            return { provider, scopeRootProvider };
+          };`;
+function generateRuntimeSharedCacheSeedCode(shareStrategy) {
 	const seedOrder = getOrderedUsedShares();
 	return `
     const __mfSeedOrder = ${JSON.stringify(seedOrder)};
@@ -1835,30 +2761,99 @@ function generateRuntimeSharedCacheSeedCode() {
       }
       __mfSeedKeys.splice(insertIndex, 0, pkg);
     }
-    for (const pkg of __mfSeedKeys) {
-      const share = usedShared[pkg];
-      const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
-      if (share.shareConfig?.import === false || __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined) {
-        continue;
-      }
-      const singletonCacheDescriptor = __mfGetSharedCacheDescriptor(pkg, true, share.version, share.scope);
-      const singletonModule = __mfReadSharedCache(__mfModuleCache.share, singletonCacheDescriptor);
-      if (singletonModule !== undefined) {
-        __mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, singletonModule);
-        continue;
+    var __mfSeedLocalShared = async (seedKeys) => {
+      for (const pkg of seedKeys) {
+        const share = usedShared[pkg];
+        const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
+        if (
+          share.shareConfig?.import === false ||
+          Boolean(share.treeShaking) ||
+          __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined
+        ) {
+          continue;
+        }
+        const singletonCacheDescriptor = __mfGetSharedCacheDescriptor(pkg, true, share.version, share.scope);
+        const singletonModule = __mfReadSharedCache(__mfModuleCache.share, singletonCacheDescriptor);
+        if (singletonModule !== undefined) {
+          __mfWriteSharedCache(
+            __mfModuleCache.share,
+            cacheDescriptor,
+            singletonModule,
+            __mfReadSharedCacheOwner(__mfModuleCache.share, singletonCacheDescriptor)
+          );
+          continue;
+        }
+        const factory = await share.get();
+        const mod = typeof factory === "function" ? factory() : factory;
+        const resolved = await Promise.resolve(mod);
+        ${normalizeRuntimeShareCode}
+        const normalizedModule = __mfNormalizeRuntimeShare(resolved);
+        const exportModule = normalizedModule === resolved ? {...resolved} : normalizedModule;
+        Object.defineProperty(exportModule, "__esModule", {
+          value: true,
+          enumerable: false
+        });
+        __mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, exportModule, mfName);
       }
-      const factory = await share.get();
-      const mod = typeof factory === "function" ? factory() : factory;
-      const resolved = await Promise.resolve(mod);
-      ${normalizeRuntimeShareCode}
-      const normalizedModule = __mfNormalizeRuntimeShare(resolved);
-      const exportModule = normalizedModule === resolved ? {...resolved} : normalizedModule;
-      Object.defineProperty(exportModule, "__esModule", {
-        value: true,
-        enumerable: false
-      });
-      __mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, exportModule);
-    }`;
+    };
+    const __mfIsRuntimeOnlySharePending = (pkg) => {
+      const share = usedShared[pkg];
+      if (!share.treeShaking && share.shareConfig?.import !== false) return false;
+      const cacheDescriptor = __mfGetSharedCacheDescriptor(
+        pkg,
+        share.shareConfig?.singleton,
+        share.version,
+        share.scope
+      );
+      return share.treeShaking
+        ? (
+            __mfReadTreeShakingSharedSelection(
+              __mfModuleCache.share,
+              cacheDescriptor,
+              mfName
+            ) === undefined &&
+            __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) === undefined
+          )
+        : __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) === undefined;
+    };
+    const __mfNeedsPreInitSeedBarrier = (pkg) => {
+      const share = usedShared[pkg];
+      const cacheDescriptor = __mfGetSharedCacheDescriptor(
+        pkg,
+        share.shareConfig?.singleton,
+        share.version,
+        share.scope
+      );
+      const cachedShare = share.treeShaking
+        ? (
+            __mfReadTreeShakingSharedSelection(
+              __mfModuleCache.share,
+              cacheDescriptor,
+              mfName
+            ) ?? __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor)
+          )
+        : __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor);
+      if (cachedShare !== undefined) return false;
+      if (share.treeShaking || share.shareConfig?.import === false) return true;
+      if (!share.shareConfig?.singleton) return false;
+      if (typeof __mfSelectExternalSharedProvider !== 'function') return false;
+      return Boolean(__mfSelectExternalSharedProvider(
+        initialShared[pkg],
+        pkg,
+        share,
+        ${JSON.stringify(shareStrategy)}
+      ));
+    };
+    const __mfFirstRuntimeSeedBarrierIndex = __mfSeedKeys.findIndex(
+      __mfNeedsPreInitSeedBarrier
+    );
+    const __mfImmediateSeedKeys = __mfFirstRuntimeSeedBarrierIndex === -1
+      ? __mfSeedKeys
+      : __mfSeedKeys.slice(0, __mfFirstRuntimeSeedBarrierIndex);
+    var __mfDeferredSeedKeys = __mfFirstRuntimeSeedBarrierIndex === -1
+      ? []
+      : __mfSeedKeys.slice(__mfFirstRuntimeSeedBarrierIndex);
+    await __mfSeedLocalShared(__mfImmediateSeedKeys);`;
 }
 function getBrowserImportPath(importPath) {
 	if (/^(?:[a-zA-Z]:[\\/]|\/)/.test(importPath) && !importPath.startsWith("/@")) return `/@fs/${importPath}`;
@@ -1886,11 +2881,178 @@ const REMOTE_ENTRY_ID = "virtual:mf-REMOTE_ENTRY_ID";
 function getRemoteEntryId(options) {
 	return `${REMOTE_ENTRY_ID}:${`${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
 }
-const SSR_ONLY_PLUGIN_SPECIFIERS = new Set(["@module-federation/vite/ssrEntryLoader"]);
-const isSsrOnlyPlugin = (importStatement) => [...SSR_ONLY_PLUGIN_SPECIFIERS].some((s) => importStatement.includes(s));
-const getSsrOnlyPluginSpecifier = (importStatement) => [...SSR_ONLY_PLUGIN_SPECIFIERS].find((s) => importStatement.includes(s));
+const SSR_ONLY_PLUGIN_SPECIFIERS = new Set(["@module-federation/vite/ssrEntryLoader"]);
+const isSsrOnlyPlugin = (importStatement) => [...SSR_ONLY_PLUGIN_SPECIFIERS].some((s) => importStatement.includes(s));
+const getSsrOnlyPluginSpecifier = (importStatement) => [...SSR_ONLY_PLUGIN_SPECIFIERS].find((s) => importStatement.includes(s));
+function generateTreeShakingSharedResolutionCode(enabled) {
+	if (!enabled) return "const __mfResolveTreeShakingShared = async () => {};";
+	return `
+    // Resolve tree-enabled shares through the Runtime after all providers have
+    // registered. Partial providers are stored with their export coverage and
+    // never occupy generic/legacy cache keys, which are reserved for complete
+    // modules only.
+    const __mfResolveTreeShakingShared = async (pkg, share) => {
+      const treeShaking = share.treeShaking;
+      if (!treeShaking) return;
+      try {
+        const factory = await initRes.loadShare(pkg, {
+          customShareInfo: {
+            shareConfig: share.shareConfig,
+            treeShaking: {
+              mode: treeShaking.mode,
+              status: treeShaking.status,
+              usedExports: treeShaking.usedExports,
+            },
+          },
+        });
+        if (factory === false) return;
+        const mod = typeof factory === "function" ? factory() : factory;
+        const resolved = await Promise.resolve(mod);
+        ${normalizeRuntimeShareCode}
+        const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
+        const normalizedShared = __mfNormalizeRuntimeShare(resolved);
+        const providedExports = treeShaking.providedExports ?? treeShaking.usedExports ?? [];
+        const hasPartialProvider =
+          ((treeShaking.mode === "runtime-infer" && treeShaking.status !== 0) ||
+            treeShaking.status === 2);
+        if (hasPartialProvider) {
+          __mfWriteTreeShakingSharedCache(
+            __mfModuleCache.share,
+            cacheDescriptor,
+            providedExports,
+            normalizedShared
+          );
+          __mfWriteTreeShakingSharedSelection(
+            __mfModuleCache.share,
+            cacheDescriptor,
+            mfName,
+            normalizedShared
+          );
+        } else {
+          __mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, normalizedShared);
+        }
+      } catch (e) {
+        console.warn('[Module Federation] Failed to load tree-shaken shared module', pkg, e);
+      }
+    };`;
+}
+const treeShakingResolveShareBodyCode = `const consumerTreeShaking = args.shareInfo?.treeShaking;
+      if (consumerTreeShaking?.mode !== "runtime-infer") return args;
+      const requiredExports = consumerTreeShaking.usedExports;
+      if (!Array.isArray(requiredExports)) return args;
+
+      const originalResolver = args.resolver;
+      args.resolver = () => {
+        const resolved = originalResolver();
+        if (!resolved?.useTreesShaking) return resolved;
+
+        const selectedExports = resolved.shared?.treeShaking?.usedExports;
+        const selectedMatches = Array.isArray(selectedExports) &&
+          requiredExports.every((name) => selectedExports.includes(name));
+        if (selectedMatches) return resolved;
+
+        // Runtime 2.7 prefers a tree provider by version before checking export
+        // coverage. Prefer this consumer's own compatible provider when one is
+        // available; otherwise retain the selected version but use its complete
+        // top-level getter.
+        const localExports = consumerTreeShaking.providedExports;
+        const localMatches = typeof consumerTreeShaking.get === "function" &&
+          Array.isArray(localExports) &&
+          requiredExports.every((name) => localExports.includes(name));
+        if (localMatches) {
+          return { shared: args.shareInfo, useTreesShaking: true };
+        }
+        return { shared: resolved.shared, useTreesShaking: false };
+      };
+      return args;`;
+function generateTreeShakingSnapshotPluginCode(enabled) {
+	if (!enabled) return "";
+	return `
+  const __mfTreeShakingSnapshotPlugin = () => ({
+    name: "vite-tree-shaking-snapshot-plugin",
+    resolveShare(args) {
+      ${treeShakingResolveShareBodyCode}
+    },
+    beforeInit(args) {
+      const { userOptions, origin, options: registeredOptions } = args;
+      const version = userOptions.version || registeredOptions.version;
+      const hostSnapshot = runtimeGlobal.getGlobalSnapshotInfoByModuleInfo({
+        name: origin.name,
+        version,
+      });
+      if (!hostSnapshot || !("shared" in hostSnapshot)) return args;
+
+      const candidates = [];
+      const appendShared = (records) => {
+        for (const [pkgName, value] of Object.entries(records || {})) {
+          const values = Array.isArray(value) ? value : [value];
+          for (const shared of values) candidates.push([pkgName, shared]);
+        }
+      };
+      appendShared(userOptions.shared);
+      appendShared(registeredOptions.shared);
+
+      for (const [pkgName, shared] of candidates) {
+        const treeShaking = shared?.treeShaking;
+        if (!treeShaking || treeShaking.mode !== "server-calc") continue;
+        const shareSnapshot = hostSnapshot.shared.find((item) => item.sharedName === pkgName);
+        if (!shareSnapshot || typeof shareSnapshot.treeShakingStatus !== "number") continue;
+        const {
+          secondarySharedTreeShakingEntry: entry,
+          secondarySharedTreeShakingName: name,
+          treeShakingStatus: status,
+          usedExports,
+          fallbackType,
+        } = shareSnapshot;
+
+        // A CALCULATED snapshot without a loadable secondary entry is not safe:
+        // retain UNKNOWN so the Runtime chooses the complete top-level getter.
+        if (status === 2 && (!entry || !name)) continue;
+        if (Array.isArray(usedExports)) {
+          treeShaking.usedExports = usedExports;
+          treeShaking.providedExports = usedExports;
+        }
+        if (entry && name) {
+          const fullFallbackGet = shared.get;
+          treeShaking.get = async () => {
+            try {
+              const shareEntry = await getRemoteEntry({
+                origin,
+                remoteInfo: {
+                  name,
+                  entry,
+                  type: fallbackType || "global",
+                  entryGlobalName: name,
+                  shareScope: "default",
+                },
+              });
+              if (!shareEntry) throw new Error("Tree-shaken shared entry did not load");
+              if (typeof shareEntry.init === "function") {
+                await shareEntry.init(origin);
+              }
+              return shareEntry.get();
+            } catch (error) {
+              if (typeof fullFallbackGet === "function") return fullFallbackGet();
+              throw error;
+            }
+          };
+        }
+        treeShaking.status = status;
+      }
+      return args;
+    },
+  });`;
+}
 function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(options), command = "build") {
-	const needsSharedProviderSelectionHelper = hasImportFalseShared$1(options);
+	const needsSharedProviderSelectionHelper = Object.keys(options.shared ?? {}).length > 0;
+	const hasTreeShakingShared = Object.values(options.shared ?? {}).some((share) => !!share?.shareConfig.treeShaking);
+	const hasEagerShared = Object.values(options.shared ?? {}).some((share) => share?.shareConfig.eager === true && share.shareConfig.import !== false);
+	const runtimeImports = [
+		"init as runtimeInit",
+		"loadRemote",
+		...hasTreeShakingShared ? ["getRemoteEntry"] : []
+	].join(", ");
+	const runtimeHelperImports = [...hasTreeShakingShared ? ["global as runtimeGlobal"] : [], ...needsSharedProviderSelectionHelper ? ["share as runtimeShare"] : []];
 	const pluginImportNames = options.runtimePlugins.map((p, i) => {
 		if (typeof p === "string") return [
 			`$runtimePlugin_${i}`,
@@ -1903,6 +3065,17 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
 			serializeRuntimeOptions(p[1])
 		];
 	});
+	const initializeSharingCode = `try {
+      await retrySharedInit(async () => {
+        await Promise.all(await initRes.initializeSharing('${options.shareScope}', {
+          strategy: '${options.shareStrategy}',
+          from: "build",
+          initScope
+        }));
+      });
+    } catch (e) {
+      console.error('[Module Federation]', e)
+    }`;
 	return `
   // Shim Vue HMR runtime for dev-compiled components loaded by a non-Vite host.
   // When a remote is served by a Vite dev server, Vue's SFC compiler injects HMR
@@ -1912,8 +3085,9 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   if (typeof __VUE_HMR_RUNTIME__ === 'undefined') {
     globalThis.__VUE_HMR_RUNTIME__ = { createRecord() {}, rerender() {}, reload() {} };
   }
-  import {init as runtimeInit, loadRemote} from "@module-federation/runtime";
-  ${needsSharedProviderSelectionHelper ? "import {share as runtimeShare} from \"@module-federation/runtime/helpers\";" : ""}
+  import {${runtimeImports}} from "@module-federation/runtime";
+  ${hasEagerShared ? `import * as __mfLocalSharedImportMap from "${getLocalSharedImportMapPath()}";` : ""}
+  ${runtimeHelperImports.length ? `import {${runtimeHelperImports.join(", ")}} from "@module-federation/runtime/helpers";` : ""}
   ${pluginImportNames.filter((item) => !isSsrOnlyPlugin(item[1])).map((item) => item[1]).join("\n")}
   ${command === "build" ? getRuntimeInitResolveBootstrapCode() : getRuntimeInitBootstrapCode() + "\n  const { initResolve } = globalThis[globalKey];"}
   ${getRuntimeModuleCacheBootstrapCode()}
@@ -1941,14 +3115,17 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       }
     }
   }
+  ${generateTreeShakingSnapshotPluginCode(hasTreeShakingShared)}
   ${needsSharedProviderSelectionHelper ? sharedProviderSelectionHelperCode : ""}
+  ${needsSharedProviderSelectionHelper ? externalSharedProviderSelectionHelperCode : ""}
 
   async function getLocalSharedImportMap() {
-    if (!localSharedImportMapPromise) {
+    ${hasEagerShared ? "return __mfLocalSharedImportMap;" : ""}
+    ${hasEagerShared ? "" : `if (!localSharedImportMapPromise) {
       localSharedImportMapPromise = retrySharedInit(() => import("${getLocalSharedImportMapPath()}"))
         .catch((e) => { localSharedImportMapPromise = undefined; throw e; });
     }
-    return localSharedImportMapPromise
+    return localSharedImportMapPromise`}
   }
 
   async function getExposesMap() {
@@ -1962,53 +3139,32 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
 
   async function init(shared = {}, initScope = []) {
     ${sharedCacheHelperCode}
-    const {usedShared, usedRemotes} = await getLocalSharedImportMap()
-    try {
-      const allInstances = globalThis.__FEDERATION__?.__SHARE__;
-      if (allInstances) {
-        ${normalizeRuntimeShareCode}
-        for (const [, scopes] of Object.entries(allInstances)) {
-          const scopeShare = scopes?.['${options.shareScope}'];
-          if (!scopeShare) continue;
-          for (const [pkg, versionMap] of Object.entries(scopeShare)) {
-            const usedShare = usedShared?.[pkg];
-            const selectedProvider = usedShare?.shareConfig?.import === false
-              ? __mfSelectSharedProvider(versionMap, pkg, usedShare, '${options.shareStrategy}')
-              : undefined;
-            const providerEntries = usedShare?.shareConfig?.import === false
-              ? Object.entries(versionMap).filter(([, provider]) => provider === selectedProvider)
-              : Object.entries(versionMap);
-            for (const [version, provider] of providerEntries) {
-              if (!provider.lib) continue;
-              const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, provider.shareConfig?.singleton, version, ${JSON.stringify(options.shareScope)});
-              if (__mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined) continue;
-              const mod = typeof provider.lib === "function" ? provider.lib() : provider.lib;
-              const resolved = await Promise.resolve(mod);
-              const normalized = __mfNormalizeRuntimeShare(resolved);
-              __mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, normalized);
-              if (provider.shareConfig?.singleton && usedShare) {
-                const usedCacheDescriptor = __mfGetSharedCacheDescriptor(pkg, usedShare.shareConfig?.singleton, usedShare.version, usedShare.scope);
-                if (__mfReadSharedCache(__mfModuleCache.share, usedCacheDescriptor) === undefined) {
-                  __mfWriteSharedCache(__mfModuleCache.share, usedCacheDescriptor, normalized);
-                }
-              }
-            }
-          }
-        }
-      }
-    } catch (e) {
-      console.error('[Module Federation] Failed to bridge external shared modules', e)
-    }
-    for (const [pkg, share] of Object.entries(usedShared)) {
-      const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
-      if (__mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined) continue;
-      const singletonCacheDescriptor = __mfGetSharedCacheDescriptor(pkg, true, share.version, share.scope);
-      const singletonModule = __mfReadSharedCache(__mfModuleCache.share, singletonCacheDescriptor);
-      if (singletonModule !== undefined) {
-        __mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, singletonModule);
+    const federationInstances = globalThis.__FEDERATION__?.__INSTANCES__ || [];
+    const initRootName = initScope.find((token) => token?.from)?.from;
+    const scopeRoot = federationInstances.find((instance) =>
+      instance?.options?.name === initRootName &&
+      instance?.shareScopeMap?.['${options.shareScope}'] === shared
+    ) || federationInstances.find((instance) =>
+      instance?.options?.name !== mfName &&
+      instance?.shareScopeMap?.['${options.shareScope}'] === shared
+    );
+    const initialShared = Object.create(null);
+    for (const [pkg, versions] of Object.entries(shared)) {
+      const initialVersions = initialShared[pkg] = Object.create(null);
+      for (const [version, provider] of Object.entries(versions)) {
+        // Runtime registration mutates provider records in-place, notably their origin.
+        // Preserve the parent-visible provider and its original provenance.
+        initialVersions[version] = Object.assign({}, provider);
       }
     }
-    ${generateRuntimeSharedCacheSeedCode()}
+    const {usedShared, usedRemotes} = await getLocalSharedImportMap()
+    // handling circular init calls before an external provider can re-enter this container
+    var initToken = initTokens[shareScopeName];
+    if (!initToken)
+      initToken = initTokens[shareScopeName] = { from: mfName };
+    if (initScope.indexOf(initToken) >= 0) return;
+    initScope.push(initToken);
+    ${normalizeRuntimeShareCode}
     const __browserPlugins = [${pluginImportNames.filter((item) => !isSsrOnlyPlugin(item[1])).map((item) => `${item[0]}(${item[2]})`).join(", ")}];
     const __ssrPlugins = typeof globalThis.window === 'undefined'
       ? await Promise.all([${pluginImportNames.filter((item) => isSsrOnlyPlugin(item[1])).map((item) => {
@@ -2017,42 +3173,592 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
 		return `import(${JSON.stringify(specifier)}).then(m => (m.default ?? m)(${opts}))`;
 	}).join(", ")}])
       : [];
+    const __mfRuntimeShareLoadIdKey = "__mf_vite_runtime_share_load_id__";
+    let __mfRuntimeShareLoadId = 0;
+    const __mfRuntimeShareSelections = new Map();
+    const __mfRuntimeShareLifecycles = new Map();
     const initRes = runtimeInit({
       name: mfName,
       remotes: ${options.shareStrategy === "loaded-first" ? "[]" : "usedRemotes"},
       shared: usedShared,
-      plugins: [...__browserPlugins, ...__ssrPlugins],
+      plugins: [__mfSharePinLifecyclePlugin(), ${hasTreeShakingShared ? "__mfTreeShakingSnapshotPlugin()," : ""} ...__browserPlugins, ...__ssrPlugins],
       ${options.shareStrategy ? `shareStrategy: '${options.shareStrategy}'` : ""}
     });
-    // handling circular init calls
-    var initToken = initTokens[shareScopeName];
-    if (!initToken)
-      initToken = initTokens[shareScopeName] = { from: mfName };
-    if (initScope.indexOf(initToken) >= 0) return;
-    initScope.push(initToken);
     initRes.initShareScopeMap('${options.shareScope}', shared);
-    try {
-      await retrySharedInit(async () => {
-        await Promise.all(await initRes.initializeSharing('${options.shareScope}', {
-          strategy: '${options.shareStrategy}',
-          from: "build",
-          initScope
-        }));
+    function __mfSharePinLifecyclePlugin() {
+      return {
+        name: "vite-share-pin-lifecycle-plugin",
+        resolveShare(args) {
+          const loadId = args.shareInfo?.[__mfRuntimeShareLoadIdKey];
+          const lifecycle = loadId === undefined
+            ? undefined
+            : __mfRuntimeShareLifecycles.get(loadId);
+          if (!lifecycle) return args;
+          const defaultResolver = args.resolver;
+          args.resolver = (...resolverArgs) => {
+            lifecycle.pinned.reapply();
+            return defaultResolver(...resolverArgs);
+          };
+          lifecycle.pinned.reveal();
+          return args;
+        }
+      };
+    }
+    const runtimeResolveShareHook = initRes.sharedHandler.hooks.lifecycle.resolveShare;
+    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);
+        const selectedProvider = resolved?.shared;
+        if (
+          selectedProvider &&
+          (typeof selectedProvider === "object" || typeof selectedProvider === "function") &&
+          !__mfRuntimeProviderOrigins.has(selectedProvider)
+        ) {
+          __mfRuntimeProviderOrigins.set(selectedProvider, { from: selectedProvider.from });
+        }
+        if (loadId !== undefined && selectedProvider) {
+          __mfRuntimeShareSelections.set(loadId, selectedProvider);
+        }
+        return resolved;
+      };
+      args.resolver = instrumentedResolver;
+      return args;
+    });
+    const __mfPinSharedProvider = (versionMap, version, currentProvider, provider) => {
+      if (!versionMap || versionMap[version] !== currentProvider) return undefined;
+      const pinnedProvider = Object.assign({}, provider, {
+        version: provider.version ?? version,
+        scope: provider.scope ?? currentProvider?.scope ?? ['${options.shareScope}'],
+        strategy: 'loaded-first'
       });
-    } catch (e) {
-      console.error('[Module Federation]', e)
+      const providerFrom = provider.from;
+      versionMap[version] = pinnedProvider;
+      const isCurrentProviderActive = () => currentProvider === undefined
+        ? versionMap[version] === undefined
+        : versionMap[version] === currentProvider;
+      return {
+        provider: pinnedProvider,
+        reveal() {
+          if (versionMap[version] !== pinnedProvider) return false;
+          if (currentProvider === undefined) delete versionMap[version];
+          else versionMap[version] = currentProvider;
+          return true;
+        },
+        reapply() {
+          if (!isCurrentProviderActive()) return false;
+          versionMap[version] = pinnedProvider;
+          return true;
+        },
+        release(loaded, selected = true) {
+          provider.from = providerFrom;
+          if (versionMap[version] !== pinnedProvider) {
+            return !selected && isCurrentProviderActive();
+          }
+          if (!selected) {
+            if (currentProvider === undefined) delete versionMap[version];
+            else versionMap[version] = currentProvider;
+            return true;
+          }
+          if (!loaded) {
+            if (currentProvider === undefined) delete versionMap[version];
+            else versionMap[version] = currentProvider;
+            return false;
+          }
+          pinnedProvider.from = providerFrom;
+          if (loaded && pinnedProvider.lib) pinnedProvider.loaded = true;
+          if (provider.strategy === undefined) delete pinnedProvider.strategy;
+          else pinnedProvider.strategy = provider.strategy;
+          return true;
+        }
+      };
+    };
+    const __mfSnapshotSharedProviders = (versionMap) => (
+      Object.entries(versionMap || {}).map(([version, provider]) => ({
+        provider,
+        version,
+        from: provider.from,
+        registered: true
+      }))
+    );
+    const __mfMatchLoadedSharedProvider = (providerSelections, factory) => {
+      if (factory === undefined) return undefined;
+      let match;
+      for (const selection of providerSelections) {
+        const provider = selection.provider;
+        const directProvider = provider.treeShaking || provider;
+        if (
+          selection.loadedFactory !== factory &&
+          provider.lib !== factory &&
+          directProvider.lib !== factory
+        ) continue;
+        if (match) return undefined;
+        match = selection;
+      }
+      return match;
+    };
+    const __mfLoadRuntimeShare = async (pkg, shareConfig, pinned) => {
+      const loadId = ++__mfRuntimeShareLoadId;
+      __mfRuntimeShareLifecycles.set(loadId, {
+        pinned
+      });
+      try {
+        const factory = await initRes.loadShare(pkg, {
+          customShareInfo: {
+            shareConfig,
+            [__mfRuntimeShareLoadIdKey]: loadId
+          }
+        });
+        return {
+          factory: factory === false ? undefined : factory,
+          selectedProvider: __mfRuntimeShareSelections.get(loadId)
+        };
+      } finally {
+        __mfRuntimeShareSelections.delete(loadId);
+        __mfRuntimeShareLifecycles.delete(loadId);
+      }
+    };
+    const __mfLoadPinnedRuntimeShare = async (
+      pkg,
+      shareConfig,
+      versionMap,
+      version,
+      currentProvider,
+      provider,
+      providerRegistered = true
+    ) => {
+      const providerFrom = provider.from;
+      const pinned = __mfPinSharedProvider(
+        versionMap,
+        version,
+        currentProvider,
+        provider
+      );
+      if (!pinned) return undefined;
+      let runtimeLoad;
+      try {
+        runtimeLoad = await __mfLoadRuntimeShare(pkg, shareConfig, pinned);
+      } catch (error) {
+        pinned.release(false);
+        throw error;
+      }
+      const factory = runtimeLoad?.factory;
+      if (factory === undefined) {
+        pinned.release(false);
+        return undefined;
+      }
+      const providerSelections = __mfSnapshotSharedProviders(versionMap);
+      const directPinnedProvider = pinned.provider.treeShaking || pinned.provider;
+      const pinnedMatchesFactory =
+        pinned.provider.lib === factory || directPinnedProvider.lib === factory;
+      if (!providerRegistered && pinnedMatchesFactory) {
+        const pinnedSelectionIndex = providerSelections.findIndex(
+          (selection) => selection.provider === pinned.provider
+        );
+        if (pinnedSelectionIndex !== -1) providerSelections.splice(pinnedSelectionIndex, 1);
+      }
+      if (!providerRegistered && !providerSelections.some((selection) => selection.provider === provider)) {
+        providerSelections.push({
+          provider,
+          version,
+          from: providerFrom,
+          registered: false,
+          loadedFactory: pinnedMatchesFactory ? factory : undefined
+        });
+      }
+      const runtimeSelectedProvider =
+        !providerRegistered &&
+        runtimeLoad.selectedProvider === pinned.provider &&
+        pinnedMatchesFactory
+          ? provider
+          : runtimeLoad.selectedProvider;
+      if (
+        runtimeSelectedProvider &&
+        !providerSelections.some((selection) => selection.provider === runtimeSelectedProvider)
+      ) {
+        const runtimeProviderOrigin = __mfRuntimeProviderOrigins.get(runtimeSelectedProvider);
+        const selectedVersion = typeof runtimeSelectedProvider.version === "string" && runtimeSelectedProvider.version
+          ? runtimeSelectedProvider.version
+          : version;
+        providerSelections.push({
+          provider: runtimeSelectedProvider,
+          version: selectedVersion,
+          from: runtimeProviderOrigin ? runtimeProviderOrigin.from : runtimeSelectedProvider.from,
+          registered: versionMap?.[selectedVersion] === runtimeSelectedProvider,
+          loadedFactory: factory
+        });
+      }
+      const selection = providerSelections.find(
+        (candidate) => candidate.provider === runtimeSelectedProvider
+      ) ?? __mfMatchLoadedSharedProvider(providerSelections, factory);
+      const providerStayedActive = pinned.release(
+        true,
+        selection?.provider === pinned.provider
+      );
+      if (!providerStayedActive || !selection) return undefined;
+      const runtimeProviderOrigin = __mfRuntimeProviderOrigins.get(selection.provider);
+      selection.from = selection.provider === provider
+        ? providerFrom
+        : runtimeProviderOrigin
+          ? runtimeProviderOrigin.from
+          : selection.provider.from;
+      if (runtimeProviderOrigin) selection.provider.from = runtimeProviderOrigin.from;
+      const mod = typeof factory === "function" ? factory() : factory;
+      const resolved = await Promise.resolve(mod);
+      if (selection.registered && versionMap?.[selection.version] !== selection.provider) return undefined;
+      return { provider: selection.provider, selection, resolved };
+    };
+    const bridgedProviders = new Set();
+    const bridgeSelections = new Map();
+    const __mfBridgeMaterializedProvider = async (pkg, usedShare, versionMap) => {
+      const singleton = Boolean(usedShare.shareConfig?.singleton);
+      if (singleton && '${options.shareStrategy}' !== 'loaded-first') return;
+      if (usedShare.canLiveRebind === false) return;
+      try {
+        const provider = __mfSelectExternalSharedProvider(
+          versionMap,
+          pkg,
+          usedShare,
+          '${options.shareStrategy}'
+        );
+        const providerEntry = __mfFindSharedProviderEntry(versionMap, provider);
+        if (!providerEntry) return;
+        const { version } = providerEntry;
+        if (!singleton && version !== usedShare.version) return;
+        if (
+          !provider.lib &&
+          !provider.loading &&
+          !(provider.loaded && typeof provider.get === 'function')
+        ) return;
+        const usedCacheDescriptor = __mfGetSharedCacheDescriptor(
+          pkg,
+          singleton,
+          usedShare.version,
+          usedShare.scope
+        );
+        if (__mfReadSharedCache(__mfModuleCache.share, usedCacheDescriptor) !== undefined) return;
+        const liveVersionMap = shared[pkg];
+        const liveProvider = liveVersionMap?.[version];
+        if (providerEntry.registered && !__mfMatchesSharedProvider(liveProvider, provider)) return;
+        let loadedShare;
+        ${options.shareStrategy === "loaded-first" ? `loadedShare = await __mfLoadPinnedRuntimeShare(
+            pkg,
+            usedShare.shareConfig,
+            liveVersionMap,
+            version,
+            liveProvider,
+            provider,
+            providerEntry.registered
+          );` : `// Runtime loadShare() implicitly initializes version-first remotes without
+          // this container's outer initScope. Materialized providers are already active,
+          // so resolve them directly and keep remote initialization on the guarded path.
+          let directFactory = provider.lib;
+          if (!directFactory && provider.loading) directFactory = await provider.loading;
+          if (!directFactory && provider.loaded && typeof provider.get === 'function') {
+            directFactory = await provider.get();
+          }
+          if (!directFactory) return;
+          const directModule = typeof directFactory === "function" ? directFactory() : directFactory;
+          const directResolved = await Promise.resolve(directModule);
+          const directProvider = providerEntry.registered ? liveProvider : provider;
+          loadedShare = {
+            provider: directProvider,
+            selection: {
+              provider: directProvider,
+              version,
+              from: provider.from,
+              registered: providerEntry.registered
+            },
+            resolved: directResolved
+          };`}
+        const actualProvider = loadedShare?.provider;
+        const actualSelection = loadedShare?.selection;
+        if (!actualSelection) return;
+        const resolved = loadedShare?.resolved;
+        if (resolved === undefined) return;
+        if (__mfReadSharedCache(__mfModuleCache.share, usedCacheDescriptor) !== undefined) return;
+        ${options.shareStrategy === "loaded-first" ? `if (
+          actualSelection.registered &&
+          liveVersionMap?.[actualSelection.version] !== actualProvider
+        ) return;` : `if (
+          actualSelection.registered &&
+          liveVersionMap?.[actualSelection.version] !== actualProvider
+        ) return;`}
+        __mfWriteSharedCache(
+          __mfModuleCache.share,
+          usedCacheDescriptor,
+          __mfNormalizeRuntimeShare(resolved),
+          actualSelection.from
+        );
+        bridgedProviders.add(actualProvider);
+      } catch (e) {
+        console.error('[Module Federation] Failed to bridge materialized shared module "' + pkg + '"', e)
+      }
+    };
+    const __mfBridgeExternalSharedProvider = async (
+      pkg,
+      usedShare,
+      versionMap,
+      passedVersionMap,
+      expectedSelection
+    ) => {
+      try {
+        const usedCacheDescriptor = __mfGetSharedCacheDescriptor(pkg, usedShare.shareConfig?.singleton, usedShare.version, usedShare.scope);
+        const cachedShare = __mfReadSharedCache(__mfModuleCache.share, usedCacheDescriptor);
+        const cachedShareOwner = __mfReadSharedCacheOwner(__mfModuleCache.share, usedCacheDescriptor);
+        const selectedExternalProvider = __mfSelectExternalSharedProvider(
+          versionMap,
+          pkg,
+          usedShare,
+          '${options.shareStrategy}'
+        );
+        const selectedRuntimeProvider = selectedExternalProvider ||
+          __mfSelectSharedProvider(versionMap, pkg, usedShare, '${options.shareStrategy}') ||
+          usedShare;
+        const providerEntry = __mfFindSharedProviderEntry(versionMap, selectedRuntimeProvider);
+        if (!providerEntry) return;
+        const selectedLocalProvider = __mfMatchesSharedProvider(selectedRuntimeProvider, usedShare);
+        const { version } = providerEntry;
+        const passedProvider = passedVersionMap?.[version];
+        const resolvedExternalProvider = __mfResolveExternalSharedProvider(
+          federationInstances,
+          scopeRoot,
+          shared,
+          '${options.shareScope}',
+          pkg,
+          providerEntry,
+          selectedExternalProvider,
+          passedProvider,
+          '${options.shareStrategy}'
+        );
+        if (!resolvedExternalProvider && !selectedLocalProvider) return;
+        const { provider, scopeRootProvider } = resolvedExternalProvider || {
+          provider: selectedRuntimeProvider,
+          scopeRootProvider: undefined
+        };
+        // Non-singleton proxies may have already snapshotted their local exports while
+        // seeding shared dependencies. Late cache replacement is safe only for the
+        // live-bound singleton proxies.
+        if (!usedShare.shareConfig?.singleton) return;
+        if (usedShare.canLiveRebind === false) return;
+        // Preserve a singleton already selected by another container. The bridge may
+        // only replace the provisional local fallback seeded by this container.
+        if (cachedShare !== undefined && cachedShareOwner !== mfName) return;
+        // Registration can replace an unloaded same-version root provider in-place.
+        // Pin the chosen provider while loadShare() runs its implicit registration.
+        const liveVersionMap = shared[pkg];
+        const liveProvider = liveVersionMap?.[version];
+        if (
+          providerEntry.registered &&
+          !scopeRootProvider &&
+          !__mfMatchesSharedProvider(liveProvider, provider)
+        ) return;
+        const loadedShare = await __mfLoadPinnedRuntimeShare(
+          pkg,
+          usedShare.shareConfig,
+          liveVersionMap,
+          version,
+          liveProvider,
+          provider,
+          providerEntry.registered && !selectedLocalProvider
+        );
+        const actualProvider = loadedShare?.provider;
+        const actualSelection = loadedShare?.selection;
+        if (!actualSelection) return;
+        if (__mfMatchesSharedProvider(actualProvider, usedShare)) return;
+        if (expectedSelection) {
+          if (
+            expectedSelection.version !== actualSelection.version ||
+            !__mfMatchesSharedProvider({ from: actualSelection.from }, expectedSelection.provider)
+          ) return;
+        }
+        if (bridgedProviders.has(actualProvider)) return;
+        const resolved = loadedShare?.resolved;
+        if (resolved === undefined) return;
+        const latestCachedShare = __mfReadSharedCache(__mfModuleCache.share, usedCacheDescriptor);
+        const latestCachedShareOwner = __mfReadSharedCacheOwner(__mfModuleCache.share, usedCacheDescriptor);
+        if (latestCachedShare !== undefined && latestCachedShareOwner !== mfName) return;
+        if (
+          actualSelection.registered &&
+          liveVersionMap?.[actualSelection.version] !== actualProvider
+        ) return;
+        if (!expectedSelection) {
+          bridgeSelections.set(pkg, {
+            version: actualSelection.version,
+            provider: { from: actualSelection.from }
+          });
+        }
+        bridgedProviders.add(actualProvider);
+        const normalized = __mfNormalizeRuntimeShare(resolved);
+        __mfWriteSharedCache(
+          __mfModuleCache.share,
+          usedCacheDescriptor,
+          normalized,
+          actualSelection.from
+        );
+      } catch (e) {
+        console.error('[Module Federation] Failed to bridge external shared module "' + pkg + '"', e)
+      }
+    };
+    for (const [pkg, usedShare] of Object.entries(usedShared)) {
+      if (usedShare.treeShaking) continue;
+      await __mfBridgeMaterializedProvider(pkg, usedShare, initialShared[pkg]);
     }
     for (const [pkg, share] of Object.entries(usedShared)) {
+      if (share.treeShaking) continue;
+      const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
+      if (__mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined) continue;
+      const singletonCacheDescriptor = __mfGetSharedCacheDescriptor(pkg, true, share.version, share.scope);
+      const singletonModule = __mfReadSharedCache(__mfModuleCache.share, singletonCacheDescriptor);
+      if (singletonModule !== undefined) {
+        __mfWriteSharedCache(
+          __mfModuleCache.share,
+          cacheDescriptor,
+          singletonModule,
+          __mfReadSharedCacheOwner(__mfModuleCache.share, singletonCacheDescriptor)
+        );
+      }
+    }
+    ${generateRuntimeSharedCacheSeedCode(options.shareStrategy)}
+    ${initializeSharingCode}
+    // Calling provider.get() marks a provider as loaded. Wait until the Runtime has
+    // finalized normal same-version precedence before materializing an external share.
+    for (const [pkg, usedShare] of Object.entries(usedShared)) {
+      if (usedShare.treeShaking) continue;
+      await __mfBridgeExternalSharedProvider(
+        pkg,
+        usedShare,
+        shared[pkg],
+        initialShared[pkg],
+        undefined
+      );
+    }
+    try {
+      const allInstances = globalThis.__FEDERATION__?.__SHARE__;
+      const globalVersionsByPackage = Object.create(null);
+      if (allInstances) {
+        for (const [, scopes] of Object.entries(allInstances)) {
+          const scopeShare = scopes?.['${options.shareScope}'];
+          if (!scopeShare) continue;
+          for (const [pkg, versionMap] of Object.entries(scopeShare)) {
+            const usedShare = usedShared?.[pkg];
+            const passedVersions = initialShared[pkg];
+            const bridgeSelection = bridgeSelections.get(pkg);
+            if (!usedShare) continue;
+            if (!passedVersions) continue;
+            if (!bridgeSelection) continue;
+            if (usedShare.treeShaking) continue;
+            const globalVersions = globalVersionsByPackage[pkg] || (globalVersionsByPackage[pkg] = Object.create(null));
+            for (const [version, provider] of Object.entries(versionMap)) {
+              if (!provider.lib) continue;
+              if (bridgeSelection.version !== version) continue;
+              if (!__mfMatchesSharedProvider(provider, bridgeSelection.provider)) continue;
+              const passedProvider = passedVersions[version];
+              const matchesPassedProvider = provider === passedProvider || (
+                passedProvider?.from && provider.from === passedProvider.from
+              );
+              if (!matchesPassedProvider) continue;
+              if (provider === usedShare || (usedShare.from && provider.from === usedShare.from)) continue;
+              if (globalVersions[version] === undefined) globalVersions[version] = provider;
+            }
+          }
+        }
+      }
+      for (const [pkg, versionMap] of Object.entries(globalVersionsByPackage)) {
+        await __mfBridgeExternalSharedProvider(
+          pkg,
+          usedShared[pkg],
+          versionMap,
+          initialShared[pkg],
+          bridgeSelections.get(pkg)
+        );
+      }
+    } catch (e) {
+      console.error('[Module Federation] Failed to bridge external shared modules', e)
+    }
+    ${generateTreeShakingSharedResolutionCode(hasTreeShakingShared)}
+    const __mfResolveImportFalseShared = async (pkg, share) => {
       const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
-      if (share.shareConfig?.import !== false || __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined) continue;
+      const cachedShare = share.treeShaking
+        ? __mfReadTreeShakingSharedSelection(__mfModuleCache.share, cacheDescriptor, mfName)
+        : __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor);
+      if (share.shareConfig?.import !== false || cachedShare !== undefined) return;
       ${normalizeRuntimeShareCode}
-      const versions = shared?.[pkg];
-      const provider = __mfSelectSharedProvider(versions, pkg, share, '${options.shareStrategy}');
-      if (!provider) continue;
-      const factory = provider.lib || (provider.loading ? await provider.loading : await provider.get?.());
-      const mod = typeof factory === "function" ? factory() : factory;
-      const resolved = await Promise.resolve(mod);
-      __mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, __mfNormalizeRuntimeShare(resolved));
+      const versionMap = shared?.[pkg];
+      const provider = __mfSelectSharedProvider(
+        versionMap,
+        pkg,
+        share,
+        '${options.shareStrategy}'
+      ) || share;
+      const providerEntry = __mfFindSharedProviderEntry(versionMap, provider);
+      if (!providerEntry) return;
+      const { version } = providerEntry;
+      const currentProvider = versionMap?.[version];
+      const loadedShare = await __mfLoadPinnedRuntimeShare(
+        pkg,
+        share.shareConfig,
+        versionMap,
+        version,
+        currentProvider,
+        provider,
+        providerEntry.registered && !__mfMatchesSharedProvider(provider, share)
+      );
+      const providerSelection = loadedShare?.selection;
+      const actualProvider = loadedShare?.provider;
+      const resolved = loadedShare?.resolved;
+      if (!providerSelection) return;
+      if (__mfMatchesSharedProvider(actualProvider, share)) return;
+      if (resolved === undefined) return;
+      const latestCachedShare = share.treeShaking
+        ? __mfReadTreeShakingSharedSelection(__mfModuleCache.share, cacheDescriptor, mfName)
+        : __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor);
+      if (latestCachedShare !== undefined) return;
+      if (
+        providerSelection.registered &&
+        versionMap?.[providerSelection.version] !== actualProvider
+      ) return;
+      const normalizedShared = __mfNormalizeRuntimeShare(resolved);
+      if (share.treeShaking) {
+        const providedExports = share.treeShaking.providedExports ?? share.treeShaking.usedExports ?? [];
+        __mfWriteTreeShakingSharedCache(
+          __mfModuleCache.share,
+          cacheDescriptor,
+          providedExports,
+          normalizedShared
+        );
+        __mfWriteTreeShakingSharedSelection(
+          __mfModuleCache.share,
+          cacheDescriptor,
+          mfName,
+          normalizedShared
+        );
+      } else {
+        __mfWriteSharedCache(
+          __mfModuleCache.share,
+          cacheDescriptor,
+          normalizedShared,
+          providerSelection.from
+        );
+      }
+    };
+    // Resolve runtime-only dependencies and seed local fallbacks in dependency
+    // order. Stop at an unresolved provider so its consumers cannot capture an
+    // undefined or provisional singleton.
+    for (const pkg of __mfDeferredSeedKeys) {
+      const share = usedShared[pkg];
+      if (__mfIsRuntimeOnlySharePending(pkg)) {
+        if (share.treeShaking) {
+          await __mfResolveTreeShakingShared(pkg, share);
+        } else if (share.shareConfig?.import === false) {
+          await __mfResolveImportFalseShared(pkg, share);
+        }
+      }
+      if (__mfIsRuntimeOnlySharePending(pkg)) break;
+      await __mfSeedLocalShared([pkg]);
     }
     initResolve(initRes)
     return initRes
@@ -2078,6 +3784,7 @@ let currentHostAutoInitCommand = "build";
 function generateHostAutoInitCode(remoteEntryImport, _command = "build") {
 	const shouldPreloadShares = getNormalizeModuleFederationOptions().shareStrategy !== "loaded-first";
 	const hostInitShareOrder = JSON.stringify(getOrderedUsedShares());
+	const cacheOwner = JSON.stringify(getNormalizeModuleFederationOptions().name);
 	return `
     ${getRuntimeModuleCacheBootstrapCode()}
     let hostInitPromise;
@@ -2096,6 +3803,10 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build") {
           for (const pkg of __mfHostInitShareOrder) {
             const share = usedShared[pkg];
             if (!share) continue;
+            // remoteEntry.init resolves tree-enabled shares into the
+            // coverage-aware cache. Never republish that selected partial under
+            // a generic full-module key here.
+            if (share.treeShaking) continue;
             const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
             if (__mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined) {
               continue;
@@ -2105,7 +3816,12 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build") {
             }).then((factory) => {
               const mod = typeof factory === "function" ? factory() : factory;
               return Promise.resolve(mod).then((resolved) => {
-                __mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, __mfNormalizeRuntimeShare(resolved));
+                __mfWriteSharedCache(
+                  __mfModuleCache.share,
+                  cacheDescriptor,
+                  __mfNormalizeRuntimeShare(resolved),
+                  ${cacheOwner}
+                );
               });
             });
           }
@@ -2158,9 +3874,8 @@ function addUsedRemote(remoteKey, remoteModule) {
 function getUsedRemotesMap() {
 	return usedRemotesMap;
 }
-function getRemoteFromId(id, remotes) {
-	const remoteName = Object.keys(remotes).filter((name) => id === name || id.startsWith(name + "/")).sort((a, b) => b.length - a.length)[0];
-	return remoteName ? remotes[remoteName] : void 0;
+function getRemoteAliasFromId(id, remotes) {
+	return Object.keys(remotes).filter((name) => id === name || id.startsWith(name + "/")).sort((a, b) => b.length - a.length)[0];
 }
 function resolveRemoteInitMode(shareStrategy, consumer) {
 	if (shareStrategy !== "loaded-first") return "eager";
@@ -2316,10 +4031,12 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
 	const isLoadedFirst = options.shareStrategy === "loaded-first";
 	const initMode = resolveRemoteInitMode(options.shareStrategy, consumer);
 	const deferRemoteLoad = shouldDeferRemoteLoad(initMode);
-	const remote = getRemoteFromId(id, options.remotes);
+	const remoteAlias = getRemoteAliasFromId(id, options.remotes);
+	const remote = remoteAlias ? options.remotes[remoteAlias] : void 0;
 	const registerRemoteCode = isLoadedFirst && remote ? `runtime.registerRemotes([${JSON.stringify({
 		entryGlobalName: remote.entryGlobalName,
 		name: remote.name,
+		alias: remoteAlias,
 		type: remote.type,
 		entry: remote.entry,
 		shareScope: remote.shareScope ?? "default"
@@ -2391,7 +4108,7 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
 const HOST_INIT_PRELOAD_CHUNKS = [
 	(name) => name === "hostInit",
 	(name) => name === "remoteEntry",
-	(name) => name.startsWith("_virtual_mf"),
+	(name) => name.startsWith("_virtual_mf") && !name.includes("__prebuild__"),
 	(name) => name === "index"
 ];
 function escapeHtmlAttr(value) {
@@ -2593,7 +4310,7 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 		return decodeViteId(id).replace(/^\0/, "");
 	}
 	function normalizeModuleId(id) {
-		return id.split("?")[0].replace(/\\/g, "/");
+		return normalizePathForImport(id.split("?")[0]);
 	}
 	function resolveProjectId(id) {
 		if (id.startsWith("\0") || id.startsWith("virtual:")) return normalizeModuleId(id);
@@ -2630,8 +4347,8 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 			const resolvedEntryPath = getEntryPath();
 			if (resolvedEntryPath.startsWith("virtual:mf")) devEntryPath = config.base + VITE_ID_PREFIX.slice(1) + resolvedEntryPath;
 			else {
-				const normalized = resolvedEntryPath.replace(/\\\\?/g, "/");
-				const root = config.root.replace(/\\\\?/g, "/").replace(/\/$/, "");
+				const normalized = normalizePathForImport(resolvedEntryPath);
+				const root = normalizePathForImport(config.root).replace(/\/$/, "");
 				const relativePath = normalized.startsWith(root + "/") ? normalized.slice(root.length) : "/" + normalized.replace(/^[A-Za-z]:[\\/]/, "");
 				devEntryPath = config.base + relativePath.replace(/^\//, "");
 			}
@@ -3382,7 +5099,7 @@ function initVirtualModules(command, remoteEntryId, enableSsrInit = false) {
 function isOutputChunk$1(chunk) {
 	return chunk.type === "chunk";
 }
-function escapeRegExp(value) {
+function escapeRegExp$1(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function getProxyBaseName(fileName) {
@@ -3474,7 +5191,7 @@ function rewriteEsmProxyConsumers(code, proxyChunks) {
 	const claimedLocals = /* @__PURE__ */ new Set();
 	for (const [proxyFileName, proxyInfo] of Array.from(proxyChunks.entries())) {
 		const proxyBaseName = getProxyBaseName(proxyFileName);
-		const importMatch = new RegExp(`import\\s*\\{([^}]+)\\}\\s*from\\s*["']([^"']*${escapeRegExp(proxyBaseName)}[^"']*)["']\\s*;?`).exec(nextCode);
+		const importMatch = new RegExp(`import\\s*\\{([^}]+)\\}\\s*from\\s*["']([^"']*${escapeRegExp$1(proxyBaseName)}[^"']*)["']\\s*;?`).exec(nextCode);
 		if (!importMatch) continue;
 		const fullImport = importMatch[0];
 		const bindings = importMatch[1].split(",").map((s) => {
@@ -3531,7 +5248,7 @@ function rewriteSystemProxyConsumers(code, systemProxyInfo) {
 	let nextCode = code;
 	for (const [proxyFileName, proxyInfo] of Array.from(systemProxyInfo.entries())) {
 		const proxyBaseName = getProxyBaseName(proxyFileName);
-		const depMatch = new RegExp(`["']([^"']*${escapeRegExp(proxyBaseName)}[^"']*)["']`).exec(nextCode);
+		const depMatch = new RegExp(`["']([^"']*${escapeRegExp$1(proxyBaseName)}[^"']*)["']`).exec(nextCode);
 		if (!depMatch) continue;
 		let setterIndex = 0;
 		const depListMatch = nextCode.match(/System\.register\(\[([\s\S]*?)\]/);
@@ -3890,10 +5607,28 @@ function createRemoteEntryAssetMap(fileName) {
 		}
 	};
 }
+function isTreeShakingProviderChunk(file) {
+	if (file.type !== "chunk") return false;
+	if (file.facadeModuleId?.includes("__treeShakingProvider__")) return true;
+	return Object.keys(file.modules || {}).some((id) => id.includes("__treeShakingProvider__") || id.includes("__mf_tree_shaking_graph__"));
+}
+function getTreeShakingBuildInfo(options) {
+	if (!(Object.values(options.shared || {}).some((share) => !!share.shareConfig.treeShaking) || !!options.treeShakingSharedPlugins?.length || !!options.treeShakingSharedExcludePlugins?.length)) return {};
+	return {
+		target: [options.target || "web"],
+		...options.treeShakingSharedPlugins?.length ? { plugins: [...options.treeShakingSharedPlugins] } : {},
+		...options.treeShakingSharedExcludePlugins?.length ? { excludePlugins: [...options.treeShakingSharedExcludePlugins] } : {}
+	};
+}
+function getRemoteContainerName(remoteKey, remote) {
+	const entryGlobalName = remote.entryGlobalName;
+	if (entryGlobalName && entryGlobalName !== remoteKey && entryGlobalName !== remote.entry) return entryGlobalName;
+	return remote.name;
+}
 const Manifest = () => {
 	const mfOptions = getNormalizeModuleFederationOptions();
 	const { name, filename, getPublicPath, manifest: manifestOptions, varFilename } = mfOptions;
-	let mfManifestName = manifestOptions === true ? "mf-manifest.json" : typeof manifestOptions === "object" ? path$1.join(manifestOptions?.filePath || "", manifestOptions?.fileName || "mf-manifest.json") : void 0;
+	let mfManifestName = manifestOptions === true ? "mf-manifest.json" : typeof manifestOptions === "object" ? normalizePathForImport(path$1.join(manifestOptions?.filePath || "", manifestOptions?.fileName || "mf-manifest.json")) : void 0;
 	let mfManifestStatsName = mfManifestName ? getStatsFileName(mfManifestName) : void 0;
 	const isConsumerProject = Object.keys(mfOptions.exposes).length === 0;
 	let disableAssetsAnalyze = false;
@@ -3942,7 +5677,8 @@ const Manifest = () => {
 								type: "app",
 								buildInfo: {
 									buildVersion: getBuildVersion(),
-									buildName: name
+									buildName: name,
+									...getTreeShakingBuildInfo(mfOptions)
 								},
 								remoteEntry: {
 									name: devRemoteEntryFile,
@@ -3997,6 +5733,16 @@ const Manifest = () => {
 			if (foundRemoteEntryFile) remoteEntryFile = foundRemoteEntryFile;
 			ssrRemoteEntryFile = foundSsrRemoteEntryFile || (_command === "serve" ? getSsrRemoteEntryFileName(resolveDevRemoteEntryFileName(mfOptions.filename)) : expectedSsrRemoteEntryFile);
 			const allCssAssets = mfOptions.bundleAllCSS && !disableAssetsAnalyze ? collectCssAssets(bundle) : /* @__PURE__ */ new Set();
+			if (allCssAssets.size > 0) {
+				const secondaryCss = /* @__PURE__ */ new Set();
+				const primaryCss = /* @__PURE__ */ new Set();
+				for (const file of Object.values(bundle)) {
+					if (file.type !== "chunk") continue;
+					const target = isTreeShakingProviderChunk(file) ? secondaryCss : primaryCss;
+					for (const css of file.viteMetadata?.importedCss || []) target.add(css);
+				}
+				for (const css of secondaryCss) if (!primaryCss.has(css)) allCssAssets.delete(css);
+			}
 			if (!disableAssetsAnalyze) {
 				const exposesModules = Object.keys(mfOptions.exposes).map((item) => mfOptions.exposes[item].import);
 				processModuleAssets(bundle, filesMap, (modulePath) => {
@@ -4008,7 +5754,7 @@ const Manifest = () => {
 					stripKnownJsExtensions: true
 				});
 				const fileToShareKey = await buildFileToShareKeyMap(getUsedShares(), this.resolve.bind(this));
-				processModuleAssets(bundle, filesMap, (modulePath) => fileToShareKey.get(modulePath));
+				processModuleAssets(Object.fromEntries(Object.entries(bundle).filter(([, file]) => !isTreeShakingProviderChunk(file))), filesMap, (modulePath) => fileToShareKey.get(modulePath));
 				if (mfOptions.bundleAllCSS) addCssAssetsToAllExports(filesMap, allCssAssets);
 				filesMap = deduplicateAssets(filesMap);
 			}
@@ -4052,22 +5798,37 @@ const Manifest = () => {
 			path: "",
 			type: "var"
 		} : void 0;
-		const remotes = Array.from(Object.entries(getUsedRemotesMap())).flatMap(([remoteKey, modules]) => Array.from(modules).map((moduleKey) => ({
-			federationContainerName: options.remotes[remoteKey].entry,
-			moduleName: moduleKey.replace(remoteKey, "").replace("/", ""),
-			alias: remoteKey,
-			entry: "*"
-		})));
+		const remotes = Array.from(Object.entries(getUsedRemotesMap())).flatMap(([remoteKey, modules]) => {
+			const remote = options.remotes[remoteKey];
+			return Array.from(modules).map((moduleKey) => ({
+				federationContainerName: getRemoteContainerName(remoteKey, remote),
+				moduleName: moduleKey.replace(remoteKey, "").replace("/", ""),
+				alias: remoteKey,
+				entry: "*"
+			}));
+		});
 		const shared = Array.from(getUsedShares()).flatMap((shareKey) => {
 			const shareItem = getNormalizeShareItem(shareKey);
 			if (!shareItem) return [];
 			const assets = preloadMap[shareKey] || (_command === "serve" && resolvedRemoteEntryFile ? createRemoteEntryAssetMap(resolvedRemoteEntryFile) : createEmptyAssetMap());
+			const treeShakingUsage = getTreeShakingExportUsage(shareKey, shareItem, shareItem.name);
+			const treeShakingUsedExports = treeShakingUsage?.kind === "exports" ? treeShakingUsage.usedExports : [];
+			const treeShakingStatus = treeShakingUsage?.kind === "full" ? 0 : 1;
 			return [{
 				id: `${name}:${shareKey}`,
 				name: shareKey,
 				version: shareItem.version,
 				singleton: shareItem.shareConfig.singleton,
 				requiredVersion: shareItem.shareConfig.requiredVersion,
+				...shareItem.shareConfig.treeShaking ? {
+					usedExports: treeShakingUsedExports,
+					referenceExports: treeShakingUsedExports,
+					treeShaking: {
+						mode: shareItem.shareConfig.treeShaking.mode,
+						...treeShakingUsage?.kind === "exports" ? { usedExports: treeShakingUsedExports } : {},
+						status: treeShakingStatus
+					}
+				} : {},
 				assets: {
 					js: {
 						async: assets.js.async,
@@ -4107,7 +5868,8 @@ const Manifest = () => {
 				type: "app",
 				buildInfo: {
 					buildVersion: getBuildVersion(),
-					buildName: name
+					buildName: name,
+					...getTreeShakingBuildInfo(options)
 				},
 				remoteEntry,
 				ssrRemoteEntry,
@@ -4152,32 +5914,41 @@ function getStatsFileName(manifestFileName) {
 	const fileExt = parsed.ext || ".json";
 	const baseName = parsed.ext ? parsed.name : parsed.base;
 	const fileName = `${baseName === "mf-manifest" ? "mf" : baseName}-stats${fileExt}`;
-	return parsed.dir ? path$1.join(parsed.dir, fileName) : fileName;
+	return parsed.dir ? normalizePathForImport(path$1.join(parsed.dir, fileName)) : fileName;
 }
 //#endregion
 //#region src/plugins/pluginModuleParseEnd.ts
 let _resolve = null;
 let _parseTimeout = null;
+let _settleTimeout = null;
 let parsePromise = Promise.resolve(1);
-let exposesParseEnd = false;
-let expectsExposesParseEnd = false;
 let parseStartSet = /* @__PURE__ */ new Set();
 let parseEndSet = /* @__PURE__ */ new Set();
+let lastLoadedModule = "";
+let lastParsedModule = "";
 function clearParseTimeout() {
 	if (_parseTimeout) {
 		clearTimeout(_parseTimeout);
 		_parseTimeout = null;
 	}
 }
+function clearSettleTimeout() {
+	if (_settleTimeout) {
+		clearTimeout(_settleTimeout);
+		_settleTimeout = null;
+	}
+}
 function resetParseState() {
 	clearParseTimeout();
-	exposesParseEnd = false;
-	expectsExposesParseEnd = false;
+	clearSettleTimeout();
 	parseStartSet = /* @__PURE__ */ new Set();
 	parseEndSet = /* @__PURE__ */ new Set();
+	lastLoadedModule = "";
+	lastParsedModule = "";
 	parsePromise = new Promise((resolve) => {
 		_resolve = (v) => {
 			clearParseTimeout();
+			clearSettleTimeout();
 			resolve(v);
 		};
 	});
@@ -4191,10 +5962,18 @@ function setParseTimeout(timeout) {
 function resetIdleTimeout(timeout) {
 	clearParseTimeout();
 	_parseTimeout = setTimeout(() => {
-		mfWarn(`moduleParseIdleTimeout: no module activity for ${timeout}s, forcing resolve. Some shared/remote dependencies may be missing. Consider increasing moduleParseIdleTimeout.`);
+		const pendingModules = Array.from(parseStartSet).filter((moduleId) => !parseEndSet.has(moduleId));
+		mfWarn(`moduleParseIdleTimeout: no module activity for ${timeout}s, forcing resolve. Some shared/remote dependencies may be missing. Consider increasing moduleParseIdleTimeout. Tracked modules: ${parseEndSet.size}/${parseStartSet.size}.` + (lastLoadedModule ? ` Last loaded: ${lastLoadedModule}.` : "") + (lastParsedModule ? ` Last parsed: ${lastParsedModule}.` : "") + (pendingModules.length ? ` Pending modules: ${pendingModules.slice(0, 10).join(", ")}` : ""));
 		_resolve?.(1);
 	}, timeout * 1e3);
 }
+function scheduleParseCompletionCheck() {
+	clearSettleTimeout();
+	_settleTimeout = setTimeout(() => {
+		_settleTimeout = null;
+		if (parseStartSet.size > 0 && Array.from(parseStartSet).every((moduleId) => parseEndSet.has(moduleId))) _resolve?.(1);
+	}, 10);
+}
 function pluginModuleParseEnd_default(excludeFn, options) {
 	const idleTimeout = options.moduleParseIdleTimeout ?? options.moduleParseTimeout;
 	return [
@@ -4209,14 +5988,20 @@ function pluginModuleParseEnd_default(excludeFn, options) {
 			enforce: "pre",
 			name: "parseStart",
 			apply: "build",
-			buildStart() {
+			async buildStart() {
 				resetParseState();
 				if (idleTimeout) resetIdleTimeout(idleTimeout);
-				else setParseTimeout(options.moduleParseTimeout);
+				else if (options.moduleParseTimeout) setParseTimeout(options.moduleParseTimeout);
+				for (const importSource of options.exposedModuleImports || []) {
+					const resolved = await this.resolve(importSource);
+					if (resolved && !resolved.external && !excludeFn(resolved.id)) parseStartSet.add(resolved.id);
+				}
 			},
 			load(id) {
+				lastLoadedModule = id;
 				if (excludeFn(id)) return;
-				if (id === options.virtualExposesId) expectsExposesParseEnd = true;
+				clearSettleTimeout();
+				if (idleTimeout) resetIdleTimeout(idleTimeout);
 				parseStartSet.add(id);
 			}
 		},
@@ -4225,12 +6010,18 @@ function pluginModuleParseEnd_default(excludeFn, options) {
 			name: "parseEnd",
 			apply: "build",
 			moduleParsed(module) {
+				clearSettleTimeout();
 				const id = module.id;
-				if (id === options.virtualExposesId) exposesParseEnd = true;
+				lastParsedModule = id;
 				if (idleTimeout) resetIdleTimeout(idleTimeout);
-				if (excludeFn(id)) return;
-				parseEndSet.add(id);
-				if (parseStartSet.size === parseEndSet.size && (!expectsExposesParseEnd || exposesParseEnd)) _resolve?.(1);
+				const parsedModule = module;
+				const addPendingResolutions = (resolutions) => {
+					for (const resolution of resolutions || []) if (!resolution.external && !excludeFn(resolution.id)) parseStartSet.add(resolution.id);
+				};
+				addPendingResolutions(parsedModule.importedIdResolutions);
+				addPendingResolutions(parsedModule.dynamicallyImportedIdResolutions);
+				if (!excludeFn(id)) parseEndSet.add(id);
+				scheduleParseCompletionCheck();
 			},
 			buildEnd() {
 				_resolve?.(1);
@@ -4249,6 +6040,9 @@ function resolveDevHashEntryFileName(fileName) {
 function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposesId }) {
 	let viteConfig, _command, root;
 	let exposeRemoteDependencies = {};
+	let exposeRemoteDependenciesDirty = true;
+	let refreshPromise;
+	let dependencyInvalidationVersion = 0;
 	function isRemoteImport(source) {
 		return Object.keys(options.remotes).some((name) => source === name || source.startsWith(name + "/"));
 	}
@@ -4287,12 +6081,26 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		return Array.from(dependencies).sort();
 	}
 	async function refreshExposeRemoteDependencies(ctx) {
-		const next = {};
-		for (const [exposeKey, expose] of Object.entries(options.exposes)) {
-			const resolved = await ctx.resolve(expose.import);
-			next[exposeKey] = resolved?.id ? await collectRemoteDependencies(ctx, resolved.id) : [];
+		if (!exposeRemoteDependenciesDirty) return;
+		if (!refreshPromise) {
+			const refreshVersion = dependencyInvalidationVersion;
+			refreshPromise = (async () => {
+				const next = {};
+				for (const [exposeKey, expose] of Object.entries(options.exposes)) {
+					const resolved = await ctx.resolve(expose.import);
+					next[exposeKey] = resolved?.id ? await collectRemoteDependencies(ctx, resolved.id) : [];
+				}
+				exposeRemoteDependencies = next;
+				if (refreshVersion === dependencyInvalidationVersion) exposeRemoteDependenciesDirty = false;
+			})().finally(() => {
+				refreshPromise = void 0;
+			});
 		}
-		exposeRemoteDependencies = next;
+		await refreshPromise;
+	}
+	function invalidateExposeRemoteDependencies() {
+		exposeRemoteDependenciesDirty = true;
+		dependencyInvalidationVersion += 1;
 	}
 	return {
 		name: "proxyRemoteEntry",
@@ -4315,6 +6123,12 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 				});
 			}
 		},
+		watchChange() {
+			invalidateExposeRemoteDependencies();
+		},
+		handleHotUpdate() {
+			invalidateExposeRemoteDependencies();
+		},
 		async resolveId(id, importer) {
 			if (id === remoteEntryId) return remoteEntryId;
 			if (id === virtualExposesId) return virtualExposesId;
@@ -4325,16 +6139,22 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 				if (resolved) return resolved;
 			}
 		},
-		load(id) {
+		async load(id) {
 			if (id === remoteEntryId) return parsePromise.then((_) => generateRemoteEntry(options, virtualExposesId, _command));
-			if (id === virtualExposesId) return generateExposes(options, exposeRemoteDependencies, _command);
+			if (id === virtualExposesId) {
+				await refreshExposeRemoteDependencies(this);
+				return generateExposes(options, exposeRemoteDependencies, _command);
+			}
 			if (_command === "serve" && id.includes(getHostAutoInitPath())) return id;
 		},
-		transform(code, id) {
-			return mapCodeToCodeWithSourcemap((() => {
+		async transform(code, id) {
+			return mapCodeToCodeWithSourcemap(await (async () => {
 				if (!filterId(id)) return;
 				if (id.includes(remoteEntryId)) return parsePromise.then((_) => generateRemoteEntry(options, virtualExposesId, _command));
-				if (id === virtualExposesId) return generateExposes(options, exposeRemoteDependencies, _command);
+				if (id === virtualExposesId) {
+					await refreshExposeRemoteDependencies(this);
+					return generateExposes(options, exposeRemoteDependencies, _command);
+				}
 				if (id.includes(getHostAutoInitPath())) {
 					if (_command === "serve") {
 						const host = typeof viteConfig.server?.host === "string" && viteConfig.server.host !== "0.0.0.0" ? viteConfig.server.host : "localhost";
@@ -4409,6 +6229,9 @@ function resolveRemoteConsumer(ctx, hasMultiEnvironment) {
 function isNodeModulesImporter(importer) {
 	return importer?.includes("/node_modules/") || importer?.includes("\\node_modules\\");
 }
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function appendAlias(config, alias) {
 	config.resolve ??= {};
 	const existingAlias = config.resolve.alias;
@@ -4451,10 +6274,9 @@ function pluginProxyRemotes_default(options) {
 		config(config, { command: _command }) {
 			command = _command;
 			root = config.root || process.cwd();
-			Object.keys(remotes).forEach((key) => {
-				const remote = remotes[key];
+			Object.keys(remotes).forEach((remoteAlias) => {
 				appendAlias(config, {
-					find: new RegExp(`^(${remote.name}(\/.*|$))`),
+					find: new RegExp(`^(${escapeRegExp(remoteAlias)}(\/.*|$))`),
 					replacement: "$1"
 				});
 			});
@@ -4465,9 +6287,9 @@ function pluginProxyRemotes_default(options) {
 		},
 		resolveId(source, importer) {
 			if (!filterId(source)) return;
-			for (const remote of Object.values(remotes)) {
-				if (source !== remote.name && !source.startsWith(`${remote.name}/`)) continue;
-				return resolveRemoteId(this, source, importer, remote.name);
+			for (const remoteAlias of Object.keys(remotes)) {
+				if (source !== remoteAlias && !source.startsWith(`${remoteAlias}/`)) continue;
+				return resolveRemoteId(this, source, importer, remoteAlias);
 			}
 		}
 	};
@@ -4625,6 +6447,36 @@ function proxySharedModule(options) {
 	const savePrebuild = new PromiseStore();
 	let devServer;
 	const materializedLoadShareSources = /* @__PURE__ */ new Set();
+	const emittedTreeShakingProviders = /* @__PURE__ */ new Set();
+	const normalizeTreeShakingOutputPath = (value) => {
+		const normalized = normalizePathForImport(value);
+		if (path$1.posix.isAbsolute(normalized) || /^[A-Za-z]:\//.test(normalized) || normalized.split("/").includes("..")) throw new Error(`Invalid treeShakingDir "${value}": absolute paths and parent segments are not allowed.`);
+		let start = normalized.startsWith("./") ? 2 : 0;
+		let end = normalized.length;
+		while (start < end && normalized.charCodeAt(start) === 47) start++;
+		while (end > start && normalized.charCodeAt(end - 1) === 47) end--;
+		return normalized.slice(start, end);
+	};
+	const getTreeShakingProviderFileName = (pkg, shareItem) => {
+		if (!shareItem.shareConfig.treeShaking) return void 0;
+		const normalizedOptions = getNormalizeModuleFederationOptions();
+		const outputDir = normalizedOptions.treeShakingDir ? normalizeTreeShakingOutputPath(normalizedOptions.treeShakingDir) : void 0;
+		const fileName = outputDir ? path$1.posix.join(outputDir, `${getTreeShakingSharedProviderName(pkg)}.js`) : void 0;
+		if (!fileName) return void 0;
+		return fileName;
+	};
+	const emitTreeShakingProvider = (context, pkg, shareItem) => {
+		if (_command !== "build" || emittedTreeShakingProviders.has(pkg)) return;
+		if (!hasTreeShakingSharedProvider(pkg, shareItem)) return;
+		const fileName = getTreeShakingProviderFileName(pkg, shareItem);
+		context.emitFile({
+			type: "chunk",
+			id: getTreeShakingSharedProviderImportId(pkg),
+			name: getTreeShakingSharedProviderName(pkg),
+			...fileName ? { fileName } : {}
+		});
+		emittedTreeShakingProviders.add(pkg);
+	};
 	return [
 		{
 			name: "generateLocalSharedImportMap",
@@ -4640,7 +6492,16 @@ function proxySharedModule(options) {
 				if (source === getLocalSharedImportMapPath()) return getResolvedLocalSharedImportMapId();
 			},
 			load(id) {
-				if (id === getResolvedLocalSharedImportMapId()) return parsePromise.then((_) => generateLocalSharedImportMap());
+				if (id === getResolvedLocalSharedImportMapId()) return parsePromise.then((_) => {
+					refreshTreeShakingModules();
+					const providerPackages = new Set([...Object.keys(shared).filter((pkg) => !pkg.endsWith("/")), ...getUsedShares()]);
+					for (const pkg of providerPackages) {
+						const sharedKey = findSharedKeyForSource(pkg, shared);
+						const shareItem = shared[pkg] || (sharedKey ? shared[sharedKey] : void 0);
+						if (shareItem) emitTreeShakingProvider(this, pkg, shareItem);
+					}
+					return generateLocalSharedImportMap();
+				});
 			},
 			closeBundle() {
 				if (devServer) return;
@@ -4652,6 +6513,9 @@ function proxySharedModule(options) {
 			enforce: "post",
 			config(config, { command }) {
 				setPackageDetectionCwd(config.root || process.cwd());
+				setTreeShakingBuildMode(command === "build");
+				resetTreeShakingExports();
+				emittedTreeShakingProviders.clear();
 				const isVinext = hasPackageDependency("vinext");
 				const isAstro = hasPackageDependency("astro");
 				const isRolldown = getIsRolldown(this);
@@ -4675,12 +6539,62 @@ function proxySharedModule(options) {
 				});
 				writeLocalSharedImportMap();
 				refreshHostAutoInit();
+			},
+			buildStart() {
+				if (_command !== "build") return;
+				resetTreeShakingExports();
+				emittedTreeShakingProviders.clear();
+				refreshTreeShakingModules();
+			},
+			shouldTransformCachedModule() {
+				return _command === "build" && Object.values(shared).some((share) => !!share.shareConfig.treeShaking);
+			},
+			transform(code, id) {
+				if (_command !== "build" || !Object.keys(shared).some((key) => shared[key].shareConfig.treeShaking)) return;
+				collectTreeShakingImports(code, id, shared, findSharedKeyForSource, recordTreeShakingExports, markTreeShakingPackageUnsafe);
+				refreshTreeShakingModules();
+			}
+		},
+		{
+			name: "proxyPreBuildShared:tree-shaking-graph",
+			enforce: "pre",
+			apply: "build",
+			async resolveId(source, importer, resolveOptions) {
+				const sourceToken = getTreeShakingGraphToken(source);
+				const importerToken = getTreeShakingGraphToken(importer);
+				const token = sourceToken || importerToken;
+				if (!token) return;
+				const cleanSource = normalizePathForImport(stripTreeShakingGraphQuery(source));
+				const cleanImporter = importer ? normalizePathForImport(stripTreeShakingGraphQuery(importer)) : void 0;
+				if (!sourceToken && importerToken) {
+					const nestedSharedKey = findSharedKeyForSource(cleanSource, shared);
+					if (nestedSharedKey && getPackageName(nestedSharedKey) !== getPackageName(importerToken)) return this.resolve(cleanSource, cleanImporter, {
+						...resolveOptions,
+						skipSelf: true
+					});
+				}
+				const projectResolvedSource = sourceToken ? tryResolveFromProjectRoot(cleanSource) || cleanSource : cleanSource;
+				const resolved = await this.resolve(projectResolvedSource, cleanImporter, {
+					...resolveOptions,
+					custom: {
+						...resolveOptions.custom,
+						__mfTreeShakingGraph: true
+					},
+					skipSelf: true
+				});
+				if (!resolved || resolved.external) return resolved;
+				if (resolved.id.startsWith("\0")) return resolved;
+				return {
+					...resolved,
+					id: addTreeShakingGraphQuery(normalizePathForImport(resolved.id), token)
+				};
 			}
 		},
 		{
 			name: "proxyPreBuildShared:resolve-shared-loadShare",
 			enforce: "pre",
-			async resolveId(source, importer) {
+			async resolveId(source, importer, resolveOptions) {
+				if (resolveOptions.custom?.__mfTreeShakingGraph) return;
 				function shouldSkipTaggedImporterProxy(sharedKey, tag) {
 					if (!importer?.includes(tag)) return false;
 					const taggedModule = VirtualModule.findModule(tag, importer);
@@ -4977,50 +6891,6 @@ function collectFromRegex(code, isRemoteImport) {
 	}
 	return result.length > 0 ? result : void 0;
 }
-function createCodePositionMap(code) {
-	const positions = Array(code.length).fill(true);
-	function mask(start, end) {
-		for (let i = start; i < end; i++) positions[i] = false;
-	}
-	for (let i = 0; i < code.length;) {
-		const char = code[i];
-		const next = code[i + 1];
-		if (char === "/" && next === "/") {
-			const start = i;
-			i += 2;
-			while (i < code.length && code[i] !== "\n" && code[i] !== "\r") i++;
-			mask(start, i);
-			continue;
-		}
-		if (char === "/" && next === "*") {
-			const start = i;
-			i += 2;
-			while (i < code.length && !(code[i] === "*" && code[i + 1] === "/")) i++;
-			i = Math.min(code.length, i + 2);
-			mask(start, i);
-			continue;
-		}
-		if (char === "\"" || char === "'" || char === "`") {
-			const quote = char;
-			const start = i++;
-			while (i < code.length) {
-				if (code[i] === "\\") {
-					i += 2;
-					continue;
-				}
-				if (code[i] === quote) {
-					i++;
-					break;
-				}
-				i++;
-			}
-			mask(start, i);
-			continue;
-		}
-		i++;
-	}
-	return positions;
-}
 function pluginRemoteNamedExports(options) {
 	const remoteNames = Object.keys(options.remotes);
 	const isNodeModulesId = (id) => id.includes("/node_modules/") || id.includes("\\node_modules\\");
@@ -5637,15 +7507,12 @@ function appendResolveAlias(config, alias) {
 		replacement
 	})), alias];
 }
-function hasImportFalseShared(options) {
-	return Object.values(options.shared ?? {}).some((share) => share?.shareConfig?.import === false);
-}
 function getRuntimeHelpersImplementation(runtimeImplementation) {
 	const indexEntryMatch = runtimeImplementation.match(/^(.*[\\/])index(\.[cm]?js)$/);
-	if (indexEntryMatch) return `${indexEntryMatch[1]}helpers${indexEntryMatch[2]}`;
+	if (indexEntryMatch) return normalizePathForImport(`${indexEntryMatch[1]}helpers${indexEntryMatch[2]}`);
 	const extension = path$1.extname(runtimeImplementation);
-	if (extension) return path$1.join(path$1.dirname(runtimeImplementation), `helpers${extension}`);
-	if (path$1.isAbsolute(runtimeImplementation) || runtimeImplementation.startsWith(".")) return path$1.join(runtimeImplementation, "helpers");
+	if (extension) return normalizePathForImport(path$1.join(path$1.dirname(runtimeImplementation), `helpers${extension}`));
+	if (path$1.isAbsolute(runtimeImplementation) || runtimeImplementation.startsWith(".")) return normalizePathForImport(path$1.join(runtimeImplementation, "helpers"));
 	return `${runtimeImplementation.replace(/\/$/, "")}/helpers`;
 }
 const UNSAFE_JS_SOURCE_CHAR_MAP = {
@@ -5828,7 +7695,7 @@ export default __mfShared.default ?? __mfShared;`
 						const optimizeDeps = config.optimizeDeps ??= {};
 						optimizeDeps.include ??= [];
 						optimizeDeps.exclude ??= [];
-						const shouldBypassOptimizeDep = isLitShare(key) || key === "react" && shareItem.shareConfig?.singleton === true;
+						const shouldBypassOptimizeDep = isLitShare(key);
 						if (optimizeDeps.include.includes(key)) optimizeDeps.exclude = optimizeDeps.exclude.filter((dep) => dep !== key);
 						else if (shouldBypassOptimizeDep) optimizeDeps.exclude.push(key);
 						else optimizeDeps.include.push(key);
@@ -5883,13 +7750,14 @@ export default __mfShared.default ?? __mfShared;`
 const SSR_ONLY_PLUGINS = new Set(["@module-federation/vite/ssrEntryLoader"]);
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-Bo95ELmX.js").then((n) => n.n).then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-CGDIZCsD.js").then((n) => n.n).then(({ default: pluginDts }) => pluginDts(options))];
 }
 function federation(mfUserOptions) {
 	if (isTestEnv()) return [];
 	const options = normalizeModuleFederationOptions(mfUserOptions);
 	const isVinext = hasPackageDependency("vinext");
 	const { name, shared, filename, hostInitInjectLocation } = options;
+	const hasTreeShakingShared = Object.values(shared).some((share) => !!share.shareConfig.treeShaking);
 	if (!name) throw createModuleFederationError("name is required");
 	const remoteEntryId = getRemoteEntryId(options);
 	const virtualExposesId = getVirtualExposesId(options);
@@ -5995,11 +7863,11 @@ function federation(mfUserOptions) {
 		pluginProxyRemotes_default(options),
 		pluginRemoteNamedExports(options),
 		...pluginModuleParseEnd_default((id) => {
-			return id.includes(getHostAutoInitImportId()) || id.includes(remoteEntryId) || id.includes(virtualExposesId) || id.includes(getLocalSharedImportMapPath()) || id.includes("__loadShare__") || id.includes("__prebuild__");
+			return id.includes(getHostAutoInitImportId()) || id.includes(remoteEntryId) || id.includes(virtualExposesId) || id.includes(getLocalSharedImportMapPath()) || id.includes("__loadShare__") || id.includes("__prebuild__") || id.includes("__treeShakingProvider__") || id.includes("__mf_tree_shaking_graph__");
 		}, {
 			moduleParseTimeout: options.moduleParseTimeout,
 			moduleParseIdleTimeout: options.moduleParseIdleTimeout,
-			virtualExposesId
+			exposedModuleImports: Object.values(options.exposes).map((expose) => expose.import)
 		}),
 		...proxySharedModule({ shared }),
 		{
@@ -6021,7 +7889,8 @@ function federation(mfUserOptions) {
 							if (context.hostType === "js" && (hostFile === options.filename || hostFile.includes("hostInit") || hostFile.includes("virtualExposes") || hostFile.includes("localSharedImportMap"))) return [];
 							const hasFederationHtmlDeps = context.hostType === "html" && resolvedDeps.some((dep) => isFederationHtmlPreloadDependency(dep));
 							const hasFederationJsDeps = context.hostType === "js" && resolvedDeps.some((dep) => isFederationHtmlPreloadDependency(dep));
-							return hasFederationHtmlDeps || hasFederationJsDeps ? resolvedDeps.filter((dep) => !isFederationHtmlPreloadDependency(dep, true)) : resolvedDeps;
+							const treeShakingFallbackDeps = hasTreeShakingShared ? (dep) => dep.includes("__prebuild__") : () => false;
+							return hasFederationHtmlDeps || hasFederationJsDeps ? resolvedDeps.filter((dep) => !isFederationHtmlPreloadDependency(dep, true) && !treeShakingFallbackDeps(dep)) : resolvedDeps.filter((dep) => !treeShakingFallbackDeps(dep));
 						}
 					};
 				}
@@ -6195,8 +8064,8 @@ function federation(mfUserOptions) {
 			config(config, { command: _command }) {
 				const isRolldown = getIsRolldown(this);
 				isSsrBuild = _command === "build" && config.build?.ssr === true;
-				const needsSharedProviderSelectionHelper = hasImportFalseShared(options);
-				if (needsSharedProviderSelectionHelper) appendResolveAlias(config, {
+				const needsRuntimeHelpers = Object.keys(options.shared ?? {}).length > 0;
+				if (needsRuntimeHelpers) appendResolveAlias(config, {
 					find: /^@module-federation\/runtime\/helpers$/,
 					replacement: getRuntimeHelpersImplementation(options.implementation)
 				});
@@ -6210,7 +8079,7 @@ function federation(mfUserOptions) {
 				config.optimizeDeps ||= {};
 				config.optimizeDeps.include ||= [];
 				config.optimizeDeps.include.push("@module-federation/runtime");
-				if (needsSharedProviderSelectionHelper) config.optimizeDeps.include.push("@module-federation/runtime/helpers");
+				if (needsRuntimeHelpers) config.optimizeDeps.include.push("@module-federation/runtime/helpers");
 				options.runtimePlugins.forEach((p) => {
 					const pluginPath = typeof p === "string" ? p : p[0];
 					if (SSR_ONLY_PLUGINS.has(pluginPath)) return;