@module-federation/vite 1.16.16 → 1.17.0

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-BcvLBYP3.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,257 @@ ${exportStatement}
 `);
 }
 //#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,
@@ -1173,7 +1435,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 +1547,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",
@@ -1343,16 +1699,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,12 +1765,15 @@ 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, 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 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) {
@@ -1415,24 +1785,25 @@ function generateEagerWorkspaceSingletonExports(namedExports, importSource, cach
     const __mf_default = exportModule.default ?? exportModule;${namedExportAssignments}
     export { __mf_default as default };${namedExportLine}`;
 }
-function generateLazyWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor) {
+function generateLazyWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor, 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);
+      __mfApplyLazyShareExports(exportModule);`;
 	return `${declarations}
     const __mfApplyLazyShareExports = (mod) => {
       ${assignments}
     };
-    let exportModule = __mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor});
+    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;
@@ -1459,16 +1830,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 +1851,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 +1874,14 @@ 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 treeShakingConsumer = command === "build" && shareItem.shareConfig.treeShaking ? getNormalizeModuleFederationOptions().name : void 0;
 	if (shareItem.shareConfig.import === false) {
 		const namedExports = getPackageNamedExports(pkg);
 		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);
+			exportLine = generateDeferredHostProvidedExports([], pkg, cacheDescriptor, treeShakingConsumer);
 		}
 		loadShareCacheMap[pkg].writeSync(`
     ${getRuntimeInitPromiseBootstrapCode()}
@@ -1529,13 +1904,17 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
 	const isConsumedByPeerSingleton = isSharedSingletonConsumedByPeer(pkg);
 	const usesEntryInjectedRemoteFallback = command !== "build" && !isWorkspaceSingleton && isRemoteOnlyContainer() && shareItem.shareConfig.singleton === true && getNormalizeModuleFederationOptions().hostInitInjectLocation === "entry" && isConsumedByPeerSingleton;
 	const usesEagerWorkspaceFallback = isWorkspaceSingleton && isConsumedByPeerSingleton;
+	const usesDeferredTreeShakingFallback = Boolean(treeShakingConsumer);
 	const namedExports = getSharedNamedExports(pkg, shareItem);
 	let exportLine;
 	let initBlock = "";
-	if (usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback) exportLine = generateEagerWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor);
+	if (usesDeferredTreeShakingFallback) {
+		importLine = `${getRuntimeInitPromiseBootstrapCode()}\n    ${importLine}`;
+		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, treeShakingConsumer);
+	} else if (usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback) exportLine = generateEagerWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, treeShakingConsumer);
 	else if (usesDeferredSingletonFallback) {
 		importLine = `${getRuntimeInitPromiseBootstrapCode()}\n    ${importLine}`;
-		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor);
+		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, treeShakingConsumer);
 	} 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(", ")} };`;
@@ -1556,9 +1935,9 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
       __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule);`;
 	}
-	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 || isWorkspacePackage && command !== "build" ? "" : `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(skipServePrebuildWarmup ? devImportSource : sharedImportSource)};`;
+	const devDynamicImportLine = isWorkspacePackage ? "" : usesDeferredSingletonFallback || usesDeferredTreeShakingFallback ? "" : command !== "build" && !skipServePrebuildWarmup ? `;() => import(${escapeGeneratedStringLiteral(devImportSource)}).catch(() => {});` : "";
+	const moduleBody = usesDeferredSingletonFallback || usesDeferredTreeShakingFallback ? `
     ${prebuildImportLine}
     ${devDynamicImportLine}
     ${importLine}
