@module-federation/vite 1.17.0 → 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-BcvLBYP3.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";
@@ -939,6 +939,145 @@ ${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
@@ -1241,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();
@@ -1332,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();
@@ -1359,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);
 }
@@ -1689,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    ");
@@ -1768,35 +2121,41 @@ function materializeCachedLoadShareModule(options) {
 function getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer) {
 	return treeShakingConsumer ? `__mfReadTreeShakingSharedSelection(__mfModuleCache.share, ${cacheDescriptor}, ${JSON.stringify(treeShakingConsumer)})` : `__mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor})`;
 }
-function generateEagerWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor, treeShakingConsumer) {
+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 = ${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, treeShakingConsumer) {
+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);
-      __mfApplyLazyShareExports(exportModule);`;
+      __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
 	return `${declarations}
     const __mfApplyLazyShareExports = (mod) => {
       ${assignments}
     };
+    __mfSubscribeSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfApplyLazyShareExports);
     let exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
     if (exportModule === undefined) {
       if (import.meta.env.SSR) {
@@ -1810,8 +2169,7 @@ function generateLazyWorkspaceSingletonExports(namedExports, importSource, cache
           }
           return import(${escapeGeneratedStringLiteral(importSource)}).then((mod) => {
             exportModule = __mfNormalizeShareModule(mod);
-            __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule);
-            __mfApplyLazyShareExports(exportModule);
+            __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});
           });
         }));
       }
@@ -1874,13 +2232,15 @@ 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, 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.`);
+			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(`
@@ -1895,26 +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 usesDeferredTreeShakingFallback = Boolean(treeShakingConsumer);
-	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 (usesDeferredTreeShakingFallback) {
 		importLine = `${getRuntimeInitPromiseBootstrapCode()}\n    ${importLine}`;
-		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, treeShakingConsumer);
-	} else if (usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback) exportLine = generateEagerWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, treeShakingConsumer);
+		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, treeShakingConsumer);
+		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(", ")} };`;
@@ -1929,13 +2322,24 @@ 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 || usesDeferredTreeShakingFallback || isWorkspacePackage && command !== "build" ? "" : `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(skipServePrebuildWarmup ? devImportSource : sharedImportSource)};`;
+	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}
@@ -2021,12 +2425,15 @@ function generateLocalSharedImportMap() {
       ${getOrderedUsedShares().map((key) => {
 		const shareItem = getNormalizeShareItem(key);
 		if (!shareItem) return null;
-		const treeShakingUsage = getTreeShakingExportUsage(key, shareItem, shareItem.name);
+		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 ? 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;
+		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)},
@@ -2035,6 +2442,7 @@ function generateLocalSharedImportMap() {
             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\`);
@@ -2061,8 +2469,8 @@ function generateLocalSharedImportMap() {
               eager: ${Boolean(shareItem.shareConfig.eager)},
               ${shareItem.shareConfig.import === false ? "import: false," : ""}
             },
-            ${shareItem.shareConfig.treeShaking ? `treeShaking: {
-              mode: ${JSON.stringify(shareItem.shareConfig.treeShaking.mode)},
+            ${treeShakingConfig ? `treeShaking: {
+              mode: ${JSON.stringify(treeShakingConfig.mode)},
               usedExports: ${JSON.stringify(treeShakingUsedExports)},
               providedExports: ${JSON.stringify(treeShakingProviderExports)},
               status: ${treeShakingStatus},
@@ -2158,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}
@@ -2167,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) => {
@@ -2188,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);
@@ -2212,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)};
@@ -2241,34 +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 ||
-        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);
-        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}`;
@@ -2300,15 +2885,15 @@ const SSR_ONLY_PLUGIN_SPECIFIERS = new Set(["@module-federation/vite/ssrEntryLoa
 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 "";
+	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.
-    for (const [pkg, share] of Object.entries(usedShared)) {
+    const __mfResolveTreeShakingShared = async (pkg, share) => {
       const treeShaking = share.treeShaking;
-      if (!treeShaking) continue;
+      if (!treeShaking) return;
       try {
         const factory = await initRes.loadShare(pkg, {
           customShareInfo: {
@@ -2320,22 +2905,21 @@ function generateTreeShakingSharedResolutionCode(enabled) {
             },
           },
         });
-        if (factory === false) continue;
+        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 =
-          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,
+            providedExports,
             normalizedShared
           );
           __mfWriteTreeShakingSharedSelection(
@@ -2350,18 +2934,18 @@ function generateTreeShakingSharedResolutionCode(enabled) {
       } catch (e) {
         console.warn('[Module Federation] Failed to load tree-shaken shared module', pkg, e);
       }
-    }`;
+    };`;
 }
-const treeShakingResolveShareBodyCode = `const originalResolver = args.resolver;
+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 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));
@@ -2460,7 +3044,7 @@ function generateTreeShakingSnapshotPluginCode(enabled) {
   });`;
 }
 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 = [
@@ -2481,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
@@ -2522,6 +3117,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   }
   ${generateTreeShakingSnapshotPluginCode(hasTreeShakingShared)}
   ${needsSharedProviderSelectionHelper ? sharedProviderSelectionHelperCode : ""}
+  ${needsSharedProviderSelectionHelper ? externalSharedProviderSelectionHelperCode : ""}
 
   async function getLocalSharedImportMap() {
     ${hasEagerShared ? "return __mfLocalSharedImportMap;" : ""}
@@ -2543,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) => {
@@ -2598,46 +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: [${hasTreeShakingShared ? "__mfTreeShakingSnapshotPlugin()," : ""} ...__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'
       });
+      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]', e)
+      console.error('[Module Federation] Failed to bridge external shared modules', e)
     }
     ${generateTreeShakingSharedResolutionCode(hasTreeShakingShared)}
-    for (const [pkg, share] of Object.entries(usedShared)) {
+    const __mfResolveImportFalseShared = async (pkg, share) => {
       const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
       const cachedShare = share.treeShaking
         ? __mfReadTreeShakingSharedSelection(__mfModuleCache.share, cacheDescriptor, mfName)
         : __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor);
-      if (share.shareConfig?.import !== false || cachedShare !== undefined) continue;
+      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
@@ -2663,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;
@@ -2694,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}
+                );
               });
             });
           }
@@ -5764,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\\");
@@ -6424,9 +7507,6 @@ 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 normalizePathForImport(`${indexEntryMatch[1]}helpers${indexEntryMatch[2]}`);
@@ -6670,7 +7750,7 @@ 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-BcvLBYP3.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 [];
@@ -6984,7 +8064,7 @@ function federation(mfUserOptions) {
 			config(config, { command: _command }) {
 				const isRolldown = getIsRolldown(this);
 				isSsrBuild = _command === "build" && config.build?.ssr === true;
-				const needsRuntimeHelpers = hasImportFalseShared(options) || Object.values(options.shared ?? {}).some((share) => !!share?.shareConfig.treeShaking);
+				const needsRuntimeHelpers = Object.keys(options.shared ?? {}).length > 0;
 				if (needsRuntimeHelpers) appendResolveAlias(config, {
 					find: /^@module-federation\/runtime\/helpers$/,
 					replacement: getRuntimeHelpersImplementation(options.implementation)