@module-federation/vite 1.22.0 → 1.22.1

package/lib/index.js

@@ -1,6 +1,6 @@
+import { _ as stripViteFsPrefix, a as ensureTrailingSlash, c as getCommonSharedSubpaths, d as isNodeModulePath, f as isNuxtClientBase, g as stripQueryAndHash, h as resolvePublicPath, l as getNodeModulesSuffix, m as normalizeNodeModulePath, n as invalidateSharedKeyMatcher, o as filterId, p as isViteOptimizableEntry, r as matchesSharedSource, s as getBasePath$1, t as findSharedKey, u as isAssetLikeImport } from "./sharedKeyMatcher-BRzBCbuR.js";
 import { i as resolveHashPlaceholderFileName, n as normalizePathForImport, r as rebaseImport } from "./buildPaths-BoaQTkxt.js";
-import { a as getPackageDetectionCwd, c as getSharedCacheDescriptor, d as packageNameDecode, f as packageNameEncode, g as createModuleFederationError, h as sharedCacheHelperCode, i as getIsRolldown, l as hasPackageDependency, m as setPackageDetectionCwd, n as getInstalledPackageEntry, o as getPackageName, p as resolveImportPath, r as getInstalledPackageJson, s as getPackageNameFromNodeModulePath, u as isNuxtProjectRoot, v as mfWarn } from "./dtsConstants-BEGrtvcw.js";
-import { a as filterId, c as getCommonSharedSubpaths, d as isNodeModulePath, f as isNuxtClientBase, h as resolvePublicPath, i as ensureTrailingSlash, l as getMatchingNodeModuleSubpath, m as normalizeNodeModulePath, n as invalidateSharedKeyMatcher, o as getBasePath$1, p as isViteOptimizableEntry, r as matchesSharedSource, s as getCommonSharedSubpathFromNodeModulePath, t as findSharedKey, u as isAssetLikeImport } from "./sharedKeyMatcher-DiUzRVH1.js";
+import { _ as sharedCacheHelperCode, a as getPackageDetectionCwd, b as mfWarn, c as getSharedCacheDescriptor, d as isPackageExportAvailable, f as isPackageInstalled, g as setPackageDetectionCwd, h as resolveImportPath, i as getIsRolldown, l as hasPackageDependency, m as packageNameEncode, n as getInstalledPackageEntry, o as getPackageName, p as packageNameDecode, r as getInstalledPackageJson, s as getPackageNameFromNodeModulePath, u as isNuxtProjectRoot, v as createModuleFederationError } from "./dtsConstants-dDsHZFC1.js";
 import { createRequire } from "node:module";
 import * as fs$2 from "fs";
 import { existsSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "fs";
@@ -431,7 +431,7 @@ function isJsxClosingTagSlash(code, slashIndex) {
 	return code[cursor] === ">";
 }
 /** Mark comments, string/template literals, and regular expressions as non-code. */
-function createCodePositionMap(code) {
+function createCodePositionMap(code, onComment) {
 	const positions = Array(code.length).fill(true);
 	const mask = (start, end) => {
 		for (let index = start; index < end; index++) positions[index] = false;
@@ -449,6 +449,7 @@ function createCodePositionMap(code) {
 			index += 2;
 			while (index < code.length && code[index] !== "\n" && code[index] !== "\r") index++;
 			mask(start, index);
+			onComment?.(start, index);
 			continue;
 		}
 		if (char === "/" && next === "*") {
@@ -457,6 +458,7 @@ function createCodePositionMap(code) {
 			while (index < code.length && !(code[index] === "*" && code[index + 1] === "/")) index++;
 			index = Math.min(code.length, index + 2);
 			mask(start, index);
+			onComment?.(start, index);
 			continue;
 		}
 		if (char === "\"" || char === "'" || char === "`") {
@@ -762,8 +764,8 @@ function normalizeRemoteItem(key, remote) {
 * @param {string} sharedName
 * @returns {string | undefined}
 */
-function searchPackageVersion(sharedName) {
-	const version = getInstalledPackageJson(sharedName)?.packageJson.version;
+function searchPackageVersion(sharedName, cwd) {
+	const version = getInstalledPackageJson(sharedName, { cwd })?.packageJson.version;
 	return typeof version === "string" ? version : void 0;
 }
 function inferVersionFromRequiredVersion(requiredVersion) {
@@ -798,36 +800,88 @@ const PACKAGE_SPECIFIER_PROTOCOL_RE = /^[a-z][a-z\d+.-]*:/i;
 function isProtocolRequiredVersion(requiredVersion) {
 	return PACKAGE_SPECIFIER_PROTOCOL_RE.test(requiredVersion.trim());
 }
+const SEMVER_COMPARATOR_RE = /^(?:[<>=~^]*v?(?:\d+|[xX*])(?:\.(?:\d+|[xX*]))*(?:[-+][\w.-]+)?|[<>=~^]+|[xX*]|-)$/;
+function isSemverRange(range) {
+	return range.split("||").every((alternative) => {
+		const comparators = alternative.trim().split(/\s+/).filter(Boolean);
+		return comparators.length > 0 && comparators.every((c) => SEMVER_COMPARATOR_RE.test(c));
+	});
+}
+function isUsableRequiredVersion(requiredVersion) {
+	return requiredVersion.trim() !== "" && !isProtocolRequiredVersion(requiredVersion) && isSemverRange(requiredVersion);
+}
+/** Bare specifiers name an installed package; relative/absolute paths do not. */
+function isBareSpecifier(specifier) {
+	return !specifier.startsWith(".") && !specifier.startsWith("\0") && !path$1.isAbsolute(specifier) && !PACKAGE_SPECIFIER_PROTOCOL_RE.test(specifier);
+}
+function readProjectPackageJson(cwd, cache) {
+	if (cache.has(cwd)) return cache.get(cwd);
+	let packageJson;
+	try {
+		packageJson = JSON.parse(fs$2.readFileSync(path$1.join(cwd, "package.json"), "utf8"));
+	} catch {}
+	cache.set(cwd, packageJson);
+	return packageJson;
+}
 function getLitExportSubpathShares(sharedName) {
 	if (sharedName !== "lit") return [];
 	const exportsField = getInstalledPackageJson(sharedName, { packageName: sharedName })?.packageJson.exports;
 	if (!exportsField || typeof exportsField === "string") return [];
 	return Object.keys(exportsField).filter((key) => key.startsWith("./") && key !== "." && !key.includes("*")).map((key) => `${sharedName}/${key.slice(2)}`);
 }
+const sharedVersionConfigs = /* @__PURE__ */ new WeakMap();
+function resolveSharedVersion(key, config, cwd, packageJsonCache = /* @__PURE__ */ new Map(), fallbackVersion) {
+	const source = typeof config.import === "string" && isBareSpecifier(config.import) ? config.import : key;
+	const version = config.version || searchPackageVersion(source, cwd) || inferVersionFromRequiredVersion(config.requiredVersion) || fallbackVersion;
+	let requiredVersion = config.requiredVersion;
+	if (requiredVersion === void 0 && !config.version) {
+		const packageJson = readProjectPackageJson(cwd, packageJsonCache);
+		const packageName = getPackageName(source);
+		requiredVersion = packageJson?.dependencies?.[packageName] ?? packageJson?.devDependencies?.[packageName] ?? packageJson?.peerDependencies?.[packageName] ?? packageJson?.optionalDependencies?.[packageName];
+	}
+	if (requiredVersion === false || typeof requiredVersion === "string" && isUsableRequiredVersion(requiredVersion)) return {
+		version,
+		requiredVersion
+	};
+	return {
+		version,
+		requiredVersion: config.import === false || config.version ? "*" : version ? `^${version}` : "*"
+	};
+}
+function resolveSharedVersions(shared, root) {
+	const packageJsonCache = /* @__PURE__ */ new Map();
+	for (const [key, item] of Object.entries(shared)) {
+		const config = sharedVersionConfigs.get(item);
+		if (!config) continue;
+		const { version, requiredVersion } = resolveSharedVersion(key, config, root, packageJsonCache, item.version);
+		item.version = version;
+		item.shareConfig.requiredVersion = requiredVersion;
+	}
+}
 function normalizeShareItem(key, shareItem) {
-	const isImportFalse = typeof shareItem === "object" && shareItem.import === false;
-	const explicitVersion = typeof shareItem === "object" ? shareItem.version : void 0;
-	const inferredVersion = typeof shareItem === "object" ? inferVersionFromRequiredVersion(shareItem.requiredVersion) : void 0;
 	const treeShaking = typeof shareItem === "object" ? shareItem.treeShaking : void 0;
 	if (treeShaking && treeShaking.mode !== "server-calc" && treeShaking.mode !== "runtime-infer") throw createModuleFederationError(`Invalid shared config for "${key}": treeShaking.mode must be either "server-calc" or "runtime-infer".`);
 	if (treeShaking && typeof shareItem === "object" && shareItem.eager) throw createModuleFederationError(`Invalid shared config for "${key}": cannot use both "eager: true" and "treeShaking.mode" simultaneously. Choose one strategy.`);
 	if (treeShaking?.mode === "runtime-infer" && typeof shareItem === "object" && shareItem.singleton) mfWarn(`Shared singleton "${key}" uses runtime-infer tree shaking, which may load both a tree-shaken bundle and a full bundle when consumers require different exports. Prefer server-calc for singleton dependencies. If runtime-infer is required, expand usedExports to reduce this risk.`);
-	const version = explicitVersion || searchPackageVersion(key) || inferredVersion;
-	if (typeof shareItem === "string") return {
-		name: shareItem,
-		version,
-		scope: "default",
-		from: "",
-		shareConfig: {
-			import: void 0,
-			singleton: false,
-			eager: false,
-			requiredVersion: version ? `^${version}` : "*"
-		}
-	};
-	const userRequiredVersion = shareItem.requiredVersion;
-	const keepUserRequiredVersion = userRequiredVersion === false || typeof userRequiredVersion === "string" && userRequiredVersion.trim() !== "" && !isProtocolRequiredVersion(userRequiredVersion);
-	return {
+	const config = typeof shareItem === "object" ? shareItem : {};
+	const { version, requiredVersion } = resolveSharedVersion(key, config, getPackageDetectionCwd());
+	if (typeof shareItem === "string") {
+		const result = {
+			name: shareItem,
+			version,
+			scope: "default",
+			from: "",
+			shareConfig: {
+				import: void 0,
+				singleton: false,
+				eager: false,
+				requiredVersion
+			}
+		};
+		sharedVersionConfigs.set(result, { ...config });
+		return result;
+	}
+	const result = {
 		name: key,
 		from: "",
 		version,
@@ -836,12 +890,14 @@ function normalizeShareItem(key, shareItem) {
 			import: shareItem.import,
 			singleton: shareItem.singleton || false,
 			eager: shareItem.eager || false,
-			requiredVersion: keepUserRequiredVersion ? userRequiredVersion : isImportFalse || shareItem.version ? "*" : version ? `^${version}` : "*",
+			requiredVersion,
 			strictVersion: !!shareItem.strictVersion,
 			...shareItem.suppressMissingImportWarning ? { suppressMissingImportWarning: true } : {},
 			...treeShaking ? { treeShaking: { ...treeShaking } } : {}
 		}
 	};
+	sharedVersionConfigs.set(result, { ...config });
+	return result;
 }
 /**
 * Trailing-slash keys are package namespace prefixes (`lodash/`, `@scope/ui/`).
@@ -945,6 +1001,9 @@ function getNormalizeModuleFederationOptions() {
 function hasRemotes(options = getNormalizeModuleFederationOptions()) {
 	return Object.keys(options.remotes || {}).length > 0;
 }
+function hasShared(options = getNormalizeModuleFederationOptions()) {
+	return Object.keys(options.shared || {}).length > 0;
+}
 function isRemoteContainer(options = getNormalizeModuleFederationOptions()) {
 	return Object.keys(options.exposes || {}).length > 0;
 }
@@ -958,7 +1017,8 @@ function isExplicitSharedKey(key, options) {
 	return (options ? explicitSharedKeysByOptions.get(options) : explicitSharedKeys)?.has(key) ?? false;
 }
 function getNormalizeShareItem(key, options = getNormalizeModuleFederationOptions()) {
-	return options.shared[key] || options.shared[getPackageName(key)] || options.shared[getPackageName(key) + "/"];
+	const matchedKey = findSharedKey(key, options.shared);
+	return options.shared[key] || (matchedKey ? options.shared[matchedKey] : void 0) || options.shared[getPackageName(key)] || options.shared[getPackageName(key) + "/"];
 }
 function normalizeModuleFederationOptions(options) {
 	warnOnReservedInternalNamePrefix(options.name, "containerName");
@@ -1216,6 +1276,279 @@ function isParsableExpression(source) {
 	}
 }
 //#endregion
+//#region src/utils/treeShaking.ts
+function shouldAnalyzeSharedExports(shareItem) {
+	return !!(shareItem && (shareItem.shareConfig.treeShaking || shareItem.shareConfig.import === false));
+}
+const legacyTreeShakingState = {
+	inferredUsage: /* @__PURE__ */ new Map(),
+	buildMode: false
+};
+const treeShakingStates = /* @__PURE__ */ new WeakMap();
+function getTreeShakingState(options) {
+	if (!options) return legacyTreeShakingState;
+	let state = treeShakingStates.get(options);
+	if (!state) {
+		state = {
+			inferredUsage: /* @__PURE__ */ new Map(),
+			buildMode: false
+		};
+		treeShakingStates.set(options, state);
+	}
+	return state;
+}
+function setTreeShakingBuildMode(enabled, options) {
+	getTreeShakingState(options).buildMode = enabled;
+}
+function resetTreeShakingExports(options) {
+	getTreeShakingState(options).inferredUsage.clear();
+}
+function getOrCreateExportRecord(sharedKey, request, options) {
+	const inferredUsage = getTreeShakingState(options).inferredUsage;
+	let byRequest = inferredUsage.get(sharedKey);
+	if (!byRequest) {
+		byRequest = /* @__PURE__ */ new Map();
+		inferredUsage.set(sharedKey, byRequest);
+	}
+	let record = byRequest.get(request);
+	if (!record) {
+		record = {
+			requiresFullBundle: false,
+			usedExports: /* @__PURE__ */ new Set()
+		};
+		byRequest.set(request, record);
+	}
+	return record;
+}
+function recordTreeShakingExports(sharedKey, exports, request = sharedKey, options) {
+	const record = getOrCreateExportRecord(sharedKey, request, options);
+	exports.forEach((name) => record.usedExports.add(name));
+}
+function markTreeShakingPackageUnsafe(sharedKey, request = sharedKey, options) {
+	getOrCreateExportRecord(sharedKey, request, options).requiresFullBundle = true;
+}
+function getExportRecords(sharedKey, request, options) {
+	const inferredUsage = getTreeShakingState(options).inferredUsage;
+	if (sharedKey) {
+		const records = inferredUsage.get(sharedKey);
+		const wildcard = records?.get("*");
+		const exact = records?.get(request);
+		return [wildcard, exact === wildcard ? void 0 : exact].filter((record) => !!record);
+	}
+	const records = [];
+	inferredUsage.forEach((byRequest, configuredKey) => {
+		const wildcard = byRequest.get("*");
+		const exact = byRequest.get(request);
+		const keyBase = configuredKey.endsWith("/") ? configuredKey.slice(0, -1) : configuredKey;
+		const requestMatchesConfiguredKey = request === keyBase || request.startsWith(`${keyBase}/`);
+		if (wildcard && requestMatchesConfiguredKey) records.push(wildcard);
+		if (exact && exact !== wildcard) records.push(exact);
+	});
+	return records;
+}
+/**
+* Return the analyzed requirement for one concrete shared request.
+*
+* Callers that know the configured share key should pass it explicitly. The
+* fallback lookup across keys keeps aliases/backwards-compatible callers
+* working, while still keeping each concrete request's exports isolated.
+*/
+function getSharedExportUsage(request, shareItem, sharedKey, options) {
+	const treeShaking = shareItem?.shareConfig.treeShaking;
+	if (!shouldAnalyzeSharedExports(shareItem) || !getTreeShakingState(options).buildMode) return;
+	const records = getExportRecords(sharedKey, request, options);
+	if (records.some((record) => record.requiresFullBundle)) return { kind: "full" };
+	const configured = treeShaking?.usedExports ?? [];
+	const result = new Set(configured);
+	records.forEach((record) => record.usedExports.forEach((name) => result.add(name)));
+	if (result.size > 0) return {
+		kind: "exports",
+		usedExports: [...result].sort()
+	};
+	return records.length > 0 ? {
+		kind: "exports",
+		usedExports: []
+	} : { kind: "unknown" };
+}
+function getTreeShakingExportUsage(request, shareItem, sharedKey, options) {
+	if (!shareItem?.shareConfig.treeShaking) return void 0;
+	return getSharedExportUsage(request, shareItem, sharedKey, options);
+}
+function getModuleSource(node) {
+	if (!node || typeof node !== "object") return void 0;
+	const source = node;
+	if (source.type === "Literal" && typeof source.value === "string") return source.value;
+	if (source.type === "StringLiteral" && typeof source.value === "string") return source.value;
+	if (source.type !== "TemplateLiteral") return void 0;
+	const expressions = Array.isArray(source.expressions) ? source.expressions : [];
+	const quasis = Array.isArray(source.quasis) ? source.quasis : [];
+	if (expressions.length > 0 || quasis.length !== 1) return void 0;
+	const value = quasis[0]?.value;
+	return typeof value?.cooked === "string" ? value.cooked : typeof value?.raw === "string" ? value.raw : void 0;
+}
+function getExportedName(node) {
+	if (!node || typeof node !== "object") return void 0;
+	const exported = node;
+	if (exported.type === "Identifier" && typeof exported.name === "string") return exported.name;
+	if ((exported.type === "Literal" || exported.type === "StringLiteral") && typeof exported.value === "string") return exported.value;
+}
+function isTypeOnly(node) {
+	return node.importKind === "type" || node.exportKind === "type";
+}
+function forEachAstNode(root, visit) {
+	const stack = [root];
+	const seen = /* @__PURE__ */ new Set();
+	while (stack.length > 0) {
+		const value = stack.pop();
+		if (!value || typeof value !== "object") continue;
+		if (seen.has(value)) continue;
+		seen.add(value);
+		if (Array.isArray(value)) {
+			for (let index = value.length - 1; index >= 0; index--) stack.push(value[index]);
+			continue;
+		}
+		const node = value;
+		if (typeof node.type === "string") visit(node);
+		Object.entries(node).forEach(([key, child]) => {
+			if (key !== "parent" && key !== "loc") stack.push(child);
+		});
+	}
+}
+function collectImportDeclaration(node, source, record, markUnsafe) {
+	if (isTypeOnly(node)) return;
+	const specifiers = Array.isArray(node.specifiers) ? node.specifiers : [];
+	if (specifiers.length === 0) {
+		markUnsafe(source);
+		return;
+	}
+	const names = [];
+	for (const specifier of specifiers) {
+		if (isTypeOnly(specifier)) continue;
+		if (specifier.type === "ImportNamespaceSpecifier") {
+			markUnsafe(source);
+			return;
+		}
+		if (specifier.type === "ImportDefaultSpecifier") {
+			names.push("default");
+			continue;
+		}
+		if (specifier.type === "ImportSpecifier") {
+			const imported = specifier.imported;
+			if (imported?.type === "Literal" || imported?.type === "StringLiteral") {
+				markUnsafe(source);
+				return;
+			}
+			const name = getExportedName(specifier.imported);
+			if (!name) {
+				markUnsafe(source);
+				return;
+			}
+			names.push(name);
+			continue;
+		}
+		markUnsafe(source);
+		return;
+	}
+	record(names, source);
+}
+function collectReExport(node, source, record, markUnsafe) {
+	if (isTypeOnly(node)) return;
+	if (node.type === "ExportAllDeclaration") {
+		markUnsafe(source);
+		return;
+	}
+	const specifiers = Array.isArray(node.specifiers) ? node.specifiers : [];
+	if (specifiers.length === 0) {
+		markUnsafe(source);
+		return;
+	}
+	const names = [];
+	for (const specifier of specifiers) {
+		if (isTypeOnly(specifier)) continue;
+		if (specifier.type !== "ExportSpecifier") {
+			markUnsafe(source);
+			return;
+		}
+		const local = specifier.local;
+		if (local?.type === "Literal" || local?.type === "StringLiteral") {
+			markUnsafe(source);
+			return;
+		}
+		const name = getExportedName(specifier.local);
+		if (!name) {
+			markUnsafe(source);
+			return;
+		}
+		names.push(name);
+	}
+	record(names, source);
+}
+/**
+* Collect the exports required by a consumer's ESM graph.
+*
+* Parsing the module avoids treating import-looking text in comments, strings,
+* templates, or regular expressions as real dependencies. If parsing fails,
+* every configured share whose exports are analyzed is conservatively marked
+* as requiring its full export surface instead of guessing from source text.
+*
+* Generated federation wrappers are excluded because their imports describe
+* the wrapper implementation, not the consumer's requirements.
+*/
+async function collectTreeShakingImports(code, id, shared, findSharedKey, record, markUnsafe) {
+	const normalizedId = normalizePathForImport(id);
+	if (normalizedId.includes("__prebuild__") || normalizedId.includes("__loadShare__") || normalizedId.includes("__mf_tree_shaking_graph__")) return;
+	let ast;
+	try {
+		ast = parseAst(code);
+	} catch {
+		Object.entries(shared).forEach(([sharedKey, shareItem]) => {
+			if (shouldAnalyzeSharedExports(shareItem)) markUnsafe(sharedKey, "*");
+		});
+		return;
+	}
+	const pending = [];
+	const withSharedSource = (source, use) => {
+		const apply = (key) => {
+			if (key && shouldAnalyzeSharedExports(shared[key])) use(key);
+		};
+		const key = findSharedKey(source, shared);
+		if (key instanceof Promise) pending.push(key.then(apply));
+		else apply(key);
+	};
+	const recordSource = (names, source) => {
+		withSharedSource(source, (key) => record(key, names, source));
+	};
+	const markSourceUnsafe = (source) => {
+		withSharedSource(source, (key) => markUnsafe(key, source));
+	};
+	forEachAstNode(ast, (node) => {
+		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);
+			}
+		}
+	});
+	await Promise.all(pending);
+}
+//#endregion
 //#region src/utils/reactIsland.ts
 const SOURCE_EXTENSIONS$1 = [
 	".tsx",
@@ -1227,11 +1560,8 @@ const SOURCE_EXTENSIONS$1 = [
 	".cts",
 	".cjs"
 ];
-function stripQueryAndHash$2(id) {
-	return id.split(/[?#]/, 1)[0];
-}
 function resolveSourceFile(importPath, root) {
-	const cleanImport = stripQueryAndHash$2(importPath);
+	const cleanImport = stripQueryAndHash(importPath);
 	if (!cleanImport.startsWith(".") && !path$1.isAbsolute(cleanImport)) return;
 	const candidate = path$1.isAbsolute(cleanImport) ? cleanImport : path$1.resolve(root, cleanImport);
 	return [
@@ -1252,7 +1582,7 @@ function localDefaultReexport(source) {
 }
 function isReactComponentSource(source, filePath = "component.tsx") {
 	if (!(/\bexport\s+default\b/.test(source) || /\bexport\s*{[^}]*\bdefault\b[^}]*}(?:\s*from\s*["'][^"']+["'])?/.test(source))) return false;
-	const extension = path$1.extname(stripQueryAndHash$2(filePath)).toLowerCase();
+	const extension = path$1.extname(stripQueryAndHash(filePath)).toLowerCase();
 	const canContainJsx = extension === ".tsx" || extension === ".jsx";
 	const hasJsx = /<>|<\s*[A-Za-z][\w.:-]*(?:\s[^<>]*?)?\s*\/?>/.test(source);
 	const importsReact = /\bfrom\s*["']react["']|\brequire\(\s*["']react["']\s*\)/.test(source);
@@ -1786,335 +2116,66 @@ for (const __mfShareKey of Object.keys(__mfModuleCache.share)) {
     const __mfLegacyShareKey = __mfShareKey.slice("default:".length);
     if (__mfModuleCache.share[__mfLegacyShareKey] === undefined) {
       __mfModuleCache.share[__mfLegacyShareKey] = __mfModuleCache.share[__mfShareKey];
-    }
-  } else if (!__mfShareKey.includes(":")) {
-    const __mfDefaultShareKey = "default:" + __mfShareKey;
-    if (__mfModuleCache.share[__mfDefaultShareKey] === undefined) {
-      __mfModuleCache.share[__mfDefaultShareKey] = __mfModuleCache.share[__mfShareKey];
-    }
-  }
-}
-`;
-}
-function getRuntimeInitPromiseBootstrapCode(enableSsrInit = false, ownerImportId, ssrRemotes, hostInitImportId = ownerImportId) {
-	return getRuntimeInitStateBootstrapCode({
-		globalKeyVar: "__mfPromiseGlobalKey",
-		stateVar: "__mfPromiseState",
-		exposedConst: "initPromise",
-		exposedProperty: "initPromise",
-		enableSsrInit,
-		ownerImportId,
-		hostInitImportId,
-		ssrRemotes
-	});
-}
-function getRuntimeInitResolveBootstrapCode(enableSsrInit = false, ownerImportId, ssrRemotes, hostInitImportId = ownerImportId) {
-	return getRuntimeInitStateBootstrapCode({
-		globalKeyVar: "__mfResolveGlobalKey",
-		stateVar: "__mfResolveState",
-		exposedConst: "initResolve",
-		exposedProperty: "initResolve",
-		enableSsrInit,
-		ownerImportId,
-		hostInitImportId,
-		ssrRemotes
-	});
-}
-function writeRuntimeInitStatus(command, enableSsrInit = false, hostInitImportId, options, ssrRemotes = _ssrRemotes) {
-	const exportStatement = command === "build" ? `const { initPromise, initResolve, initReject, moduleCache } = globalThis[globalKey];
-export { initPromise, initResolve, initReject, moduleCache };` : `module.exports = globalThis[globalKey];`;
-	const ownerImportId = options ? getRuntimeInitStatusImportId(options) : hostInitImportId;
-	getRuntimeInitModule(options).writeSync(`
-${getRuntimeInitBootstrapCode(enableSsrInit, ownerImportId, ssrRemotes, hostInitImportId)}
-${exportStatement}
-`);
-}
-//#endregion
-//#region src/plugins/pluginReactMixedModeGuard.ts
-function createReactMixedModeRuntimeGuard() {
-	return `const __mfReactInternals = mod["__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE"];
-if (__mfReactInternals && "A" in __mfReactInternals) {
-  let __mfReactDispatcher = __mfReactInternals.A;
-  Object.defineProperty(__mfReactInternals, "A", {
-    configurable: true,
-    enumerable: true,
-    get: () => __mfReactDispatcher,
-    set: (next) => {
-      if (next && typeof next.getOwner !== "function") next.getOwner = () => null;
-      __mfReactDispatcher = next;
-    },
-  });
-  __mfReactInternals.A = __mfReactDispatcher;
-}`;
-}
-//#endregion
-//#region src/utils/treeShaking.ts
-function shouldAnalyzeSharedExports(shareItem) {
-	return !!(shareItem && (shareItem.shareConfig.treeShaking || shareItem.shareConfig.import === false));
-}
-const legacyTreeShakingState = {
-	inferredUsage: /* @__PURE__ */ new Map(),
-	buildMode: false
-};
-const treeShakingStates = /* @__PURE__ */ new WeakMap();
-function getTreeShakingState(options) {
-	if (!options) return legacyTreeShakingState;
-	let state = treeShakingStates.get(options);
-	if (!state) {
-		state = {
-			inferredUsage: /* @__PURE__ */ new Map(),
-			buildMode: false
-		};
-		treeShakingStates.set(options, state);
-	}
-	return state;
-}
-function setTreeShakingBuildMode(enabled, options) {
-	getTreeShakingState(options).buildMode = enabled;
-}
-function resetTreeShakingExports(options) {
-	getTreeShakingState(options).inferredUsage.clear();
-}
-function getOrCreateExportRecord(sharedKey, request, options) {
-	const inferredUsage = getTreeShakingState(options).inferredUsage;
-	let byRequest = inferredUsage.get(sharedKey);
-	if (!byRequest) {
-		byRequest = /* @__PURE__ */ new Map();
-		inferredUsage.set(sharedKey, byRequest);
-	}
-	let record = byRequest.get(request);
-	if (!record) {
-		record = {
-			requiresFullBundle: false,
-			usedExports: /* @__PURE__ */ new Set()
-		};
-		byRequest.set(request, record);
-	}
-	return record;
-}
-function recordTreeShakingExports(sharedKey, exports, request = sharedKey, options) {
-	const record = getOrCreateExportRecord(sharedKey, request, options);
-	exports.forEach((name) => record.usedExports.add(name));
-}
-function markTreeShakingPackageUnsafe(sharedKey, request = sharedKey, options) {
-	getOrCreateExportRecord(sharedKey, request, options).requiresFullBundle = true;
-}
-function getExportRecords(sharedKey, request, options) {
-	const inferredUsage = getTreeShakingState(options).inferredUsage;
-	if (sharedKey) {
-		const records = inferredUsage.get(sharedKey);
-		const wildcard = records?.get("*");
-		const exact = records?.get(request);
-		return [wildcard, exact === wildcard ? void 0 : exact].filter((record) => !!record);
-	}
-	const records = [];
-	inferredUsage.forEach((byRequest, configuredKey) => {
-		const wildcard = byRequest.get("*");
-		const exact = byRequest.get(request);
-		const keyBase = configuredKey.endsWith("/") ? configuredKey.slice(0, -1) : configuredKey;
-		const requestMatchesConfiguredKey = request === keyBase || request.startsWith(`${keyBase}/`);
-		if (wildcard && requestMatchesConfiguredKey) records.push(wildcard);
-		if (exact && exact !== wildcard) records.push(exact);
-	});
-	return records;
-}
-/**
-* Return the analyzed requirement for one concrete shared request.
-*
-* Callers that know the configured share key should pass it explicitly. The
-* fallback lookup across keys keeps aliases/backwards-compatible callers
-* working, while still keeping each concrete request's exports isolated.
-*/
-function getSharedExportUsage(request, shareItem, sharedKey, options) {
-	const treeShaking = shareItem?.shareConfig.treeShaking;
-	if (!shouldAnalyzeSharedExports(shareItem) || !getTreeShakingState(options).buildMode) return;
-	const records = getExportRecords(sharedKey, request, options);
-	if (records.some((record) => record.requiresFullBundle)) return { kind: "full" };
-	const configured = treeShaking?.usedExports ?? [];
-	const result = new Set(configured);
-	records.forEach((record) => record.usedExports.forEach((name) => result.add(name)));
-	if (result.size > 0) return {
-		kind: "exports",
-		usedExports: [...result].sort()
-	};
-	return records.length > 0 ? {
-		kind: "exports",
-		usedExports: []
-	} : { kind: "unknown" };
-}
-function getTreeShakingExportUsage(request, shareItem, sharedKey, options) {
-	if (!shareItem?.shareConfig.treeShaking) return void 0;
-	return getSharedExportUsage(request, shareItem, sharedKey, options);
-}
-function getModuleSource(node) {
-	if (!node || typeof node !== "object") return void 0;
-	const source = node;
-	if (source.type === "Literal" && typeof source.value === "string") return source.value;
-	if (source.type === "StringLiteral" && typeof source.value === "string") return source.value;
-	if (source.type !== "TemplateLiteral") return void 0;
-	const expressions = Array.isArray(source.expressions) ? source.expressions : [];
-	const quasis = Array.isArray(source.quasis) ? source.quasis : [];
-	if (expressions.length > 0 || quasis.length !== 1) return void 0;
-	const value = quasis[0]?.value;
-	return typeof value?.cooked === "string" ? value.cooked : typeof value?.raw === "string" ? value.raw : void 0;
-}
-function getExportedName(node) {
-	if (!node || typeof node !== "object") return void 0;
-	const exported = node;
-	if (exported.type === "Identifier" && typeof exported.name === "string") return exported.name;
-	if ((exported.type === "Literal" || exported.type === "StringLiteral") && typeof exported.value === "string") return exported.value;
+    }
+  } else if (!__mfShareKey.includes(":")) {
+    const __mfDefaultShareKey = "default:" + __mfShareKey;
+    if (__mfModuleCache.share[__mfDefaultShareKey] === undefined) {
+      __mfModuleCache.share[__mfDefaultShareKey] = __mfModuleCache.share[__mfShareKey];
+    }
+  }
 }
-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 getRuntimeInitPromiseBootstrapCode(enableSsrInit = false, ownerImportId, ssrRemotes, hostInitImportId = ownerImportId) {
+	return getRuntimeInitStateBootstrapCode({
+		globalKeyVar: "__mfPromiseGlobalKey",
+		stateVar: "__mfPromiseState",
+		exposedConst: "initPromise",
+		exposedProperty: "initPromise",
+		enableSsrInit,
+		ownerImportId,
+		hostInitImportId,
+		ssrRemotes
+	});
 }
-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 getRuntimeInitResolveBootstrapCode(enableSsrInit = false, ownerImportId, ssrRemotes, hostInitImportId = ownerImportId) {
+	return getRuntimeInitStateBootstrapCode({
+		globalKeyVar: "__mfResolveGlobalKey",
+		stateVar: "__mfResolveState",
+		exposedConst: "initResolve",
+		exposedProperty: "initResolve",
+		enableSsrInit,
+		ownerImportId,
+		hostInitImportId,
+		ssrRemotes
+	});
 }
-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);
+function writeRuntimeInitStatus(command, enableSsrInit = false, hostInitImportId, options, ssrRemotes = _ssrRemotes) {
+	const exportStatement = command === "build" ? `const { initPromise, initResolve, initReject, moduleCache } = globalThis[globalKey];
+export { initPromise, initResolve, initReject, moduleCache };` : `module.exports = globalThis[globalKey];`;
+	const ownerImportId = options ? getRuntimeInitStatusImportId(options) : hostInitImportId;
+	getRuntimeInitModule(options).writeSync(`
+${getRuntimeInitBootstrapCode(enableSsrInit, ownerImportId, ssrRemotes, hostInitImportId)}
+${exportStatement}
+`);
 }
-/**
-* Collect the exports required by a consumer's ESM graph.
-*
-* Parsing the module avoids treating import-looking text in comments, strings,
-* templates, or regular expressions as real dependencies. If parsing fails,
-* every configured share whose exports are analyzed is conservatively marked
-* as requiring its full export surface instead of guessing from source text.
-*
-* Generated federation wrappers are excluded because their imports describe
-* the wrapper implementation, not the consumer's requirements.
-*/
-function collectTreeShakingImports(code, id, shared, findSharedKey, record, markUnsafe) {
-	const normalizedId = normalizePathForImport(id);
-	if (normalizedId.includes("__prebuild__") || normalizedId.includes("__loadShare__") || normalizedId.includes("__mf_tree_shaking_graph__")) return;
-	let ast;
-	try {
-		ast = parseAst(code);
-	} catch {
-		Object.entries(shared).forEach(([sharedKey, shareItem]) => {
-			if (shouldAnalyzeSharedExports(shareItem)) markUnsafe(sharedKey, "*");
-		});
-		return;
-	}
-	const matchShared = (source) => {
-		const sharedKey = findSharedKey(source, shared);
-		return sharedKey && shouldAnalyzeSharedExports(shared[sharedKey]) ? sharedKey : void 0;
-	};
-	const recordSource = (names, source) => {
-		const sharedKey = matchShared(source);
-		if (sharedKey) record(sharedKey, names, source);
-	};
-	const markSourceUnsafe = (source) => {
-		const sharedKey = matchShared(source);
-		if (sharedKey) markUnsafe(sharedKey, source);
-	};
-	forEachAstNode(ast, (node) => {
-		if (node.type === "ImportDeclaration") {
-			const source = getModuleSource(node.source);
-			if (source) collectImportDeclaration(node, source, recordSource, markSourceUnsafe);
-			return;
-		}
-		if ((node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") && node.source) {
-			const source = getModuleSource(node.source);
-			if (source) collectReExport(node, source, recordSource, markSourceUnsafe);
-			return;
-		}
-		if (node.type === "ImportExpression") {
-			const source = getModuleSource(node.source);
-			if (source) markSourceUnsafe(source);
-			return;
-		}
-		if (node.type === "CallExpression") {
-			const callee = node.callee;
-			const args = Array.isArray(node.arguments) ? node.arguments : [];
-			if (callee?.type === "Identifier" && callee.name === "require" && args.length > 0) {
-				const source = getModuleSource(args[0]);
-				if (source) markSourceUnsafe(source);
-			}
-		}
-	});
+//#endregion
+//#region src/plugins/pluginReactMixedModeGuard.ts
+function createReactMixedModeRuntimeGuard() {
+	return `const __mfReactInternals = mod["__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE"];
+if (__mfReactInternals && "A" in __mfReactInternals) {
+  let __mfReactDispatcher = __mfReactInternals.A;
+  Object.defineProperty(__mfReactInternals, "A", {
+    configurable: true,
+    enumerable: true,
+    get: () => __mfReactDispatcher,
+    set: (next) => {
+      if (next && typeof next.getOwner !== "function") next.getOwner = () => null;
+      __mfReactDispatcher = next;
+    },
+  });
+  __mfReactInternals.A = __mfReactDispatcher;
+}`;
 }
 //#endregion
 //#region src/utils/typeArgumentScanner.ts
@@ -2257,6 +2318,18 @@ const DEFAULT_SHARED_EXPORT_CONDITIONS = [
 	"module",
 	"default"
 ];
+function getSharedExportSource(source) {
+	const parts = [];
+	let offset = 0;
+	const codePositions = createCodePositionMap(source, (start, end) => {
+		parts.push(source.slice(offset, start), source.slice(start, end).replace(/[^\r\n\u2028\u2029]/g, " "));
+		offset = end;
+	});
+	return {
+		source: parts.length ? parts.join("") + source.slice(offset) : source,
+		codePositions
+	};
+}
 function hasCodeMatch(source, regex, codePositions) {
 	regex.lastIndex = 0;
 	let match;
@@ -2301,8 +2374,7 @@ function getMutableExportsFromFile(entryPath, exportConditions = DEFAULT_SHARED_
 	if (!entryPath || visited.has(entryPath)) return [];
 	visited.add(entryPath);
 	try {
-		const source = readFileSync(entryPath, "utf-8");
-		const codePositions = createCodePositionMap(source);
+		const { source, codePositions } = getSharedExportSource(readFileSync(entryPath, "utf-8"));
 		const mutableBindings = /* @__PURE__ */ new Set();
 		const mutableExports = /* @__PURE__ */ new Set();
 		let match;
@@ -2616,7 +2688,9 @@ function hasUnsupportedBindingPattern(source, start) {
 }
 function getNamedExportsViaRegex(source, filePath, visited, scanState = { complete: true }, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
 	const names = /* @__PURE__ */ new Set();
-	const codePositions = createCodePositionMap(source);
+	const inspected = getSharedExportSource(source);
+	source = inspected.source;
+	const codePositions = inspected.codePositions;
 	const recognizedExportStarts = /* @__PURE__ */ new Set();
 	visited = visited || /* @__PURE__ */ new Set();
 	if (filePath) visited.add(filePath);
@@ -3806,10 +3880,11 @@ function generateLocalSharedImportMap(options) {
       }
       `;
 }
-/** Expand `pkg/` → package root + matching usedShares; never returns the prefix string. */
+/** Expand `pkg/` → package root (if importable) + matching usedShares; never returns the prefix string. */
 function expandSharedPrefixKey(prefixKey, used) {
 	const base = prefixKey.slice(0, -1);
-	const expanded = /* @__PURE__ */ new Set([base]);
+	const baseImportable = isPackageInstalled(base) && isPackageExportAvailable(base);
+	const expanded = new Set(baseImportable ? [base] : []);
 	for (const pkg of used) {
 		if (pkg.endsWith("/")) continue;
 		if (pkg === base || pkg.startsWith(`${base}/`)) expanded.add(pkg);
@@ -3987,6 +4062,8 @@ const normalizeRuntimeShareCode = `const __mfNormalizeRuntimeShare = (mod) => {
           };`;
 const sharedProviderSelectionHelperCode = `const __mfOriginalProviderKey = Symbol("mf.originalSharedProvider");
           const __mfResolveShareHook = { emit: (params) => params };
+          const __mfGetShareScopeNames = (share) =>
+            Array.isArray(share.scope) ? share.scope : [share.scope || "default"];
           const __mfCreateProviderSelectionVersions = (versions, strategy) => {
             if (strategy !== "version-first") return versions;
             const selectionVersions = {};
@@ -4028,7 +4105,7 @@ const sharedProviderSelectionHelperCode = `const __mfOriginalProviderKey = Symbo
               Object.entries(versions).filter(([, provider]) => provider?.shareConfig?.import !== false)
             );
             if (Object.keys(candidates).length === 0) return undefined;
-            const scopes = Array.isArray(share.scope) ? share.scope : [share.scope || "default"];
+            const scopes = __mfGetShareScopeNames(share);
             const selectionVersions = __mfCreateProviderSelectionVersions(candidates, strategy);
             const shareScopeMap = {};
             for (const scope of scopes) {
@@ -4488,7 +4565,7 @@ function generateTreeShakingSnapshotPluginCode(enabled) {
   });`;
 }
 function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(options), command = "build", exportConditions) {
-	const needsSharedProviderSelectionHelper = Object.keys(options.shared ?? {}).length > 0;
+	const needsSharedProviderSelectionHelper = hasShared(options);
 	const hasTreeShakingShared = Object.values(options.shared ?? {}).some((share) => !!share?.shareConfig.treeShaking);
 	const hasMultipleShareScopes = Array.isArray(options.shareScope);
 	const guardHostAutoInit = command === "build" && isRemoteContainer(options) && hasRemotes(options);
@@ -5468,7 +5545,28 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
 	const hostInitShareBatches = toSafeJsLiteral(getShareBatches(options, false));
 	const cacheOwner = toSafeJsLiteral(resolvedOptions.name);
 	const preferLocalVinextReact = hasPackageDependency("vinext") && (!exportConditions?.includes("browser") || exportConditions.includes("worker"));
+	const hasConfiguredShared = hasShared(resolvedOptions);
+	const hostInitSharedProviderHelperImport = shouldPreloadShares && hasConfiguredShared ? "import {share as runtimeShare} from \"@module-federation/runtime/helpers\";" : "";
+	const hostInitSharedProviderHelperCode = shouldPreloadShares && hasConfiguredShared ? `
+          ${sharedProviderSelectionHelperCode}
+          const __mfHasUsableProvider = (versions, pkg, share, scopeName) => {
+            // Keep runtime singleton negotiation unchanged. A singleton already
+            // registered in this scope is authoritative, even when runtime-core
+            // reports a version mismatch.
+            if (share.shareConfig?.singleton) {
+              return Object.values(versions || {}).some(
+                (provider) => provider?.shareConfig?.import !== false
+              );
+            }
+            return Boolean(__mfSelectSharedProvider(
+              versions,
+              pkg,
+              { ...share, scope: [scopeName] },
+              ${toSafeJsLiteral(resolvedOptions.shareStrategy)}
+            ));
+          };` : "";
 	return `
+    ${hostInitSharedProviderHelperImport}
     ${getRuntimeModuleCacheBootstrapCode(exportConditions)}
     let hostInitPromise;
     async function initHost() {
@@ -5482,12 +5580,13 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
           ${normalizeRuntimeShareCode}
           ${shouldPreloadShares ? `
           const __mfHasAlternativeSharedVersion = (pkg, share) =>
-            (Array.isArray(share.scope) ? share.scope : [share.scope || 'default']).some(
+            __mfGetShareScopeNames(share).some(
               (scopeName) => Object.keys(runtime.shareScopeMap?.[scopeName]?.[pkg] || {}).some(
                 (version) => version !== share.version
               )
             );
           const __mfHostInitShareBatches = ${hostInitShareBatches};
+          ${hostInitSharedProviderHelperCode}
           for (const __mfHostInitShareBatch of __mfHostInitShareBatches) {
             await Promise.all(__mfHostInitShareBatch.map(async (pkg) => {
               const share = usedShared[pkg];
@@ -5505,18 +5604,57 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
                       )`}
               ) return;
               // An import:false share has nothing to load until a foreign provider
-              // registers: its own stub getter throws by construction.
-              if (
-                share.shareConfig?.import === false &&
-                !(Array.isArray(share.scope) ? share.scope : [share.scope || 'default']).some((scopeName) =>
-                  Object.values(runtime.shareScopeMap?.[scopeName]?.[pkg] || {}).some(
-                    (provider) => provider?.shareConfig?.import !== false
-                  )
-                )
-              ) return;
+              // registers: its own stub getter throws by construction. A standalone
+              // container initialized on the same page keeps its providers in its
+              // own runtime scope (#1307), so adopt those before giving up.
+              if (share.shareConfig?.import === false) {
+                const __mfScopeNames = __mfGetShareScopeNames(share);
+                const __mfNeedsSiblingProvider = (scopeName) =>
+                  !__mfHasUsableProvider(
+                    runtime.shareScopeMap?.[scopeName]?.[pkg],
+                    pkg,
+                    share,
+                    scopeName
+                  );
+                if (__mfScopeNames.some(__mfNeedsSiblingProvider)) {
+                  // loadShare() re-runs initializeSharing(), which re-registers this
+                  // container's own stub and lets it displace an unloaded adopted
+                  // provider whenever this container's name sorts after the provider's
+                  // (#1311). Put the provider back: a stub never outranks a provider.
+                  if (!runtime.__mfKeepAdoptedProviders) {
+                    runtime.__mfKeepAdoptedProviders = true;
+                    runtime.sharedHandler?.hooks?.lifecycle?.afterRegisterShare?.on?.((args) => {
+                      const { shared, previousShared, registeredShared } = args || {};
+                      if (
+                        shared?.shareConfig?.import !== false ||
+                        registeredShared !== shared ||
+                        !previousShared ||
+                        previousShared.shareConfig?.import === false
+                      ) return;
+                      const versions = runtime.shareScopeMap?.[args.scope]?.[args.pkgName];
+                      if (versions && versions[shared.version] === shared) versions[shared.version] = previousShared;
+                    });
+                  }
+                  for (const instance of globalThis.__FEDERATION__?.__INSTANCES__ || []) {
+                    for (const scopeName of __mfScopeNames) {
+                      const versions = instance?.shareScopeMap?.[scopeName]?.[pkg];
+                      if (!__mfHasUsableProvider(versions, pkg, share, scopeName)) continue;
+                      if (!__mfNeedsSiblingProvider(scopeName)) continue;
+                      const target = (runtime.shareScopeMap[scopeName] ||= {})[pkg] ||= {};
+                      for (const [version, provider] of Object.entries(versions)) {
+                        if (provider?.shareConfig?.import === false) continue;
+                        if (target[version] && target[version].shareConfig?.import !== false) continue;
+                        target[version] = provider;
+                      }
+                    }
+                  }
+                }
+                if (__mfScopeNames.every(__mfNeedsSiblingProvider)) return;
+              }
               await runtime.loadShare(pkg, {
                 customShareInfo: { shareConfig: share.shareConfig }
               }).then(async (factory) => {
+                if (factory === false) return;
                 const mod = typeof factory === "function" ? factory() : factory;
                 let resolved = __mfNormalizeRuntimeShare(await Promise.resolve(mod));
                 ${preferLocalVinextReact ? `if (
@@ -6100,9 +6238,6 @@ if (typeof document !== 'undefined' && document.head) {
 function getFirstHtmlEntryFile(entryFiles) {
 	return entryFiles.find((file) => file.endsWith(".html"));
 }
-function stripQueryAndHash$1(file) {
-	return file.split(/[?#]/)[0];
-}
 function isReactRouterClientRouteInput(file) {
 	return /[?&]__react-router-build-client-route(?:[=&]|$)/.test(file);
 }
@@ -6153,6 +6288,7 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 	let emitFileId;
 	let pendingSharesEmitId;
 	let viteConfig;
+	let devServer;
 	let skipHtmlDevFallback = forceClientInjected ?? false;
 	let clientInjected = false;
 	let emittedFileName;
@@ -6229,6 +6365,28 @@ const __mfCurrentScript = document.currentScript;
 			return registration && (registration.type === "module" || registration.type === "esm") && /^(?:https?:)?\/\//.test(registration.entry) && !/\.json(?:[?#]|$)/i.test(registration.entry) ? [registration.entry] : [];
 		})));
 	}
+	async function warmupDevEntryGraph(entryUrl) {
+		const server = devServer;
+		if (!server) return;
+		const seen = /* @__PURE__ */ new Set();
+		const cacheDir = normalizePathForImport(server.config?.cacheDir ?? "").replace(/\/$/, "") + "/";
+		const visit = async (url) => {
+			if (seen.has(url)) return;
+			seen.add(url);
+			try {
+				await server.transformRequest(url);
+			} catch {
+				return;
+			}
+			const deps = [...(await server.moduleGraph.getModuleByUrl(url))?.importedModules ?? []].filter((dep) => {
+				if (!dep.file || dep.type !== "js" || !path$1.isAbsolute(dep.file)) return false;
+				const file = normalizePathForImport(dep.file);
+				return !file.includes("/node_modules/") && !file.startsWith(cacheDir);
+			});
+			await Promise.all(deps.map((dep) => visit(dep.url)));
+		};
+		await visit(entryUrl).catch(() => {});
+	}
 	function getBootstrapSource(initSrc, entrySrc, useSystemImportFallback = false, options) {
 		const importHelper = useSystemImportFallback ? `const __mfImport = (src) =>
   globalThis.System && typeof globalThis.System.import === 'function'
@@ -6345,7 +6503,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 	function isWorkspaceSourceId(id) {
 		const normalized = normalizeModuleId(decodeViteId(id));
 		if (normalized.startsWith("\0") || normalized.startsWith("virtual:")) return false;
-		const filePath = stripQueryAndHash$1(normalized);
+		const filePath = stripQueryAndHash(normalized);
 		if (filePath.startsWith("/@fs/")) return true;
 		if (!path$1.isAbsolute(filePath)) return false;
 		const root = normalizePathForImport(path$1.resolve(viteConfig.root));
@@ -6367,7 +6525,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 				ignoredHtmlScriptSources.add(match[1]);
 				continue;
 			}
-			const scriptSrc = stripQueryAndHash$1(match[1]);
+			const scriptSrc = stripQueryAndHash(match[1]);
 			if (/^(?:[a-z]+:)?\/\//i.test(scriptSrc)) continue;
 			addEntryFile(scriptSrc);
 			addEntryFile(scriptSrc.startsWith("/") ? path$1.resolve(viteConfig.root, scriptSrc.slice(1)) : path$1.resolve(path$1.dirname(htmlPath), scriptSrc));
@@ -6375,7 +6533,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 	}
 	function addEntryRemoteImports(entrySrc) {
 		if (!federationOptions || /^(?:[a-z]+:)?\/\//i.test(entrySrc)) return;
-		const file = path$1.resolve(viteConfig.root, stripQueryAndHash$1(entrySrc).replace(/^\//, ""));
+		const file = path$1.resolve(viteConfig.root, stripQueryAndHash(entrySrc).replace(/^\//, ""));
 		if (!fs$2.existsSync(file)) return;
 		const code = fs$2.readFileSync(file, "utf-8");
 		for (const source of findModuleImportSources(code)) {
@@ -6402,6 +6560,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			skipTransformIds = new Set(skipTransformFor.map(resolveProjectId));
 		},
 		configureServer(server) {
+			devServer = server;
 			server.middlewares.use((req, res, next) => {
 				const rawUrl = req.url?.split("#")[0] ?? "";
 				if (normalizeDevHtmlProxyId(rawUrl.split("?")[0]) === DEV_HTML_PROXY_PREFIX.slice(0, -1)) {
@@ -6411,9 +6570,12 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 					const entrySrc = params.get("entry");
 					if (initSrc && entrySrc) {
 						const withBase = (src) => viteConfig.base + src.replace(/^\//, "");
-						res.statusCode = 200;
-						res.setHeader("Content-Type", "application/javascript");
-						res.end(getBootstrapSource(withBase(initSrc), withBase(entrySrc)));
+						const source = getBootstrapSource(withBase(initSrc), withBase(entrySrc));
+						warmupDevEntryGraph(entrySrc).finally(() => {
+							res.statusCode = 200;
+							res.setHeader("Content-Type", "application/javascript");
+							res.end(source);
+						});
 						return;
 					}
 				}
@@ -6461,7 +6623,8 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			const initSrc = params.get("init");
 			const entrySrc = params.get("entry");
 			if (!initSrc || !entrySrc) return;
-			return getBootstrapSource(initSrc, entrySrc);
+			const source = getBootstrapSource(initSrc, entrySrc);
+			return warmupDevEntryGraph(entrySrc).then(() => source);
 		},
 		transform(code, id) {
 			if (id.includes("node_modules") || inject !== "html" || htmlFilePath) return;
@@ -7405,7 +7568,7 @@ function pluginExternalRuntimeCore() {
 }
 //#endregion
 //#region package.json
-var version$1 = "1.22.0";
+var version$1 = "1.22.1";
 //#endregion
 //#region src/virtualModules/index.ts
 function initVirtualModules(command, remoteEntryId, enableSsrInit = false, options) {
@@ -7494,16 +7657,31 @@ const collectStaticChunks = (bundle, roots) => {
 };
 /**
 * Analyzes assets associated with a chunk without mutating the output map.
-* The static-import traversal is cycle-safe and ignores missing bundle entries.
+* Dynamic imports are collected transitively (a lazy route nested behind another
+* lazy route is still reachable), following both static and dynamic edges.
+* The traversal is cycle-safe and ignores missing bundle entries.
 */
 const analyzeChunkAssets = (bundle, fileName, chunk) => {
 	const dynamicAssets = [];
-	for (const currentChunk of collectStaticChunks(bundle, [fileName])) for (const dynamicImport of currentChunk.dynamicImports ?? []) {
-		if (!bundle[dynamicImport]) continue;
-		dynamicAssets.push({
-			fileName: dynamicImport,
-			type: isCSSFile(dynamicImport) ? "css" : "js"
-		});
+	const visited = /* @__PURE__ */ new Set([fileName]);
+	const queue = [fileName];
+	const enqueue = (imported) => {
+		if (visited.has(imported)) return;
+		visited.add(imported);
+		queue.push(imported);
+	};
+	for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
+		const currentChunk = bundle[queue[queueIndex]];
+		if (!currentChunk || currentChunk.type !== "chunk") continue;
+		for (const imported of currentChunk.imports ?? []) enqueue(imported);
+		for (const dynamicImport of currentChunk.dynamicImports ?? []) {
+			if (!bundle[dynamicImport]) continue;
+			dynamicAssets.push({
+				fileName: dynamicImport,
+				type: isCSSFile(dynamicImport) ? "css" : "js"
+			});
+			enqueue(dynamicImport);
+		}
 	}
 	return {
 		importedCss: Array.from(chunk.viteMetadata?.importedCss ?? []),
@@ -8089,14 +8267,25 @@ const Manifest = (providedOptions) => {
 				expandExposeAssets(filesMap, exposesModules, bundle, foundRemoteEntryFile, mfOptions, getIsRolldown(this));
 				const fileToShareKey = await buildFileToShareKeyMap(getUsedShares(mfOptions), this.resolve.bind(this), mfOptions);
 				processModuleAssets(Object.fromEntries(Object.entries(bundle).filter(([, file]) => !isTreeShakingProviderChunk(file))), filesMap, (modulePath) => fileToShareKey.get(modulePath));
+				const deferredSharedAssets = {
+					js: /* @__PURE__ */ new Set(),
+					css: /* @__PURE__ */ new Set()
+				};
 				for (const shareKey of getUsedShares(mfOptions)) {
 					const shareItem = getNormalizeShareItem(shareKey, mfOptions);
 					const assets = filesMap[shareKey];
 					if (!assets || shareItem?.shareConfig.eager === true) continue;
-					assets.js.async.push(...assets.js.sync.splice(0));
-					assets.css.async.push(...assets.css.sync.splice(0));
+					for (const type of ASSET_TYPES) {
+						assets[type].async.push(...assets[type].sync.splice(0));
+						for (const asset of assets[type].async) deferredSharedAssets[type].add(asset);
+					}
 				}
 				if (mfOptions.bundleAllCSS) addCssAssetsToAllExports(filesMap, allCssAssets);
+				for (const exposeModule of exposesModules) {
+					const assets = filesMap[exposeModule];
+					if (!assets) continue;
+					for (const type of ASSET_TYPES) for (const timing of LOAD_TIMINGS) assets[type][timing] = assets[type][timing].filter((asset) => !deferredSharedAssets[type].has(asset));
+				}
 				filesMap = deduplicateAssets(filesMap);
 			}
 			const manifest = await applyManifestAdditionalData(generateMFManifest(filesMap, disableAssetsAnalyze), void 0);
@@ -8702,6 +8891,81 @@ function pluginProxyRemotes_default(options) {
 	};
 }
 //#endregion
+//#region src/utils/sharedSource.ts
+/** Identify shared entries through Vite, with a cache scoped to this federation instance. */
+function createSharedSourceResolver(shared, getResolutionConfig) {
+	const caches = /* @__PURE__ */ new Map();
+	async function matchEntry(source, suffix, resolveEntry) {
+		const packageName = getPackageNameFromNodeModulePath(source);
+		if (!packageName) return;
+		const candidates = /* @__PURE__ */ new Set();
+		if (findSharedKey(packageName, shared)) candidates.add(packageName);
+		if (findSharedKey(suffix, shared)) candidates.add(suffix);
+		for (const key of Object.keys(shared)) {
+			if (getPackageName(key) !== packageName) continue;
+			if (!key.endsWith("/")) candidates.add(key);
+			for (const subpath of getCommonSharedSubpaths(key)) if (findSharedKey(subpath, shared)) candidates.add(subpath);
+		}
+		if (candidates.size === 0) return;
+		const resolvedSource = await resolveEntry(source);
+		if (!resolvedSource) return;
+		for (const candidate of candidates) {
+			const entry = await resolveEntry(candidate);
+			if (!entry) continue;
+			if (normalizeNodeModulePath(entry) === normalizeNodeModulePath(resolvedSource) || getNodeModulesSuffix(entry) === suffix) return candidate;
+		}
+	}
+	return {
+		clear() {
+			caches.clear();
+		},
+		async resolve(context, source, options = {}) {
+			if (source.startsWith("\0") || source.includes("#")) return;
+			const queryIndex = source.indexOf("?");
+			const query = queryIndex === -1 ? "" : source.slice(queryIndex + 1);
+			if (query && [...new URLSearchParams(query).keys()].some((key) => ![
+				"v",
+				"t",
+				"import"
+			].includes(key))) return;
+			if (findSharedKey(source, shared)) return source;
+			const suffix = getNodeModulesSuffix(source);
+			if (!suffix) return;
+			const normalizedSource = stripViteFsPrefix(normalizeNodeModulePath(source));
+			const environment = context.environment ?? !!options.ssr;
+			const cacheable = !options.isEntry && !options.scan && (!options.kind || options.kind === "import-statement") && Object.keys(options.attributes ?? {}).length === 0 && Object.keys(options.custom ?? {}).length === 0;
+			let cache = cacheable ? caches.get(environment) : void 0;
+			if (cacheable && !cache) {
+				cache = /* @__PURE__ */ new Map();
+				caches.set(environment, cache);
+			}
+			if (cache?.has(normalizedSource)) return cache.get(normalizedSource);
+			const { root, conditions } = getResolutionConfig(context, options);
+			const result = await matchEntry(normalizedSource, suffix, async (request) => {
+				if (!path$1.isAbsolute(request) && !isPackageExportAvailable(request, {
+					cwd: root,
+					conditions
+				})) return void 0;
+				try {
+					const resolved = await context.resolve(request, path$1.join(root, "package.json"), {
+						...options,
+						skipSelf: true,
+						custom: {
+							...options.custom,
+							__mfSharedEntryLookup: true
+						}
+					});
+					return resolved && !resolved.external ? resolved.id : void 0;
+				} catch {
+					return;
+				}
+			});
+			cache?.set(normalizedSource, result);
+			return result;
+		}
+	};
+}
+//#endregion
 //#region src/utils/PromiseStore.ts
 /**
 * example:
@@ -8751,23 +9015,6 @@ function isBuildConfigImporter(importer) {
 	if (!importer) return false;
 	return /(^|\/)(?:nuxt|vite|vitest|webpack|rollup|rspack)\.config\.[cm]?[jt]sx?$/.test(importer.replace(/\\/g, "/"));
 }
-function findSharedKeyForSource(source, shared) {
-	const key = findSharedKey(source, shared);
-	if (key) return key;
-	const explicitSharedSubpathKeys = Object.keys(shared || {}).filter((sharedKey) => getPackageName(sharedKey) !== sharedKey && !sharedKey.endsWith("/"));
-	if (isNodeModulePath(source)) {
-		const explicitSubpathKey = getMatchingNodeModuleSubpath(source, explicitSharedSubpathKeys);
-		if (explicitSubpathKey) return explicitSubpathKey;
-		const normalizedSource = normalizeNodeModulePath(source);
-		const explicitSubpathEntryKey = explicitSharedSubpathKeys.find((sharedKey) => {
-			const entry = getInstalledPackageEntry(sharedKey, { cwd: getPackageDetectionCwd() });
-			return entry ? normalizeNodeModulePath(entry) === normalizedSource : false;
-		});
-		if (explicitSubpathEntryKey) return explicitSubpathEntryKey;
-	}
-	const packageName = getPackageNameFromNodeModulePath(source);
-	return packageName ? findSharedKey(packageName, shared) : void 0;
-}
 /**
 * Reads the dependencies of an installed package from its package.json.
 */
@@ -9141,6 +9388,10 @@ function proxySharedModule(options) {
 			ssrTarget
 		});
 	};
+	const sharedSourceResolver = createSharedSourceResolver(shared, (context, resolveOptions) => ({
+		root: _config?.root || getPackageDetectionCwd(),
+		conditions: getRuntimeDependencyConditions(context, resolveOptions)
+	}));
 	const refreshTreeShakingForEnvironment = (context) => refreshTreeShakingModules(federationOptions, _command, getIsRolldown(context), getEnvironmentConditions(context));
 	const normalizeTreeShakingOutputPath = (value) => {
 		const normalized = normalizePathForImport(value);
@@ -9190,7 +9441,7 @@ function proxySharedModule(options) {
 					refreshTreeShakingForEnvironment(this);
 					const providerPackages = /* @__PURE__ */ new Set([...Object.keys(shared).filter((pkg) => !pkg.endsWith("/")), ...getUsedShares(federationOptions)]);
 					for (const pkg of providerPackages) {
-						const sharedKey = findSharedKeyForSource(pkg, shared);
+						const sharedKey = findSharedKey(pkg, shared);
 						const shareItem = shared[pkg] || (sharedKey ? shared[sharedKey] : void 0);
 						if (shareItem) emitTreeShakingProvider(this, pkg, shareItem);
 					}
@@ -9210,6 +9461,7 @@ function proxySharedModule(options) {
 				setTreeShakingBuildMode(command === "build", federationOptions);
 				resetTreeShakingExports(federationOptions);
 				emittedTreeShakingProviders.clear();
+				sharedSourceResolver.clear();
 				sharedDependencyCache.clear();
 				dependencyManifestCache.clear();
 				sharedRuntimeDependencyCache.clear();
@@ -9244,7 +9496,11 @@ function proxySharedModule(options) {
 				writeLocalSharedImportMap(federationOptions);
 				refreshHostAutoInit(federationOptions);
 			},
+			watchChange() {
+				sharedSourceResolver.clear();
+			},
 			buildStart() {
+				sharedSourceResolver.clear();
 				if (_command !== "build") return;
 				resetTreeShakingExports(federationOptions);
 				emittedTreeShakingProviders.clear();
@@ -9253,9 +9509,12 @@ function proxySharedModule(options) {
 			shouldTransformCachedModule() {
 				return _command === "build" && hasAnalyzableShares;
 			},
-			transform(code, id) {
+			async transform(code, id, transformOptions) {
 				if (_command !== "build" || !hasAnalyzableShares) return;
-				collectTreeShakingImports(code, id, shared, findSharedKeyForSource, (sharedKey, exports, request) => recordTreeShakingExports(sharedKey, exports, request, federationOptions), (sharedKey, request) => markTreeShakingPackageUnsafe(sharedKey, request, federationOptions));
+				await collectTreeShakingImports(code, id, shared, async (source, shares) => {
+					const request = await sharedSourceResolver.resolve(this, source, transformOptions);
+					return request ? findSharedKey(request, shares) : void 0;
+				}, (sharedKey, exports, request) => recordTreeShakingExports(sharedKey, exports, request, federationOptions), (sharedKey, request) => markTreeShakingPackageUnsafe(sharedKey, request, federationOptions));
 				refreshTreeShakingForEnvironment(this);
 			}
 		},
@@ -9264,6 +9523,7 @@ function proxySharedModule(options) {
 			enforce: "pre",
 			apply: "build",
 			async resolveId(source, importer, resolveOptions) {
+				if (resolveOptions.custom?.__mfSharedEntryLookup) return;
 				const sourceToken = getTreeShakingGraphToken(source);
 				const importerToken = getTreeShakingGraphToken(importer);
 				const token = sourceToken || importerToken;
@@ -9271,7 +9531,8 @@ function proxySharedModule(options) {
 				const cleanSource = normalizePathForImport(stripTreeShakingGraphQuery(source));
 				const cleanImporter = importer ? normalizePathForImport(stripTreeShakingGraphQuery(importer)) : void 0;
 				if (!sourceToken && importerToken) {
-					const nestedSharedKey = findSharedKeyForSource(cleanSource, shared);
+					const request = await sharedSourceResolver.resolve(this, cleanSource, resolveOptions);
+					const nestedSharedKey = request ? findSharedKey(request, shared) : void 0;
 					if (nestedSharedKey && getPackageName(nestedSharedKey) !== getPackageName(importerToken)) return this.resolve(cleanSource, cleanImporter, {
 						...resolveOptions,
 						skipSelf: true
@@ -9298,20 +9559,22 @@ function proxySharedModule(options) {
 			name: "proxyPreBuildShared:resolve-shared-loadShare",
 			enforce: "pre",
 			async resolveId(source, importer, resolveOptions) {
-				if (resolveOptions.custom?.__mfTreeShakingGraph) return;
-				function shouldSkipTaggedImporterProxy(sharedKey, tag) {
+				if (resolveOptions.custom?.__mfSharedEntryLookup || resolveOptions.custom?.__mfTreeShakingGraph) return;
+				const sharedSource = await sharedSourceResolver.resolve(this, source, resolveOptions);
+				if (!sharedSource) return;
+				const key = findSharedKey(sharedSource, shared);
+				if (!key) return;
+				const shouldSkipTaggedImporterProxy = (sharedKey, tag) => {
 					if (!importer?.includes(tag)) return false;
 					const taggedModule = VirtualModule.findModule(tag, importer);
 					if (!taggedModule) return true;
-					return taggedModule.name === sharedKey || matchesSharedSource(source, taggedModule.name);
-				}
-				const key = findSharedKeyForSource(source, shared);
-				if (!key) return;
+					return taggedModule.name === sharedKey || matchesSharedSource(sharedSource, taggedModule.name);
+				};
 				const importerPackage = getSharedPackageFromFile(importer, shared);
 				if (importerPackage === getPackageName(key)) return;
 				if (importerPackage && shared[key].shareConfig.import !== false) {
 					const importerIsUnsharedWorkspacePackage = !isNodeModulePath(importer) && !Object.keys(shared).some((sharedKey) => getPackageName(sharedKey) === importerPackage);
-					const runtimeDependencyRequest = key.endsWith("/") && matchesSharedSource(source, key) ? source : key;
+					const runtimeDependencyRequest = key.endsWith("/") && matchesSharedSource(sharedSource, key) ? sharedSource : key;
 					if (importerIsUnsharedWorkspacePackage ? isSharedPackageRuntimeDependency(runtimeDependencyRequest, importerPackage, getRuntimeDependencyConditions(this, resolveOptions)) : isSharedPackageDependency(key, importerPackage)) return;
 				}
 				if (useDirectReactImport && key === "react") return;
@@ -9322,8 +9585,8 @@ function proxySharedModule(options) {
 				if (importer && (importer.includes("hostAutoInit") || importer.includes("__H_A_I__"))) return;
 				if (shouldSkipTaggedImporterProxy(key, "__loadShare__")) return;
 				if (shouldSkipTaggedImporterProxy(key, "__prebuild__")) return;
-				const shareSource = key === "vue" && source.startsWith("vue/dist/") ? key : isNodeModulePath(source) ? getCommonSharedSubpathFromNodeModulePath(source, key) || key : source;
-				if (shouldKeepSharedImportLocal(source, importer, key, shared, importerPackage)) {
+				const shareSource = key === "vue" && sharedSource.startsWith("vue/dist/") ? key : sharedSource;
+				if (shouldKeepSharedImportLocal(sharedSource, importer, key, shared, importerPackage)) {
 					const localSource = getPrebuildResolutionSource(shareSource, shared[key]);
 					return tryResolveFromProjectRoot(localSource) || localSource;
 				}
@@ -9649,7 +9912,6 @@ function pluginRemoteNamedExports(options) {
 const MAX_RUNNER_BODY_BYTES = 1024 * 1024;
 const MAX_RUNNER_START_OFFSET = 1024 * 1024;
 const ALLOWED_RUNNER_INVOKE_NAMES = /* @__PURE__ */ new Set(["fetchModule", "getBuiltins"]);
-const VITE_FS_PREFIX = "/@fs/";
 function isPlainObject(value) {
 	return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -9668,12 +9930,6 @@ function isSafeRunnerFetchModuleOptions(value) {
 	}
 	return true;
 }
-function stripQueryAndHash(id) {
-	const queryIndex = id.indexOf("?");
-	const hashIndex = id.indexOf("#");
-	const endIndex = queryIndex === -1 ? hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
-	return endIndex === -1 ? id : id.slice(0, endIndex);
-}
 function decodeRunnerFilePath(filePath) {
 	try {
 		return decodeURIComponent(filePath);
@@ -9717,8 +9973,8 @@ function isSafeRunnerFetchModuleId(id, config) {
 	const cleanId = decodeRunnerFilePath(stripQueryAndHash(decoded));
 	if (!cleanId || hasRelativeTraversal(cleanId)) return false;
 	const allowedDirectories = getRunnerAllowedDirectories(config);
-	if (cleanId.startsWith(VITE_FS_PREFIX)) {
-		const fsPath = `/${cleanId.slice(5)}`;
+	if (cleanId.startsWith("/@fs/")) {
+		const fsPath = stripViteFsPrefix(cleanId);
 		return path$1.isAbsolute(fsPath) && isPathWithinAllowedDirectories(fsPath, allowedDirectories);
 	}
 	if (path$1.isAbsolute(cleanId)) {
@@ -10253,7 +10509,7 @@ function applyRuntimeCapabilityDefines(define, options, { defaultDisableSnapshot
 function getRuntimeCapabilityConfigurationWarnings(options) {
 	const warnings = [];
 	if (options.disableRemote && Object.keys(options.remotes).length > 0) warnings.push("disableRemote is true, but remotes are configured. Remote loading will be unavailable at runtime.");
-	if (options.disableShared && Object.keys(options.shared).length > 0) warnings.push("disableShared is true, but shared dependencies are configured. Shared dependency loading will be unavailable at runtime.");
+	if (options.disableShared && hasShared(options)) warnings.push("disableShared is true, but shared dependencies are configured. Shared dependency loading will be unavailable at runtime.");
 	return warnings;
 }
 //#endregion
@@ -10564,6 +10820,7 @@ function createEarlyVirtualModulesPlugin(options) {
 			const resolvedConfiguredEntryFiles = (typeof buildInput === "string" ? [buildInput] : Array.isArray(buildInput) ? buildInput : buildInput && typeof buildInput === "object" ? Object.values(buildInput) : []).map((entry) => String(entry)).filter((entry) => !isReactRouterBuildClientRouteInput(entry)).map((entry) => entry.split(/[?#]/)[0]).map((entry) => path$1.isAbsolute(entry) ? entry : path$1.resolve(root, entry));
 			resetConcreteSharedImportSourceCache();
 			setPackageDetectionCwd(root);
+			resolveSharedVersions(shared, root);
 			const isVinext = hasPackageDependency("vinext");
 			initVirtualModules(_command, getRemoteEntryId(options), false, options);
 			const isRolldown = getIsRolldown(this);
@@ -10576,11 +10833,11 @@ function createEarlyVirtualModulesPlugin(options) {
 					config.optimizeDeps.exclude.push(...Object.keys(remotes || {}));
 				}
 			}
-			if (!config.build?.ssr && (Object.keys(shared ?? {}).length > 0 || Object.keys(remotes ?? {}).length > 0)) {
+			if (!config.build?.ssr && (hasShared(options) || hasRemotes(options))) {
 				const hasJsxSource = registerEntryImports(options, root, _command === "serve", resolvedConfiguredEntryFiles);
 				if (_command === "serve") hasClientJsxSource = hasJsxSource;
 			}
-			if (shared && Object.keys(shared).length > 0) {
+			if (hasShared(options)) {
 				if (_command === "serve") {
 					excludeSharedSubDependencies(shared);
 					config.optimizeDeps = config.optimizeDeps || {};
@@ -10799,7 +11056,7 @@ function applyBuildTimeRuntimeDefines(define, options, { target, isAstro, defaul
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-D7Faa4NJ.js").then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-CQ088qGF.js").then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {
@@ -10980,6 +11237,7 @@ function federation(mfUserOptions) {
 				ssrTarget = config.ssr?.target ?? "node";
 				isProduction = config.isProduction;
 				const ssrCapabilities = getSsrCapabilities(parseInt(version, 10), command, Object.keys(options.remotes).length > 0);
+				resolveSharedVersions(shared, config.root);
 				initVirtualModules(command, remoteEntryId, ssrCapabilities.enableSsrInitBootstrap, options);
 			}
 		},
@@ -11089,7 +11347,7 @@ function federation(mfUserOptions) {
 						if (id.includes("__loadShare__")) {
 							const pkg = getCachedLoadSharePkg(id);
 							const key = pkg && findSharedKey(pkg, shared);
-							if (useCodeSplitting && key && shared[key].shareConfig.eager === true) return "loadShare-eager";
+							if (key && shared[key].shareConfig.eager === true) return "loadShare-eager";
 							if (key && shared[key].shareConfig.import === false) return null;
 							const match = id.match(/([^/\\]+__loadShare__[^/\\]+)/);
 							return match ? match[1] : "loadShare";
@@ -11266,7 +11524,7 @@ function federation(mfUserOptions) {
 			config(config, { command: _command }) {
 				const isRolldown = getIsRolldown(this);
 				isSsrBuild = _command === "build" && Boolean(config.build?.ssr);
-				const needsRuntimeHelpers = Object.keys(options.shared ?? {}).length > 0;
+				const needsRuntimeHelpers = hasShared(options);
 				if (needsRuntimeHelpers) appendResolveAlias(config, {
 					find: /^@module-federation\/runtime\/helpers$/,
 					replacement: getRuntimeHelpersImplementation(options.implementation)