@@ -1571,7 +1950,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 +1997,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,12 +2021,19 @@ function generateLocalSharedImportMap() {
       ${getOrderedUsedShares().map((key) => {
 		const shareItem = getNormalizeShareItem(key);
 		if (!shareItem) return null;
+		const treeShakingUsage = getTreeShakingExportUsage(key, shareItem, shareItem.name);
+		const treeShakingProviderExports = treeShakingUsage?.kind === "exports" ? treeShakingUsage.usedExports : [];
+		const treeShakingUsedExports = options.injectTreeShakingUsedExports === false ? shareItem.shareConfig.treeShaking?.usedExports || [] : treeShakingProviderExports;
+		const disableRuntimeInference = shareItem.shareConfig.treeShaking?.mode === "runtime-infer" && options.injectTreeShakingUsedExports === false;
+		const treeShakingProviderImportId = !disableRuntimeInference && hasTreeShakingSharedProvider(key, shareItem) ? getTreeShakingSharedProviderImportId(key) : void 0;
+		const treeShakingStatus = treeShakingUsage?.kind === "full" || disableRuntimeInference || shareItem.shareConfig.treeShaking?.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)},
             async get () {
               if (${shareItem.shareConfig.import === false}) {
@@ -1665,8 +2058,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," : ""}
-            }
+            },
+            ${shareItem.shareConfig.treeShaking ? `treeShaking: {
+              mode: ${JSON.stringify(shareItem.shareConfig.treeShaking.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 +2081,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)},
@@ -1838,7 +2244,11 @@ function generateRuntimeSharedCacheSeedCode() {
     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) {
+      if (
+        share.shareConfig?.import === false ||
+        Boolean(share.treeShaking) ||
+        __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined
+      ) {
         continue;
       }
       const singletonCacheDescriptor = __mfGetSharedCacheDescriptor(pkg, true, share.version, share.scope);
@@ -1889,8 +2299,176 @@ function getRemoteEntryId(options) {
 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 "";
+	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.
+    for (const [pkg, share] of Object.entries(usedShared)) {
+      const treeShaking = share.treeShaking;
+      if (!treeShaking) continue;
+      try {
+        const factory = await initRes.loadShare(pkg, {
+          customShareInfo: {
+            shareConfig: share.shareConfig,
+            treeShaking: {
+              mode: treeShaking.mode,
+              status: treeShaking.status,
+              usedExports: treeShaking.usedExports,
+            },
+          },
+        });
+        if (factory === false) continue;
+        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 hasPartialProvider =
+          Array.isArray(treeShaking.providedExports) &&
+          treeShaking.providedExports.length > 0 &&
+          ((treeShaking.mode === "runtime-infer" && treeShaking.status !== 0) ||
+            treeShaking.status === 2);
+        if (hasPartialProvider) {
+          __mfWriteTreeShakingSharedCache(
+            __mfModuleCache.share,
+            cacheDescriptor,
+            treeShaking.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 originalResolver = args.resolver;
+      args.resolver = () => {
+        const resolved = originalResolver();
+        if (!resolved?.useTreesShaking) return resolved;
+
+        const consumerTreeShaking = args.shareInfo?.treeShaking;
+        if (consumerTreeShaking?.mode !== "runtime-infer") return resolved;
+        const requiredExports = consumerTreeShaking.usedExports;
+        if (!Array.isArray(requiredExports)) 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 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}`,
@@ -1912,8 +2490,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 +2520,16 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       }
     }
   }
+  ${generateTreeShakingSnapshotPluginCode(hasTreeShakingShared)}
   ${needsSharedProviderSelectionHelper ? sharedProviderSelectionHelperCode : ""}
 
   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() {
@@ -2021,7 +2602,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       name: mfName,
       remotes: ${options.shareStrategy === "loaded-first" ? "[]" : "usedRemotes"},
       shared: usedShared,
-      plugins: [...__browserPlugins, ...__ssrPlugins],
+      plugins: [${hasTreeShakingShared ? "__mfTreeShakingSnapshotPlugin()," : ""} ...__browserPlugins, ...__ssrPlugins],
       ${options.shareStrategy ? `shareStrategy: '${options.shareStrategy}'` : ""}
     });
     // handling circular init calls
@@ -2042,9 +2623,13 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
     } catch (e) {
       console.error('[Module Federation]', e)
     }
+    ${generateTreeShakingSharedResolutionCode(hasTreeShakingShared)}
     for (const [pkg, share] of Object.entries(usedShared)) {
       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) continue;
       ${normalizeRuntimeShareCode}
       const versions = shared?.[pkg];
       const provider = __mfSelectSharedProvider(versions, pkg, share, '${options.shareStrategy}');
@@ -2096,6 +2681,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;
@@ -2158,9 +2747,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 +2904,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 +2981,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 +3183,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 +3220,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 +3972,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 +4064,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 +4121,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 +4480,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 +4550,8 @@ const Manifest = () => {
 								type: "app",
 								buildInfo: {
 									buildVersion: getBuildVersion(),
-									buildName: name
+									buildName: name,
+									...getTreeShakingBuildInfo(mfOptions)
 								},
 								remoteEntry: {
 									name: devRemoteEntryFile,
@@ -3997,6 +4606,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 +4627,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 +4671,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 +4741,8 @@ const Manifest = () => {
 				type: "app",
 				buildInfo: {
 					buildVersion: getBuildVersion(),
-					buildName: name
+					buildName: name,
+					...getTreeShakingBuildInfo(options)
 				},
 				remoteEntry,
 				ssrRemoteEntry,
@@ -4152,32 +4787,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 +4835,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 +4861,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 +4883,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 +4913,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 +4954,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 +4996,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 +5012,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 +5102,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 +5147,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 +5160,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 +5320,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 +5365,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 +5386,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 +5412,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);
@@ -5642,10 +6429,10 @@ function hasImportFalseShared(options) {
 }
 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 +6615,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 +6670,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-BcvLBYP3.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 +6783,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 +6809,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 +6984,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 = hasImportFalseShared(options) || Object.values(options.shared ?? {}).some((share) => !!share?.shareConfig.treeShaking);
+				if (needsRuntimeHelpers) appendResolveAlias(config, {
 					find: /^@module-federation\/runtime\/helpers$/,
 					replacement: getRuntimeHelpersImplementation(options.implementation)
 				});
@@ -6210,7 +6999,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;