@module-federation/vite 1.21.2 → 1.21.4

package/lib/index.js

@@ -1,10 +1,10 @@
 import { n as normalizePathForImport, r as rebaseImport } from "./buildPaths-BkaQHrd2.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-DyJrx8ah.js";
-import { a as getCommonSharedSubpaths, c as isNodeModulePath, d as normalizeNodeModulePath, f as resolvePublicPath, i as getCommonSharedSubpathFromNodeModulePath, l as isNuxtClientBase, n as filterId, o as getMatchingNodeModuleSubpath, r as getBasePath$1, s as isAssetLikeImport, t as ensureTrailingSlash, u as isViteOptimizableEntry } from "./pathNormalization-CHct3UwV.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-BsaLBaaK.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 { createRequire } from "node:module";
 import * as fs$2 from "fs";
-import { existsSync, readFileSync, realpathSync, statSync, writeFileSync } from "fs";
-import { createRequire as createRequire$1 } from "module";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "fs";
+import { createRequire as createRequire$1, isBuiltin } from "module";
 import * as path$1 from "node:path";
 import path, { basename } from "node:path";
 import { fileURLToPath, pathToFileURL } from "url";
@@ -13,6 +13,7 @@ import { createHash } from "node:crypto";
 import * as fs$1 from "node:fs";
 import { existsSync as existsSync$1, readFileSync as readFileSync$1 } from "node:fs";
 import { pathToFileURL as pathToFileURL$1 } from "node:url";
+import { isIPv6 } from "node:net";
 //#region src/utils/bundleHelpers.ts
 function isOutputChunk$1(chunk) {
 	return chunk.type === "chunk";
@@ -502,68 +503,119 @@ function createCodePositionMap(code) {
 }
 //#endregion
 //#region src/utils/htmlEntryUtils.ts
-function isTypeOnlyClause(clause) {
-	const normalized = clause.trim();
-	if (/^type\b/.test(normalized)) return true;
-	const namedSpecifiers = normalized.match(/^\{([\s\S]*)\}$/)?.[1];
-	if (!namedSpecifiers) return false;
+const IDENTIFIER = String.raw`[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}]*`;
+const NAMED_SPECIFIERS = String.raw`\{[^{}]*\}`;
+const NAMESPACE_SPECIFIER = String.raw`\*\s*as\s+${IDENTIFIER}`;
+const IMPORT_CLAUSE = String.raw`(?:(?<importType>type)\s+)?(?<importClause>${NAMESPACE_SPECIFIER}|${NAMED_SPECIFIERS}|${IDENTIFIER}(?:\s*,\s*(?:${NAMESPACE_SPECIFIER}|${NAMED_SPECIFIERS}))?)`;
+const EXPORT_CLAUSE = String.raw`(?:(?<exportType>type)\s+)?(?<exportClause>\*(?:\s*as\s+(?:${IDENTIFIER}|"[^"]*"|'[^']*'))?|${NAMED_SPECIFIERS})`;
+const SPECIFIER = String.raw`(?<quote>["'])(?<source>[^"'\r\n]*)\k<quote>`;
+const KEYWORD_BOUNDARY = String.raw`(?<![.$\w])`;
+const KEYWORD_GAP = String.raw`(?:\s+|(?=[{*]))`;
+const STATIC_PATTERN = new RegExp(String.raw`${KEYWORD_BOUNDARY}(?:import${KEYWORD_GAP}${IMPORT_CLAUSE}|export${KEYWORD_GAP}${EXPORT_CLAUSE})\s*from\s*${SPECIFIER}`, "gud");
+const DYNAMIC_PATTERN = new RegExp(String.raw`${KEYWORD_BOUNDARY}import\s*\(\s*${SPECIFIER}`, "gud");
+const REQUIRE_PATTERN = new RegExp(String.raw`${KEYWORD_BOUNDARY}require\s*\(\s*${SPECIFIER}\s*\)`, "gud");
+const SIDE_EFFECT_PATTERN = new RegExp(String.raw`${KEYWORD_BOUNDARY}import\s*${SPECIFIER}`, "gud");
+/**
+* Returns `code` with every non-code region blanked out to spaces so that
+* regexes can run against real syntax only. String literals keep their
+* delimiters (with a blank interior) so import specifiers stay locatable;
+* comments, template literals, and regular expressions vanish entirely.
+* The result has the same length as `code`, so match indices map back 1:1.
+*/
+function blankNonCode(code) {
+	const codePositions = createCodePositionMap(code);
+	const chars = code.split("");
+	let index = 0;
+	while (index < code.length) {
+		if (codePositions[index]) {
+			index++;
+			continue;
+		}
+		const start = index;
+		while (index < code.length && !codePositions[index]) index++;
+		const quote = code[start];
+		const isString = (quote === "\"" || quote === "'") && index - start >= 2 && code[index - 1] === quote;
+		for (let position = start; position < index; position++) chars[position] = isString && (position === start || position === index - 1) ? quote : code[position] === "\n" ? "\n" : " ";
+	}
+	return chars.join("");
+}
+function isTypeOnlyNamedClause(clause) {
+	const namedSpecifiers = clause.trim().match(/^\{([\s\S]*)\}$/)?.[1];
+	if (namedSpecifiers === void 0) return false;
 	const specifiers = namedSpecifiers.split(",").map((specifier) => specifier.trim()).filter(Boolean);
-	return specifiers.length > 0 && specifiers.every((specifier) => /^type\s+\S/.test(specifier));
+	return specifiers.length > 0 && specifiers.every((specifier) => /^type\s+(?!as(?:\s|$))\S/.test(specifier));
+}
+function readSource(code, match) {
+	const range = match.indices?.groups?.source;
+	if (!range) return void 0;
+	const source = code.slice(range[0], range[1]);
+	return source.length > 0 ? source : void 0;
 }
 /**
 * Finds module imports while ignoring comments, strings, and regular expressions.
 * The descriptor keeps enough information for callers to distinguish runtime
 * static imports from type-only imports without introducing a parser dependency.
+*
+* Matching runs against a blanked copy of the code (see `blankNonCode`), so an
+* `import` inside a comment or string can never match, comments inside a
+* statement never change its classification, and a clause can never span
+* multiple statements.
 */
 function findModuleImportDescriptors(code) {
-	const codePositions = createCodePositionMap(code);
+	const blanked = blankNonCode(code);
 	const descriptors = [];
-	const staticFromPattern = /\b(?:import|export)\s+([\s\S]*?)\s+from\s*(["'])([^"']+)\2/g;
-	const dynamicPattern = /\bimport\s*\(\s*(?:\/\*[\s\S]*?\*\/\s*)?(["'])([^"']+)\1\s*\)/g;
-	const requirePattern = /\brequire\s*\(\s*(["'])([^"']+)\1\s*\)/g;
-	const sideEffectPattern = /\bimport\s*(["'])([^"']+)\1/g;
-	let match;
-	while (match = staticFromPattern.exec(code)) {
-		if (!codePositions[match.index]) {
-			staticFromPattern.lastIndex = match.index + 1;
-			continue;
-		}
+	for (const match of blanked.matchAll(STATIC_PATTERN)) {
+		const source = readSource(code, match);
+		if (!source) continue;
+		const groups = match.groups;
+		const typeOnly = groups.importType !== void 0 || groups.exportType !== void 0 || isTypeOnlyNamedClause(groups.importClause ?? groups.exportClause ?? "");
 		descriptors.push({
 			kind: "static",
 			syntax: "import",
-			source: match[3],
-			typeOnly: isTypeOnlyClause(match[1])
+			source,
+			typeOnly
 		});
 	}
-	for (const match of code.matchAll(dynamicPattern)) {
-		if (!codePositions[match.index]) continue;
-		descriptors.push({
+	for (const match of blanked.matchAll(DYNAMIC_PATTERN)) {
+		const source = readSource(code, match);
+		if (source) descriptors.push({
 			kind: "dynamic",
 			syntax: "import",
-			source: match[2],
+			source,
 			typeOnly: false
 		});
 	}
-	for (const match of code.matchAll(requirePattern)) {
-		if (!codePositions[match.index]) continue;
-		descriptors.push({
+	for (const match of blanked.matchAll(REQUIRE_PATTERN)) {
+		const source = readSource(code, match);
+		if (source) descriptors.push({
 			kind: "dynamic",
 			syntax: "require",
-			source: match[2],
+			source,
 			typeOnly: false
 		});
 	}
-	for (const match of code.matchAll(sideEffectPattern)) {
-		if (!codePositions[match.index]) continue;
-		descriptors.push({
+	for (const match of blanked.matchAll(SIDE_EFFECT_PATTERN)) {
+		const source = readSource(code, match);
+		if (source) descriptors.push({
 			kind: "static",
 			syntax: "import",
-			source: match[2],
+			source,
 			typeOnly: false
 		});
 	}
 	return descriptors;
 }
+/**
+* Returns the JavaScript/TypeScript portion of a module for import scanning.
+* Vue and Svelte single-file components only contribute their `<script>`
+* blocks so template markup and styles are never misread as code.
+*/
+function getScannableModuleSource(id, code) {
+	if (!/\.(?:vue|svelte)(?:\?|$)/.test(id)) return code;
+	const blocks = [];
+	for (const match of code.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script(?:\s[^>]*)?>/gi)) blocks.push(match[1]);
+	return blocks.join("\n");
+}
 function findModuleImportSources(code) {
 	return Array.from(new Set(findModuleImportDescriptors(code).filter(({ syntax, typeOnly }) => syntax === "import" && !typeOnly).map(({ source }) => source)));
 }
@@ -588,7 +640,8 @@ function rewriteEntryScripts(html, createProxySrc) {
 }
 function injectEntryScript(html, initSrc) {
 	const src = sanitizeDevEntryPath(initSrc);
-	return html.replace("<head>", `<head><script type="module" src=${JSON.stringify(src)}><\/script>`);
+	const script = `<script type="module" src=${JSON.stringify(src)}><\/script>`;
+	return html.replace(/<head\b[^>]*>/i, (openTag) => `${openTag}${script}`);
 }
 //#endregion
 //#region src/utils/normalizeModuleFederationOptions.ts
@@ -673,7 +726,30 @@ function searchPackageVersion(sharedName) {
 }
 function inferVersionFromRequiredVersion(requiredVersion) {
 	if (typeof requiredVersion !== "string") return void 0;
-	return requiredVersion.match(/\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/)?.[0];
+	const isDigit = (char) => char !== void 0 && char >= "0" && char <= "9";
+	const isSuffixChar = (char) => char !== void 0 && (char >= "0" && char <= "9" || char >= "A" && char <= "Z" || char >= "a" && char <= "z" || char === "." || char === "-");
+	let index = 0;
+	while (index < requiredVersion.length) {
+		if (!isDigit(requiredVersion[index])) {
+			index += 1;
+			continue;
+		}
+		const start = index;
+		while (isDigit(requiredVersion[index])) index += 1;
+		if (requiredVersion[index] !== ".") continue;
+		index += 1;
+		if (!isDigit(requiredVersion[index])) continue;
+		while (isDigit(requiredVersion[index])) index += 1;
+		if (requiredVersion[index] !== ".") continue;
+		index += 1;
+		if (!isDigit(requiredVersion[index])) continue;
+		while (isDigit(requiredVersion[index])) index += 1;
+		if ((requiredVersion[index] === "-" || requiredVersion[index] === "+") && isSuffixChar(requiredVersion[index + 1])) {
+			index += 1;
+			while (isSuffixChar(requiredVersion[index])) index += 1;
+		}
+		return requiredVersion.slice(start, index);
+	}
 }
 /** URI-style package specifiers are not semver ranges for runtime satisfy(). */
 const PACKAGE_SPECIFIER_PROTOCOL_RE = /^[a-z][a-z\d+.-]*:/i;
@@ -854,7 +930,7 @@ function normalizeModuleFederationOptions(options) {
 		injectTreeShakingUsedExports: options.injectTreeShakingUsedExports,
 		treeShakingSharedPlugins: options.treeShakingSharedPlugins,
 		treeShakingSharedExcludePlugins: options.treeShakingSharedExcludePlugins,
-		moduleParseTimeout: options.moduleParseTimeout || 10,
+		moduleParseTimeout: options.moduleParseTimeout ?? 10,
 		moduleParseIdleTimeout: options.moduleParseIdleTimeout,
 		varFilename: options.varFilename,
 		target: options.target,
@@ -1016,7 +1092,7 @@ function serializeRuntimeOptions(options) {
 		if (type === "number" || type === "boolean") return String(val);
 		if (type === "undefined") return "undefined";
 		if (type === "symbol") return `Symbol(${toSafeJsLiteral(val.description ?? "")})`;
-		if (type === "function") return val.toString();
+		if (type === "function") return functionToExpression(val);
 		if (val instanceof Date) return `new Date(${toSafeJsLiteral(val.toISOString())})`;
 		if (val instanceof RegExp) return `new RegExp(${toSafeJsLiteral(val.source)}, ${toSafeJsLiteral(val.flags)})`;
 		if (type === "object") {
@@ -1039,9 +1115,49 @@ function serializeRuntimeOptions(options) {
 	for (const key in options) if (Object.prototype.hasOwnProperty.call(options, key)) topLevelProps.push(`${toSafeJsLiteral(key)}: ${valueToCode(options[key])}`);
 	return `{${topLevelProps.join(", ")}}`;
 }
+const NATIVE_FUNCTION_SOURCE = /\{\s*\[native code\]\s*\}\s*$/;
+/**
+* Turns `Function#toString()` output into a JS expression that is valid as an
+* object-literal value.
+*
+* Method shorthand (`onError() { … }`) is not a valid expression after a `:`,
+* so it is rewritten as a function expression. Native functions have no
+* reconstructable source (`function parse() { [native code] }`) and serialize
+* as `undefined` so the generated object stays loadable.
+*/
+function functionToExpression(fn) {
+	let source;
+	try {
+		source = Function.prototype.toString.call(fn).trim();
+	} catch {
+		return "undefined";
+	}
+	if (NATIVE_FUNCTION_SOURCE.test(source) || /^(async\s+)?(?:get|set)\s+/.test(source)) return "undefined";
+	if (/^(async\s+)?function\b/.test(source) || /^(async\s*)?\(/.test(source) || /^class\b/.test(source) || /^(async\s+)?[$_\p{ID_Start}][$\p{ID_Continue}]*\s*=>/u.test(source)) return isParsableExpression(source) ? source : "undefined";
+	for (const [pattern, prefix] of [
+		[/^async\s*\*\s*[$_\p{ID_Start}][$\p{ID_Continue}]*\s*(\([\s\S]*)$/u, "async function* "],
+		[/^\*\s*[$_\p{ID_Start}][$\p{ID_Continue}]*\s*(\([\s\S]*)$/u, "function* "],
+		[/^async\s+[$_\p{ID_Start}][$\p{ID_Continue}]*\s*(\([\s\S]*)$/u, "async function "],
+		[/^[$_\p{ID_Start}][$\p{ID_Continue}]*\s*(\([\s\S]*)$/u, "function "]
+	]) {
+		const match = source.match(pattern);
+		if (!match) continue;
+		const expression = `${prefix}${match[1]}`;
+		return isParsableExpression(expression) ? expression : "undefined";
+	}
+	return "undefined";
+}
+function isParsableExpression(source) {
+	try {
+		new Function(`return (${source});`);
+		return true;
+	} catch {
+		return false;
+	}
+}
 //#endregion
 //#region src/utils/reactIsland.ts
-const SOURCE_EXTENSIONS = [
+const SOURCE_EXTENSIONS$1 = [
 	".tsx",
 	".jsx",
 	".ts",
@@ -1060,8 +1176,8 @@ function resolveSourceFile(importPath, root) {
 	const candidate = path$1.isAbsolute(cleanImport) ? cleanImport : path$1.resolve(root, cleanImport);
 	return [
 		candidate,
-		...SOURCE_EXTENSIONS.map((extension) => `${candidate}${extension}`),
-		...SOURCE_EXTENSIONS.map((extension) => path$1.join(candidate, `index${extension}`))
+		...SOURCE_EXTENSIONS$1.map((extension) => `${candidate}${extension}`),
+		...SOURCE_EXTENSIONS$1.map((extension) => path$1.join(candidate, `index${extension}`))
 	].find((filePath) => {
 		try {
 			return fs$1.statSync(filePath).isFile();
@@ -1283,6 +1399,49 @@ function loadReactIslandConsumerModule(id) {
 function getVirtualModuleScopeKey(options) {
 	return `${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
+function compareConfigValues(a, b) {
+	const serializedA = JSON.stringify(a);
+	const serializedB = JSON.stringify(b);
+	return serializedA < serializedB ? -1 : serializedA > serializedB ? 1 : 0;
+}
+function stableConfigValue(value, ancestors = /* @__PURE__ */ new WeakSet()) {
+	if (typeof value === "function") return value.toString();
+	if (!value || typeof value !== "object") return value;
+	if (value instanceof Date) return {
+		type: "Date",
+		value: value.toISOString()
+	};
+	if (value instanceof RegExp) return {
+		type: "RegExp",
+		source: value.source,
+		flags: value.flags
+	};
+	if (ancestors.has(value)) return "__circular__";
+	ancestors.add(value);
+	let result;
+	if (value instanceof Map) {
+		const entries = [...value.entries()].map(([key, item]) => [stableConfigValue(key, ancestors), stableConfigValue(item, ancestors)]);
+		entries.sort(compareConfigValues);
+		result = {
+			type: "Map",
+			entries
+		};
+	} else if (value instanceof Set) {
+		const values = [...value].map((item) => stableConfigValue(item, ancestors));
+		values.sort(compareConfigValues);
+		result = {
+			type: "Set",
+			values
+		};
+	} else result = Array.isArray(value) ? value.map((item) => stableConfigValue(item, ancestors)) : Object.fromEntries(Object.entries(value).filter(([key]) => key !== "implementation").sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => [key, stableConfigValue(item, ancestors)]));
+	ancestors.delete(value);
+	return result;
+}
+function getFederationScopeKey(options) {
+	const identity = JSON.stringify(stableConfigValue(options));
+	const ownerId = BigInt(`0x${createHash("sha256").update(identity).digest("hex").slice(0, 12)}`);
+	return `${options.internalName}${MF_OWNER_INFIX}${ownerId}`;
+}
 //#endregion
 //#region src/virtualModules/virtualExposes.ts
 const EXPOSES_CSS_MAP_PLACEHOLDER = "__MF_EXPOSES_CSS_MAP__";
@@ -1432,28 +1591,17 @@ function isReactServerConditions(conditions) {
 //#region src/virtualModules/virtualRuntimeInitStatus.ts
 const virtualRuntimeInitStatus = new VirtualModule("runtimeInit");
 const runtimeInitModules = /* @__PURE__ */ new WeakMap();
-const runtimeInitOwnerIds = /* @__PURE__ */ new WeakMap();
-let nextRuntimeInitOwnerId = 1;
 const MODULE_CACHE_GLOBAL_KEY = "__mf_module_cache__";
 const REACT_SERVER_MODULE_CACHE_GLOBAL_KEY = "__mf_module_cache_react_server__";
 const MODULE_CACHE_SHARE_SCOPE_KEY = "module-federation.vite-module-cache";
 function getModuleCacheGlobalKey(exportConditions) {
 	return isReactServerConditions(exportConditions) ? REACT_SERVER_MODULE_CACHE_GLOBAL_KEY : MODULE_CACHE_GLOBAL_KEY;
 }
-function getRuntimeInitOwnerId(options) {
-	let ownerId = runtimeInitOwnerIds.get(options);
-	if (!ownerId) {
-		ownerId = nextRuntimeInitOwnerId++;
-		runtimeInitOwnerIds.set(options, ownerId);
-	}
-	return ownerId;
-}
 function getRuntimeInitModule(options) {
 	if (!options) return virtualRuntimeInitStatus;
 	let runtimeInitModule = runtimeInitModules.get(options);
 	if (!runtimeInitModule) {
-		const ownerId = getRuntimeInitOwnerId(options);
-		runtimeInitModule = new VirtualModule("runtimeInit", "__mf_v__", "", `${options.internalName}${MF_OWNER_INFIX}${ownerId}`);
+		runtimeInitModule = new VirtualModule("runtimeInit", "__mf_v__", "", getFederationScopeKey(options));
 		runtimeInitModules.set(options, runtimeInitModule);
 	}
 	return runtimeInitModule;
@@ -1466,7 +1614,14 @@ function getRuntimeRemoteCachePrefix(options) {
 }
 function getRuntimeRemoteAlias(alias, options) {
 	if (!options) return alias;
-	return `${options.internalName}${MF_OWNER_INFIX}${getRuntimeInitOwnerId(options)}__${alias}`;
+	return `${getFederationScopeKey(options)}__${alias}`;
+}
+function getSsrRuntimeRemotes(remotes, options) {
+	return Object.entries(remotes).map(([name, item]) => ({
+		name: getRuntimeRemoteAlias(name, options),
+		entry: item.entry,
+		type: item.type ?? "module"
+	}));
 }
 function getRuntimeInitGlobalKey(ownerImportId) {
 	return `__mf_init__${ownerImportId ?? virtualRuntimeInitStatus.getImportId()}__`;
@@ -1556,6 +1711,16 @@ globalThis[__mfCacheGlobalKey] ||= { share: {}, remote: {} };
 globalThis[__mfCacheGlobalKey].share ||= {};
 globalThis[__mfCacheGlobalKey].remote ||= {};
 const __mfModuleCache = globalThis[__mfCacheGlobalKey];
+const __mfTrackPendingShareLoad = (promise) => {
+  const pendingShareLoads = (__mfModuleCache.pendingShareLoads ||= []);
+  pendingShareLoads.push(promise);
+  const cleanup = () => {
+    const index = pendingShareLoads.indexOf(promise);
+    if (index !== -1) pendingShareLoads.splice(index, 1);
+  };
+  void promise.then(cleanup, cleanup);
+  return promise;
+};
 for (const __mfShareKey of Object.keys(__mfModuleCache.share)) {
   if (__mfShareKey.startsWith("default:")) {
     const __mfLegacyShareKey = __mfShareKey.slice("default:".length);
@@ -1928,6 +2093,7 @@ function hasLikelyTypeArgumentFollower(source, end, codePositions, followsNamedE
 	let next = end + 1;
 	while (next < source.length && (!codePositions[next] || /\s/.test(source[next]))) next++;
 	if (next >= source.length || /[([.!?=;,)\]}:|&]/.test(source[next])) return true;
+	if (source.slice(end + 1, next).includes("\n")) return true;
 	const followingToken = source.slice(next).match(/^[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}]*/u)?.[0];
 	return followingToken === "as" || followingToken === "satisfies" || !followsNamedExpression && followingToken !== void 0;
 }
@@ -2236,6 +2402,14 @@ function getAdditionalTopLevelDeclaratorNames(source, start, codePositions) {
 			canStartRegex = false;
 			continue;
 		}
+		if (char === "<" && source[index + 1] === "/") {
+			const jsxClosingTag = source.slice(index).match(/^<\/\s*(?:[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}.:-]*\s*)?>/u);
+			if (jsxClosingTag) {
+				index += jsxClosingTag[0].length - 1;
+				canStartRegex = false;
+				continue;
+			}
+		}
 		if (char === "/" && source[index + 1] === "/") {
 			index = source.indexOf("\n", index + 2);
 			if (index === -1) return names;
@@ -2288,6 +2462,11 @@ function getAdditionalTopLevelDeclaratorNames(source, start, codePositions) {
 			const tokenStart = index;
 			while (/[$_\u200C\u200D\p{ID_Continue}]/u.test(source[index + 1] || "")) index++;
 			const token = source.slice(tokenStart, index + 1);
+			if (depth === 0 && templateFrames.length === 0 && token === "export") {
+				let previous = tokenStart - 1;
+				while (/\s/.test(source[previous] || "")) previous--;
+				if (source[previous] !== "." && /^\s+(?:(?:async\s+)?function\b|(?:abstract\s+)?class\b|const\b|let\b|var\b|enum\b|namespace\b|module\b|interface\b|type\b|declare\b|default\b|\{|\*)/.test(source.slice(index + 1))) return names;
+			}
 			canStartRegex = /^(?:await|case|delete|in|instanceof|new|return|throw|typeof|void|yield)$/.test(token);
 			continue;
 		}
@@ -2472,6 +2651,15 @@ function getNamedExportsViaRegex(source, filePath, visited, scanState = { comple
 		let previousCodeIndex = match.index - 1;
 		while (previousCodeIndex >= 0 && (/\s/.test(source[previousCodeIndex]) || !codePositions[previousCodeIndex])) previousCodeIndex--;
 		if (source[previousCodeIndex] === ".") continue;
+		let nextCodeIndex = match.index + match[0].length;
+		while (nextCodeIndex < source.length && (/\s/.test(source[nextCodeIndex]) || !codePositions[nextCodeIndex])) nextCodeIndex++;
+		if (source[nextCodeIndex] === "(") continue;
+		let memberIndex = nextCodeIndex;
+		if (source[memberIndex] === "?") {
+			memberIndex++;
+			while (memberIndex < source.length && (/\s/.test(source[memberIndex]) || !codePositions[memberIndex])) memberIndex++;
+		}
+		if (source[memberIndex] === ":") continue;
 		scanState.complete = false;
 		break;
 	}
@@ -2633,23 +2821,25 @@ function getDependencyNames(packageJson) {
 	}
 	return Array.from(names);
 }
-function isSharedSingletonConsumedByPeer(pkg, options = getNormalizeModuleFederationOptions()) {
+function isSharedSingletonConsumedByPeer(pkg, options = getNormalizeModuleFederationOptions(), requireFederationRuntimeDependency = false) {
 	const shared = options?.shared || {};
-	if (Object.entries(shared).some(([key, item]) => key !== pkg && key.startsWith(`${pkg}/`) && item.shareConfig.singleton === true)) return true;
+	if (!requireFederationRuntimeDependency && Object.entries(shared).some(([key, item]) => key !== pkg && key.startsWith(`${pkg}/`) && item.shareConfig.singleton === true)) return true;
 	const sharedKeyByPackageName = /* @__PURE__ */ new Map();
 	Object.entries(shared).filter(([, item]) => item.shareConfig.singleton === true).forEach(([key]) => {
 		const packageName = getPackageName(key);
 		if (!sharedKeyByPackageName.get(packageName) || key === packageName) sharedKeyByPackageName.set(packageName, key);
 	});
-	const reachesPkg = (current, seen) => {
-		const packageJson = getSharedDependencyGraphPackageJson(current);
-		for (const dependency of getDependencyNames(packageJson)) {
+	const reachesPkg = (current, seen, hasFederationRuntimeDependency = false) => {
+		const dependencies = getDependencyNames(getSharedDependencyGraphPackageJson(current));
+		const usesFederationRuntime = dependencies.some((dependency) => dependency === "@module-federation/enhanced" || dependency === "@module-federation/runtime" || dependency === "@module-federation/runtime-core");
+		const runtimeIsReachable = hasFederationRuntimeDependency || usesFederationRuntime;
+		for (const dependency of dependencies) {
 			const sharedDependency = sharedKeyByPackageName.get(dependency);
 			if (!sharedDependency) continue;
-			if (sharedDependency === pkg) return true;
+			if (sharedDependency === pkg) return !requireFederationRuntimeDependency || runtimeIsReachable;
 			if (seen.has(sharedDependency)) continue;
 			seen.add(sharedDependency);
-			if (reachesPkg(sharedDependency, seen)) return true;
+			if (reachesPkg(sharedDependency, seen, runtimeIsReachable)) return true;
 		}
 		return false;
 	};
@@ -2710,7 +2900,6 @@ const legacySharedVirtualModuleState = {
 	warnedMissingImportFalse: /* @__PURE__ */ new Set()
 };
 const sharedVirtualModuleStates = /* @__PURE__ */ new WeakMap();
-let nextSharedVirtualModuleOwnerId = 1;
 function getSharedVirtualModuleState(options) {
 	if (!options) try {
 		const currentOptions = getNormalizeModuleFederationOptions();
@@ -2727,7 +2916,7 @@ function getSharedVirtualModuleState(options) {
 			materializedTreeShakingProviders: /* @__PURE__ */ new Set(),
 			loadShareCacheMap: {},
 			warnedMissingImportFalse: /* @__PURE__ */ new Set(),
-			ownerKey: `${options.internalName}${MF_OWNER_INFIX}${nextSharedVirtualModuleOwnerId++}`
+			ownerKey: getFederationScopeKey(options)
 		};
 		sharedVirtualModuleStates.set(options, state);
 	}
@@ -2981,6 +3170,12 @@ function findCurrentLoadShareForStaleOwnerId(id, shared, findSharedKey, options)
 function getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer) {
 	return treeShakingConsumer ? `__mfReadTreeShakingSharedSelection(__mfModuleCache.share, ${cacheDescriptor}, ${JSON.stringify(treeShakingConsumer)})` : `__mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor})`;
 }
+/**
+* Eager workspace singleton wrapper: reads the shared cache synchronously and falls back to the local
+* namespace. Inside the fallback's own evaluation cycle that namespace is not initialized yet (undefined in
+* a merged chunk, TDZ bindings otherwise), so the exports stay unassigned until the deferred cache write
+* re-applies them; a host-provided copy re-applies them through the cache subscription as before.
+*/
 function generateEagerWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer, mutableExports = []) {
 	const copiedExports = namedExports.filter((name) => !mutableExports.includes(name));
 	const namedExportVars = copiedExports.map((_name, i) => `__mf_${i}`);
@@ -2992,8 +3187,10 @@ function generateEagerWorkspaceSingletonExports(namedExports, importSource, cach
     let exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
     if (exportModule === undefined) {
       Promise.resolve().then(() => {
-        if (__mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor}) === undefined) {
-          __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfNormalizeShareModule(__mfLocalShare), ${cacheOwner});
+        if (__mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor}) !== undefined) return;
+        const localShare = __mfInitializedLocalShare(__mfLocalShare);
+        if (localShare !== undefined) {
+          __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, localShare, ${cacheOwner});
         }
       });
       exportModule = __mfLocalShare;
@@ -3002,8 +3199,16 @@ function generateEagerWorkspaceSingletonExports(namedExports, importSource, cach
     const __mfApplyEagerShareExports = (mod) => {
       ${assignments}
     };
+    const __mfApplyEagerShareExportsWhenReady = (mod) => {
+      if (mod === undefined) return;
+      try {
+        __mfApplyEagerShareExports(mod);
+      } catch (error) {
+        if (!(error instanceof ReferenceError)) throw error;
+      }
+    };
     __mfSubscribeSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfApplyEagerShareExports);
-    __mfApplyEagerShareExports(exportModule);
+    __mfApplyEagerShareExportsWhenReady(exportModule);
     export { __mf_default as default };${namedExportLine}${mutableExportLine}`;
 }
 function generateLazyWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer, serveLocalFallback = false, mutableExports = []) {
@@ -3026,7 +3231,7 @@ function generateLazyWorkspaceSingletonExports(namedExports, importSource, cache
       if (import.meta.env.SSR${serveLocalFallback ? " || (import.meta.env.DEV && typeof __mfLocalShare !== 'undefined')" : ""}) {
         ${applyLocalFallback}
       } else {
-        (__mfModuleCache.pendingShareLoads ||= []).push(initPromise.then(() => {
+        __mfTrackPendingShareLoad(initPromise.then(() => {
           exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
           if (exportModule !== undefined) {
             __mfApplyLazyShareExports(exportModule);
@@ -3071,7 +3276,7 @@ function generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor,
     };
     let exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
     if (exportModule === undefined) {
-      (__mfModuleCache.pendingShareLoads ||= []).push(initPromise.then(() => {
+      __mfTrackPendingShareLoad(initPromise.then(() => {
         exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
         if (exportModule === undefined) {
           throw new Error("[Module Federation] Shared module ${pkg} was imported before federation bootstrap finished.");
@@ -3111,6 +3316,15 @@ const normalizeLocalShareModuleCode = `const __mfNormalizeShareModule = (mod) =>
         ? Object.assign({}, normalized)
         : normalized;
     };`;
+const initializedLocalShareModuleCode = `const __mfInitializedLocalShare = (mod) => {
+      if (mod === undefined) return undefined;
+      try {
+        return __mfNormalizeShareModule(mod);
+      } catch (error) {
+        if (error instanceof ReferenceError) return undefined;
+        throw error;
+      }
+    };`;
 function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exportConditions, importFalseExportUsage) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const { loadShareCacheMap } = getSharedVirtualModuleState(options);
@@ -3158,10 +3372,10 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	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 = hasCompleteExportCoverage && (isWorkspacePackage || command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true || command === "build" && isRemoteOnlyContainer(resolvedOptions) && (shareItem.shareConfig.singleton === true ? !isDefaultShareScope : isDefaultShareScope));
+	const usesDeferredSingletonFallback = hasCompleteExportCoverage && shareItem.shareConfig.eager !== true && (isWorkspacePackage || command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true || command === "build" && isRemoteOnlyContainer(resolvedOptions) && (shareItem.shareConfig.singleton === true || isDefaultShareScope) && !isSharedSingletonConsumedByPeer(pkg, resolvedOptions, true));
 	const servesRemoteSingletonFallback = command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true;
 	const isConsumedByPeerSingleton = isSharedSingletonConsumedByPeer(pkg, resolvedOptions);
-	const usesEntryInjectedRemoteFallback = hasCompleteExportCoverage && command !== "build" && !isWorkspaceSingleton && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true && resolvedOptions.hostInitInjectLocation === "entry" && isConsumedByPeerSingleton;
+	const usesEntryInjectedRemoteFallback = hasCompleteExportCoverage && !isWorkspaceSingleton && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true && resolvedOptions.hostInitInjectLocation === "entry" && (command === "build" || isConsumedByPeerSingleton);
 	const usesEagerWorkspaceFallback = hasCompleteExportCoverage && isWorkspaceSingleton && !servesRemoteSingletonFallback && (isConsumedByPeerSingleton || shareItem.shareConfig.eager === true);
 	const usesDeferredTreeShakingFallback = hasCompleteExportCoverage && Boolean(treeShakingConsumer);
 	const reactMixedModeGuard = pkg === "react" ? createReactMixedModeRuntimeGuard() : "";
@@ -3244,12 +3458,13 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	}
 	const prebuildImportLine = usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback ? "" : usesDeferredSingletonFallback || usesDeferredTreeShakingFallback ? !servesRemoteSingletonFallback && usesDeferredSingletonFallback && command !== "build" && (isWorkspaceSingleton || isWorkspacePackage) ? `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(lazyLocalFallbackSource)};` : "" : `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(detectedNamedExports === void 0 ? coherentLocalSource : skipServePrebuildWarmup ? devImportSource : sharedImportSource)};`;
 	const devDynamicImportLine = isWorkspacePackage ? "" : usesDeferredSingletonFallback || usesDeferredTreeShakingFallback ? "" : command !== "build" && !skipServePrebuildWarmup ? `;() => import(${escapeGeneratedStringLiteral(devImportSource)}).catch(() => {});` : "";
-	const moduleBody = usesDeferredSingletonFallback || usesDeferredTreeShakingFallback ? `
+	const moduleBody = usesDeferredSingletonFallback || usesDeferredTreeShakingFallback || usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback ? `
     ${prebuildImportLine}
     ${devDynamicImportLine}
     ${importLine}
     ${sharedCacheHelperCode}
     ${normalizeLocalShareModuleCode}
+    ${initializedLocalShareModuleCode}
     ${exportLine}
   ` : `
     ${prebuildImportLine}
@@ -3351,6 +3566,7 @@ function generateLocalSharedImportMap(options) {
 		if (!shareItem?.shareConfig.eager || shareItem.shareConfig.import === false) return "";
 		return `import * as __mfEagerShare_${index} from ${toSafeJsLiteral(getLocalSharedPackagePath(pkg, shareItem, options))};`;
 	}).filter(Boolean).join("\n")}
+    ${normalizeRuntimeShareCode}
     const importMap = {
       ${orderedShares.map((pkg, index) => {
 		const shareItem = getNormalizeShareItem(pkg, resolvedOptions);
@@ -3395,7 +3611,7 @@ function generateLocalSharedImportMap(options) {
               const res = await pkgDynamicImport()
               const exportModule = ${toSafeJsLiteral(useDirectReactImport)} && ${toSafeJsLiteral(key)} === "react"
                 ? (res?.default ?? res)
-                : {...res}
+                : __mfNormalizeRuntimeShare({...res})
               // All npm packages pre-built by vite will be converted to esm
               if (exportModule.__esModule !== true) {
                 Object.defineProperty(exportModule, "__esModule", {
@@ -3511,9 +3727,8 @@ function getMaterializedShares(options) {
 		return priority(a) - priority(b) || a.localeCompare(b);
 	}));
 }
-function getShareBatches(options, materializedOnly = true) {
-	const ordered = materializedOnly ? getMaterializedShares(options) : getOrderedUsedShares(options);
-	const levels = /* @__PURE__ */ new Map();
+/** Shared keys a share's package.json depends on (roots stand in for their subpaths, subpaths for their root), keyed by share. */
+function getSharePrerequisites(ordered) {
 	const roots = /* @__PURE__ */ new Map();
 	const subpaths = /* @__PURE__ */ new Map();
 	for (const pkg of ordered) {
@@ -3521,6 +3736,7 @@ function getShareBatches(options, materializedOnly = true) {
 		if (pkg === packageName) roots.set(packageName, pkg);
 		else subpaths.set(packageName, [...subpaths.get(packageName) ?? [], pkg]);
 	}
+	const prerequisitesByShare = /* @__PURE__ */ new Map();
 	for (const pkg of ordered) {
 		const packageName = getPackageName(pkg);
 		const packageJson = getInstalledPackageJson(pkg)?.packageJson ?? (pkg !== packageName ? getInstalledPackageJson(packageName)?.packageJson : void 0);
@@ -3534,8 +3750,15 @@ function getShareBatches(options, materializedOnly = true) {
 			const root = roots.get(packageName);
 			if (root) prerequisites.push(root);
 		} else if (pkg === packageName && packageName !== "react" && packageName !== "react-dom") prerequisites.push(...subpaths.get(packageName) ?? []);
-		levels.set(pkg, prerequisites.reduce((level, dependency) => Math.max(level, (levels.get(dependency) ?? 0) + 1), 0));
+		prerequisitesByShare.set(pkg, prerequisites);
 	}
+	return prerequisitesByShare;
+}
+function getShareBatches(options, materializedOnly = true) {
+	const ordered = materializedOnly ? getMaterializedShares(options) : getOrderedUsedShares(options);
+	const prerequisitesByShare = getSharePrerequisites(ordered);
+	const levels = /* @__PURE__ */ new Map();
+	for (const pkg of ordered) levels.set(pkg, (prerequisitesByShare.get(pkg) ?? []).reduce((level, dependency) => Math.max(level, (levels.get(dependency) ?? 0) + 1), 0));
 	const batches = [];
 	for (const pkg of ordered) (batches[levels.get(pkg) ?? 0] ??= []).push(pkg);
 	return batches.filter(Boolean);
@@ -3655,8 +3878,16 @@ const sharedProviderSelectionHelperCode = `const __mfOriginalProviderKey = Symbo
             strategy
           ) => {
             if (!versions || !share) return undefined;
+            // import:false stubs provide nothing, so they are never a selectable
+            // provider and must not be satisfy-checked. Skip the runtime entirely
+            // when nothing remains: it treats an empty map as version "0" and
+            // warns that it fails even a "*" requirement.
+            const candidates = Object.fromEntries(
+              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 selectionVersions = __mfCreateProviderSelectionVersions(versions, strategy);
+            const selectionVersions = __mfCreateProviderSelectionVersions(candidates, strategy);
             const shareScopeMap = {};
             for (const scope of scopes) {
               shareScopeMap[scope || "default"] = { [pkg]: selectionVersions };
@@ -3769,9 +4000,14 @@ const externalSharedProviderSelectionHelperCode = `const __mfSelectExternalShare
           };`;
 function generateRuntimeSharedCacheSeedCode(shareStrategy, options) {
 	const seedBatches = getShareBatches(options, false);
+	const seedOrder = seedBatches.flat();
+	const seedIndex = new Map(seedOrder.map((pkg, index) => [pkg, index]));
+	const seedPrerequisites = Object.fromEntries(Array.from(getSharePrerequisites(seedOrder)).filter(([, prerequisites]) => prerequisites.length > 0).map(([pkg, prerequisites]) => [seedIndex.get(pkg), prerequisites.map((prerequisite) => seedIndex.get(prerequisite))]));
 	return `
-    const __mfSeedOrder = ${toSafeJsLiteral(seedBatches.flat())};
+    const __mfSeedOrder = ${toSafeJsLiteral(seedOrder)};
     const __mfSeedBatches = ${toSafeJsLiteral(seedBatches)};
+    const __mfSeedIndex = new Map(__mfSeedOrder.map((pkg, index) => [pkg, index]));
+    const __mfSeedPrerequisites = ${toSafeJsLiteral(seedPrerequisites)};
     // A share is normally skipped here until the dev scanner has observed a real
     // import and set materialize. An import:false share has no local fallback
     // though, so on a cold request (materialize not set yet) it must still be
@@ -3878,15 +4114,30 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy, options) {
         ${toSafeJsLiteral(shareStrategy)}
       ));
     };
-    const __mfFirstRuntimeSeedBarrierIndex = __mfSeedKeys.findIndex(
-      __mfNeedsPreInitSeedBarrier
+    const __mfExpandBlockedSeedKeys = (blocked) => {
+      let changed = true;
+      while (changed) {
+        changed = false;
+        for (const pkg of __mfSeedKeys) {
+          const seedIndex = __mfSeedIndex.get(pkg);
+          if (blocked.has(seedIndex)) continue;
+          if ((__mfSeedPrerequisites[seedIndex] || []).some((dependency) => blocked.has(dependency))) {
+            blocked.add(seedIndex);
+            changed = true;
+          }
+        }
+      }
+      return blocked;
+    };
+    const __mfPreInitBlockedSeedKeys = __mfExpandBlockedSeedKeys(new Set(
+      __mfSeedKeys.filter(__mfNeedsPreInitSeedBarrier).map((pkg) => __mfSeedIndex.get(pkg))
+    ));
+    const __mfImmediateSeedKeys = __mfSeedKeys.filter(
+      (pkg) => !__mfPreInitBlockedSeedKeys.has(__mfSeedIndex.get(pkg))
+    );
+    var __mfDeferredSeedKeys = __mfSeedKeys.filter(
+      (pkg) => __mfPreInitBlockedSeedKeys.has(__mfSeedIndex.get(pkg))
     );
-    const __mfImmediateSeedKeys = __mfFirstRuntimeSeedBarrierIndex === -1
-      ? __mfSeedKeys
-      : __mfSeedKeys.slice(0, __mfFirstRuntimeSeedBarrierIndex);
-    var __mfDeferredSeedKeys = __mfFirstRuntimeSeedBarrierIndex === -1
-      ? []
-      : __mfSeedKeys.slice(__mfFirstRuntimeSeedBarrierIndex);
     await __mfSeedLocalShared(__mfImmediateSeedKeys);`;
 }
 function getBrowserImportPath(importPath) {
@@ -4225,7 +4476,21 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       }
       return runtimeScope;
     };
+    // runtimeInit() lets runtime plugins register providers (public
+    // registerShared) before initShareScopeMap() replaces the runtime's own
+    // scope map. Carry those registrations over; the runtime's own copies of
+    // usedShared keep registering lazily through loadShare().
+    const __mfKeepRegisteredShares = (scopeName, scope) => {
+      for (const [pkg, versions] of Object.entries(initRes.shareScopeMap?.[scopeName] || {})) {
+        for (const [version, provider] of Object.entries(versions || {})) {
+          if (!provider || provider.get === usedShared[pkg]?.get) continue;
+          const target = scope[pkg] ||= {};
+          if (target[version] === undefined) target[version] = provider;
+        }
+      }
+    };
     const __mfGetRuntimeShareScope = (scopeName, hostScope) => {
+      __mfKeepRegisteredShares(scopeName, hostScope);
       const isWebpackScope = !scopeRoot && Object.values(hostScope || {}).some((versions) =>
         Object.values(versions || {}).some(isWebpackProvider)
       );
@@ -4621,6 +4886,9 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
         );
         const providerEntry = __mfFindSharedProviderEntry(versionMap, provider);
         if (!providerEntry) return;
+        if (usedShare.shareConfig?.import === false && __mfMatchesSharedProvider(provider, usedShare)) return;
+        // Another container's consume-only stub has nothing to bridge to: its get() throws by construction.
+        if (provider?.shareConfig?.import === false) return;
         const { version } = providerEntry;
         if (!singleton && version !== usedShare.version) return;
         if (
@@ -4734,6 +5002,9 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
           scopeRootProvider: undefined
         };
         if (usedShare.canLiveRebind === false) return;
+        if (usedShare.shareConfig?.import === false && __mfMatchesSharedProvider(provider, usedShare)) return;
+        // Another container's consume-only stub has nothing to bridge to: its get() throws by construction.
+        if (provider?.shareConfig?.import === 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;
@@ -4900,6 +5171,11 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       ) || share;
       const providerEntry = __mfFindSharedProviderEntry(versionMap, provider);
       if (!providerEntry) return;
+      // A provider registered on this instance through the public registerShared
+      // API carries this container's own name, so tell the own stub apart by its
+      // import:false config rather than by provenance.
+      const __mfIsOwnStub = (candidate) => candidate === share || candidate?.shareConfig?.import === false;
+      if (__mfIsOwnStub(provider)) return;
       const { version } = providerEntry;
       const currentProvider = versionMap?.[version];
       const loadedShare = await __mfLoadPinnedRuntimeShare(
@@ -4909,13 +5185,13 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
         version,
         currentProvider,
         provider,
-        providerEntry.registered && !__mfMatchesSharedProvider(provider, share)
+        providerEntry.registered
       );
       const providerSelection = loadedShare?.selection;
       const actualProvider = loadedShare?.provider;
       const resolved = loadedShare?.resolved;
       if (!providerSelection) return;
-      if (__mfMatchesSharedProvider(actualProvider, share)) return;
+      if (__mfIsOwnStub(actualProvider)) return;
       if (resolved === undefined) return;
       const latestCachedShare = share.treeShaking
         ? __mfReadTreeShakingSharedSelection(__mfModuleCache.share, cacheDescriptor, mfName)
@@ -4950,11 +5226,13 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       }
     };
     // 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.
+    // order. An unresolved provider blocks its consumers, which would otherwise
+    // capture an undefined or provisional singleton; unrelated shares still seed.
     const __mfReadyDeferredSeedKeys = [];
+    const __mfBlockedSeedKeys = new Set();
     for (const pkg of __mfDeferredSeedKeys) {
       const share = usedShared[pkg];
+      const seedIndex = __mfSeedIndex.get(pkg);
       if (__mfIsRuntimeOnlySharePending(pkg)) {
         try {
           if (share.treeShaking) {
@@ -4963,18 +5241,22 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
             await __mfResolveImportFalseShared(pkg, share);
           }
         } catch (err) {
-          // A rejected provider is an unresolved provider: stop here as the comment above
-          // prescribes, instead of escalating to a container-wide init() failure.
+          // A rejected provider is an unresolved provider: block its consumers as the
+          // comment above prescribes, instead of escalating to a container-wide init() failure.
           console.error(
             \`[Module Federation] Failed to resolve runtime-only shared module "\${pkg}"\`,
             err
           );
-          break;
         }
       }
-      if (__mfIsRuntimeOnlySharePending(pkg)) break;
-      __mfReadyDeferredSeedKeys.push(pkg);
+      if (__mfIsRuntimeOnlySharePending(pkg)) {
+        __mfBlockedSeedKeys.add(seedIndex);
+      }
     }
+    __mfExpandBlockedSeedKeys(__mfBlockedSeedKeys);
+    __mfReadyDeferredSeedKeys.push(...__mfDeferredSeedKeys.filter(
+      (pkg) => !__mfBlockedSeedKeys.has(__mfSeedIndex.get(pkg))
+    ));
     await __mfSeedLocalShared(__mfReadyDeferredSeedKeys);
     initResolve(initRes)
     return initRes
@@ -5056,6 +5338,16 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
                 __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined &&
                 __mfReadSharedCacheOwner(__mfModuleCache.share, cacheDescriptor) ${_command === "serve" ? "!== undefined" : `=== ${cacheOwner}`}
               ) 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;
               await runtime.loadShare(pkg, {
                 customShareInfo: { shareConfig: share.shareConfig }
               }).then(async (factory) => {
@@ -5110,6 +5402,71 @@ function getHostAutoInitPath(options) {
 function isOwnedHostAutoInitId(id, options) {
 	return VirtualModule.findById(id) === getHostAutoInitState(options).module;
 }
+/**
+* Build-time list of the loadShare wrappers this container bundles a fallback for, plus a function the host
+* bootstrap calls after the remote preloads: a share still unseeded then (behind an unresolved runtime-only
+* share in init()) has a deferred wrapper that only registers its pending load once evaluated. Importing it
+* here puts that load in front of the bootstrap's pendingShareLoads barrier instead of inside the entry's own
+* import graph, where module-scope reads would see it undefined. Kept out of hostInit so that chunk stays
+* free of wrapper references.
+*/
+const PENDING_SHARES_TAG = "__P_S__";
+const legacyPendingSharesState = {
+	module: new VirtualModule("pendingShares", PENDING_SHARES_TAG),
+	command: "build"
+};
+const pendingSharesStates = /* @__PURE__ */ new WeakMap();
+function getPendingSharesState(options) {
+	if (!options) return legacyPendingSharesState;
+	let state = pendingSharesStates.get(options);
+	if (!state) {
+		state = {
+			module: new VirtualModule("pendingShares", PENDING_SHARES_TAG, "", getLocalOwnerKey(options)),
+			command: "build"
+		};
+		pendingSharesStates.set(options, state);
+	}
+	return state;
+}
+function generatePendingSharesCode(command = "build", options) {
+	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
+	const pendingShareImports = command === "build" ? getMaterializedShares(options).filter((pkg) => {
+		const shareItem = resolvedOptions.shared?.[pkg];
+		return Boolean(shareItem) && !pkg.endsWith("/") && shareItem.shareConfig.import !== false && !shareItem.shareConfig.treeShaking;
+	}).map((pkg) => `[${toSafeJsLiteral(pkg)}, () => import(${toSafeJsLiteral(getLoadShareModulePath(pkg, false, options))})]`) : [];
+	return `
+    ${getRuntimeModuleCacheBootstrapCode()}
+    ${sharedCacheHelperCode}
+    const __mfPendingShareImports = [${pendingShareImports.join(", ")}];
+    export async function preloadPendingShares() {
+      if (__mfPendingShareImports.length === 0) return;
+      const {usedShared} = await import("${getLocalSharedImportMapPath(options)}");
+      await Promise.all(__mfPendingShareImports.map(async ([pkg, load]) => {
+        const share = usedShared[pkg];
+        if (!share || share.materialize === false || share.treeShaking || share.shareConfig?.import === false) return;
+        const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
+        if (__mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined) return;
+        await load().catch((err) => console.warn("[module-federation] shared preload failed:", pkg, err));
+      }));
+    }
+  `;
+}
+function writePendingShares(command = "build", options) {
+	const state = getPendingSharesState(options);
+	state.command = command;
+	state.module.writeSync(generatePendingSharesCode(command, options), true);
+}
+function refreshPendingShares(options) {
+	try {
+		writePendingShares(getPendingSharesState(options).command, options);
+	} catch {}
+}
+function getPendingSharesPath(options) {
+	return getPendingSharesState(options).module.getImportId();
+}
+function isOwnedPendingSharesId(id, options) {
+	return VirtualModule.findById(id) === getPendingSharesState(options).module;
+}
 //#endregion
 //#region src/virtualModules/virtualRemotes.ts
 const cacheRemoteMap = /* @__PURE__ */ new WeakMap();
@@ -5403,11 +5760,7 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
 	const remoteRegistration = getRemoteRegistration(id, resolvedOptions.remotes, options);
 	const registerRemoteCode = isLoadedFirst && remoteRegistration ? `runtime.registerRemotes([${JSON.stringify(remoteRegistration)}]);` : "";
 	const hostAutoInitPath = getHostAutoInitPath(options);
-	const ssrRemotes = Object.entries(resolvedOptions.remotes).map(([name, item]) => ({
-		name: getRuntimeRemoteAlias(name, options),
-		entry: item.entry,
-		type: item.type ?? "module"
-	}));
+	const ssrRemotes = getSsrRuntimeRemotes(resolvedOptions.remotes, options);
 	const browserHostInitCode = `import(${JSON.stringify(hostAutoInitPath)})
         .then((mod) => mod.hostInitPromise)
         .then(initResolve, initReject);`;
@@ -5633,6 +5986,7 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 	let htmlFilePath;
 	let _command;
 	let emitFileId;
+	let pendingSharesEmitId;
 	let viteConfig;
 	let skipHtmlDevFallback = forceClientInjected ?? false;
 	let clientInjected = false;
@@ -5776,12 +6130,15 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
   if (__mfReactServerModuleCache?.pendingShareLoads) {
     await Promise.all(__mfReactServerModuleCache.pendingShareLoads);
   }`;
+		const pendingSharesBlock = waitsForInit && (_command === "build" || viteConfig?.command === "build") ? `
+  const __mfPendingShares = await ${importExpression(options?.pendingSharesSrc ?? getPendingSharesPath(federationOptions))}.catch(() => undefined);
+  if (__mfPendingShares && typeof __mfPendingShares.preloadPendingShares === "function") await __mfPendingShares.preloadPendingShares();` : "";
 		const importCode = `
 (async () => {
   const __mfHostInit = await ${importExpression(initSrc)};
   await __mfHostInit.__tla;
   const { initHost } = __mfHostInit;
-  ${preloadBlock}${sharedPreloadBlock}${pendingShareLoadsAwait}
+  ${preloadBlock}${pendingSharesBlock}${sharedPreloadBlock}${pendingShareLoadsAwait}
 })().then(() => ${entryImportExpression});
 `;
 		return [
@@ -5792,8 +6149,8 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			importCode
 		].join("\n");
 	}
-	function getSystemBootstrapSource(initSrc, entrySrc) {
-		return getBootstrapSource(initSrc, entrySrc, true);
+	function getSystemBootstrapSource(initSrc, entrySrc, pendingSharesSrc) {
+		return getBootstrapSource(initSrc, entrySrc, true, { pendingSharesSrc });
 	}
 	function injectHtml() {
 		return inject === "html" && (htmlFilePath || hasPackageDependency("@sveltejs/kit"));
@@ -5966,6 +6323,10 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			else if (Array.isArray(inputOptions)) entryFiles = inputOptions.filter((input) => !isReactRouterClientRouteInput(String(input))).map(resolveProjectId);
 			else if (typeof inputOptions === "object") entryFiles = Object.values(inputOptions).filter((input) => !isReactRouterClientRouteInput(String(input))).map((input) => resolveProjectId(String(input)));
 			if (entryFiles.length > 0) htmlFilePath = getFirstHtmlEntryFile(entryFiles);
+			if (config.command === "serve" && !htmlFilePath) {
+				const rootIndexHtml = path$1.resolve(config.root, "index.html");
+				if (fs$2.existsSync(rootIndexHtml)) htmlFilePath = rootIndexHtml;
+			}
 			if (htmlFilePath) addHtmlScriptEntries(htmlFilePath);
 		},
 		buildStart() {
@@ -5981,6 +6342,12 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			};
 			if (!hasHash) emitFileOptions.fileName = fileName;
 			emitFileId = this.emitFile(emitFileOptions);
+			if (waitsForInit) pendingSharesEmitId = this.emitFile({
+				name: "pendingShares",
+				type: "chunk",
+				id: getPendingSharesPath(federationOptions),
+				preserveSignature: "strict"
+			});
 			if (htmlFilePath) addHtmlScriptEntries(htmlFilePath);
 		},
 		generateBundle(_options, bundle) {
@@ -5995,6 +6362,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			if (htmlFileNames.length === 0) return;
 			const file = this.getFileName(emitFileId);
 			emittedFileName = file;
+			const pendingSharesFile = pendingSharesEmitId ? this.getFileName(pendingSharesEmitId) : void 0;
 			const lastSlash = file.lastIndexOf("/");
 			bootstrapDir = lastSlash !== -1 ? file.slice(0, lastSlash + 1) : "";
 			const resolvePath = (builtFileName, htmlFileName) => {
@@ -6030,7 +6398,10 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 					rewritten = true;
 					const strippedInit = stripBase(initPath);
 					const strippedEntry = stripBase(entrySrc);
-					const bootstrapSource = getSystemBootstrapSource(bootstrapDir ? rebaseImport(strippedInit, bootstrapDir) : initPath, bootstrapDir ? rebaseImport(strippedEntry, bootstrapDir) : entrySrc);
+					const rebasedInitPath = bootstrapDir ? rebaseImport(strippedInit, bootstrapDir) : initPath;
+					const rebasedEntrySrc = bootstrapDir ? rebaseImport(strippedEntry, bootstrapDir) : entrySrc;
+					const pendingSharesPath = pendingSharesFile ? resolvePath(pendingSharesFile, fileName) : void 0;
+					const bootstrapSource = getSystemBootstrapSource(rebasedInitPath, rebasedEntrySrc, pendingSharesPath && bootstrapDir ? rebaseImport(stripBase(pendingSharesPath), bootstrapDir) : pendingSharesPath);
 					const bootstrapHash = createHash("sha256").update(bootstrapSource).digest("hex").slice(0, 8);
 					const bootstrapFileName = `${bootstrapDir}mf-entry-bootstrap-${bootstrapIndex++}-${bootstrapHash}.js`;
 					const bootstrapRef = this.emitFile({
@@ -6127,7 +6498,12 @@ function checkAliasConflicts(options) {
 			const matchesSharedKey = (aliasEntry, sharedKey) => {
 				const findPattern = aliasEntry.find;
 				if (typeof findPattern === "string") return findPattern === sharedKey || sharedKey.startsWith(findPattern + "/");
-				if (findPattern instanceof RegExp) return findPattern.test(sharedKey);
+				if (findPattern instanceof RegExp) {
+					findPattern.lastIndex = 0;
+					const matched = findPattern.test(sharedKey);
+					findPattern.lastIndex = 0;
+					return matched;
+				}
 				return false;
 			};
 			for (const sharedKey of sharedKeys) for (const aliasEntry of userAliases) {
@@ -6318,6 +6694,21 @@ const vueAdapter = {
 	} }
 };
 //#endregion
+//#region src/utils/devServerHost.ts
+const UNSPECIFIED_HOSTS = /* @__PURE__ */ new Set(["0.0.0.0", "::"]);
+/**
+* Hostname for client-facing HTTP/WS origins built from Vite `server.host`.
+*
+* Unspecified bind addresses (`0.0.0.0`, `::`) map to `localhost`, matching
+* Vite's own printed local URL. IPv6 addresses are wrapped in brackets so
+* `http://[::1]:5173` / `ws://[::1]:5173` parse as valid URLs.
+*/
+function formatDevServerHostForOrigin(host) {
+	if (typeof host !== "string" || UNSPECIFIED_HOSTS.has(host)) return "localhost";
+	if (host.startsWith("[") && host.endsWith("]")) return host;
+	return isIPv6(host) ? `[${host}]` : host;
+}
+//#endregion
 //#region src/plugins/hmr/fullReload.ts
 const REMOTE_HMR_ENDPOINT = "__mf_hmr";
 const REMOTE_HMR_EVENT = "mf:remote-update";
@@ -6343,10 +6734,10 @@ function getHmrWsPath(base, hmrPath) {
 }
 function getRemoteHmrWsUrl(server) {
 	const hmr = server.config.server.hmr;
-	return `${hmr && typeof hmr === "object" && hmr.protocol ? hmr.protocol : server.config.server.https ? "wss" : "ws"}://${hmr && typeof hmr === "object" && hmr.host ? hmr.host : typeof server.config.server.host === "string" && server.config.server.host !== "0.0.0.0" ? server.config.server.host : "localhost"}:${hmr && typeof hmr === "object" && (hmr.clientPort || hmr.port) ? hmr.clientPort || hmr.port : server.config.server.port}${getHmrWsPath(server.config.base, hmr && typeof hmr === "object" ? hmr.path : "")}?token=${server.config.webSocketToken}`;
+	return `${hmr && typeof hmr === "object" && hmr.protocol ? hmr.protocol : server.config.server.https ? "wss" : "ws"}://${formatDevServerHostForOrigin(hmr && typeof hmr === "object" && hmr.host ? hmr.host : server.config.server.host)}:${hmr && typeof hmr === "object" && (hmr.clientPort || hmr.port) ? hmr.clientPort || hmr.port : server.config.server.port}${getHmrWsPath(server.config.base, hmr && typeof hmr === "object" ? hmr.path : "")}?token=${server.config.webSocketToken}`;
 }
 function getLocalFallbackOrigin(server) {
-	return `${server.config.server.https ? "https" : "http"}://${typeof server.config.server.host === "string" && server.config.server.host !== "0.0.0.0" && server.config.server.host !== "::" ? server.config.server.host : "localhost"}:${server.config.server.port || 5173}`;
+	return `${server.config.server.https ? "https" : "http"}://${formatDevServerHostForOrigin(server.config.server.host)}:${server.config.server.port || 5173}`;
 }
 function getRemoteHmrEndpoint(remoteEntry, server) {
 	try {
@@ -6844,11 +7235,7 @@ function pluginExternalRuntimeCore() {
 function initVirtualModules(command, remoteEntryId, enableSsrInit = false, options) {
 	writeLocalSharedImportMap(options);
 	writeHostAutoInit(remoteEntryId, command, options);
-	writeRuntimeInitStatus(command, enableSsrInit, getHostAutoInitPath(options), options, options ? Object.entries(options.remotes).map(([name, item]) => ({
-		name,
-		entry: item.entry,
-		type: item.type ?? "module"
-	})) : void 0);
+	writeRuntimeInitStatus(command, enableSsrInit, getHostAutoInitPath(options), options, options ? getSsrRuntimeRemotes(options.remotes, options) : void 0);
 }
 //#endregion
 //#region src/utils/cssModuleHelpers.ts
@@ -7071,15 +7458,22 @@ const REMOTE_ENTRY_SSR_ID = "virtual:mf-REMOTE_ENTRY_SSR_ID";
 function getRemoteEntrySSRId(options) {
 	return `${REMOTE_ENTRY_SSR_ID}:${getVirtualModuleScopeKey(options)}`;
 }
+function stripSsrFilenameHashPlaceholder(filename) {
+	if (!filename.includes("[hash")) return filename;
+	filename = filename.replace(/(?:[._-]?\[hash(?::\d+)?\])/g, "");
+	if (!/\.[^.]+$/.test(filename)) filename = `${filename}.js`;
+	return filename;
+}
 function getSsrRemoteEntryFileName(browserFilename) {
-	let filename = browserFilename;
-	if (filename.includes("[hash")) {
-		filename = filename.replace(/(?:[._-]?\[hash(?::\d+)?\])/g, "");
-		if (!/\.[^.]+$/.test(filename)) filename = `${filename}.js`;
-	}
+	const filename = stripSsrFilenameHashPlaceholder(browserFilename);
 	const ext = filename.match(/\.[^.]+$/)?.[0] || ".js";
 	return `${filename.slice(0, filename.length - ext.length)}.ssr${ext}`;
 }
+function getSsrExposesFileName(browserFilename) {
+	const filename = stripSsrFilenameHashPlaceholder(browserFilename);
+	const ext = filename.match(/\.[^.]+$/)?.[0];
+	return `${ext ? filename.slice(0, filename.length - ext.length) : filename}.exposes.js`;
+}
 /** Singleton map for SSR loadShare: expand `pkg/` via usedShares; never serialize the prefix. */
 function getSsrSharedSingletons(options) {
 	const used = getUsedShares(options);
@@ -7854,12 +8248,10 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 	}
 	function collectImportSources(code) {
 		const sources = /* @__PURE__ */ new Map();
-		for (const match of code.matchAll(/(?:^|[;\n\r])\s*import\s+(?:[\s\S]*?\s+from\s+)?["']([^"']+)["']|import\(\s*["']([^"']+)["']\s*\)/g)) {
-			const source = match[1] || match[2];
-			if (source) {
-				const dynamic = !match[1];
-				sources.set(source, (sources.get(source) ?? true) && dynamic);
-			}
+		for (const { source, kind, syntax, typeOnly } of findModuleImportDescriptors(code)) {
+			if (syntax !== "import" || typeOnly) continue;
+			const dynamic = kind === "dynamic";
+			sources.set(source, (sources.get(source) ?? true) && dynamic);
 		}
 		return Array.from(sources, ([source, dynamic]) => ({
 			source,
@@ -7876,7 +8268,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		seen.add(id);
 		let code;
 		try {
-			code = readFileSync$1(id, "utf8");
+			code = getScannableModuleSource(id, readFileSync$1(id, "utf8"));
 		} catch {
 			return [];
 		}
@@ -7971,7 +8363,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 				}
 				if (isHostAutoInitId(id)) {
 					if (_command === "serve") {
-						const host = typeof viteConfig.server?.host === "string" && viteConfig.server.host !== "0.0.0.0" ? viteConfig.server.host : "localhost";
+						const host = formatDevServerHostForOrigin(viteConfig.server?.host);
 						const resolvedPublicPath = resolvePublicPath(options, viteConfig.base, originalConfigBase);
 						const devPublicPath = resolvedPublicPath === "auto" ? "/" : resolvedPublicPath;
 						const remoteEntryFileName = resolveDevHashEntryFileName(options.filename);
@@ -8173,54 +8565,6 @@ function isBuildConfigImporter(importer) {
 	if (!importer) return false;
 	return /(^|\/)(?:nuxt|vite|vitest|webpack|rollup|rspack)\.config\.[cm]?[jt]sx?$/.test(importer.replace(/\\/g, "/"));
 }
-function matchesSharedSource(source, key) {
-	const keyBase = key.endsWith("/") ? key.slice(0, -1) : key;
-	if (keyBase === "vue" && (source === "vue/dist/vue.esm-bundler.js" || source === "vue/dist/vue.runtime.esm-bundler.js")) return true;
-	if (key.endsWith("/")) return source === keyBase || source.startsWith(`${keyBase}/`);
-	if (getCommonSharedSubpaths(keyBase).includes(source)) return true;
-	return source === keyBase;
-}
-function findSharedKey(source, shared) {
-	return getSharedKeyMatcher(shared).find(source);
-}
-const emptySharedKeyMatcher = { find: () => void 0 };
-const sharedKeyMatcherCache = /* @__PURE__ */ new WeakMap();
-function getSharedKeyMatcher(shared) {
-	if (!shared) return emptySharedKeyMatcher;
-	const cached = sharedKeyMatcherCache.get(shared);
-	if (cached) return cached;
-	const keys = Object.keys(shared);
-	const exactKeys = new Set(keys);
-	const commonSubpathKeys = /* @__PURE__ */ new Map();
-	const wildcardKeys = [];
-	let vueKey;
-	for (const key of keys) {
-		const keyBase = key.endsWith("/") ? key.slice(0, -1) : key;
-		const shareItem = shared[key];
-		if (!vueKey && keyBase === "vue") vueKey = key;
-		if (key.endsWith("/")) wildcardKeys.push({
-			key,
-			base: keyBase
-		});
-		if (shareItem.shareConfig?.import !== false) {
-			for (const subpath of getCommonSharedSubpaths(keyBase)) if (!commonSubpathKeys.has(subpath)) commonSubpathKeys.set(subpath, key);
-		}
-	}
-	const sourceCache = /* @__PURE__ */ new Map();
-	const matcher = { find(source) {
-		if (sourceCache.has(source)) return sourceCache.get(source);
-		let result = exactKeys.has(source) ? source : void 0;
-		if (!result && vueKey) {
-			if (source === "vue/dist/vue.esm-bundler.js" || source === "vue/dist/vue.runtime.esm-bundler.js") result = vueKey;
-		}
-		if (!result) result = commonSubpathKeys.get(source);
-		if (!result) result = wildcardKeys.find(({ base }) => source === base || source.startsWith(`${base}/`))?.key;
-		sourceCache.set(source, result);
-		return result;
-	} };
-	sharedKeyMatcherCache.set(shared, matcher);
-	return matcher;
-}
 function findSharedKeyForSource(source, shared) {
 	const key = findSharedKey(source, shared);
 	if (key) return key;
@@ -8266,11 +8610,267 @@ function excludeSharedSubDependencies(shared) {
 				delete shared[depKey];
 				sharedKeys.delete(depKey);
 				sharedKeyByBase.delete(dep);
-				sharedKeyMatcherCache.delete(shared);
+				invalidateSharedKeyMatcher(shared);
 			}
 		}
 	}
 }
+const sharedDependencyCache = /* @__PURE__ */ new Map();
+const sharedPackageDirectoryCache = /* @__PURE__ */ new WeakMap();
+function getSharedPackageFromFile(importer, shared, cwd = getPackageDetectionCwd()) {
+	if (!importer) return;
+	const nodeModulePackage = getPackageNameFromNodeModulePath(importer);
+	if (nodeModulePackage) return nodeModulePackage;
+	let cached = sharedPackageDirectoryCache.get(shared);
+	if (!cached || cached.cwd !== cwd) {
+		const entries = /* @__PURE__ */ new Map();
+		for (const key of Object.keys(shared)) {
+			const packageName = getPackageName(key);
+			const entry = getInstalledPackageEntry(packageName, { cwd });
+			if (entry && !isNodeModulePath(entry)) entries.set(path$1.dirname(normalizePathForImport(entry)), packageName);
+		}
+		cached = {
+			cwd,
+			entries
+		};
+		sharedPackageDirectoryCache.set(shared, cached);
+	}
+	const normalizedImporter = normalizePathForImport(importer);
+	return [...cached.entries].find(([dir]) => normalizedImporter === dir || normalizedImporter.startsWith(`${dir}/`))?.[1] ?? getWorkspacePackageNameFromFile(normalizedImporter);
+}
+const workspacePackageNameCache = /* @__PURE__ */ new Map();
+/** Name from the nearest `package.json` above `file`, for files outside `node_modules`. */
+function getWorkspacePackageNameFromFile(file) {
+	const filePath = file.split("?")[0];
+	if (!path$1.isAbsolute(filePath) || isNodeModulePath(filePath)) return;
+	const visited = [];
+	let dir = path$1.dirname(filePath);
+	let name;
+	while (true) {
+		if (workspacePackageNameCache.has(dir)) {
+			name = workspacePackageNameCache.get(dir);
+			break;
+		}
+		visited.push(dir);
+		const manifestPath = path$1.join(dir, "package.json");
+		if (existsSync(manifestPath)) {
+			try {
+				const manifestName = JSON.parse(readFileSync(manifestPath, "utf-8")).name;
+				if (typeof manifestName !== "string") {
+					const parent = path$1.dirname(dir);
+					if (parent === dir) break;
+					dir = parent;
+					continue;
+				}
+				name = manifestName;
+			} catch {
+				name = void 0;
+			}
+			break;
+		}
+		const parent = path$1.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	for (const visitedDir of visited) workspacePackageNameCache.set(visitedDir, name);
+	return name;
+}
+const dependencyManifestCache = /* @__PURE__ */ new Map();
+/**
+* The manifest of `dep` as seen from `fromDir`: a plain `node_modules` walk-up first, because the
+* cycle walk below visits every package in the tree and `getInstalledPackageJson`'s resolver is
+* far too expensive for that many lookups; it stays the fallback for layouts the walk-up misses.
+*/
+function getDependencyManifest(dep, fromDir) {
+	const cacheKey = `${fromDir}\0${dep}`;
+	if (dependencyManifestCache.has(cacheKey)) return dependencyManifestCache.get(cacheKey);
+	let found;
+	let currentDir = fromDir;
+	while (true) {
+		const packageJsonPath = path$1.join(currentDir, "node_modules", dep, "package.json");
+		if (existsSync(packageJsonPath)) {
+			try {
+				let dir = path$1.dirname(packageJsonPath);
+				try {
+					dir = realpathSync(dir);
+				} catch {}
+				found = {
+					path: packageJsonPath,
+					dir,
+					packageJson: JSON.parse(readFileSync(packageJsonPath, "utf-8"))
+				};
+			} catch {}
+			break;
+		}
+		const parentDir = path$1.dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	found ??= getInstalledPackageJson(dep, {
+		cwd: fromDir,
+		packageName: dep
+	});
+	dependencyManifestCache.set(cacheKey, found);
+	return found;
+}
+/** Whether `dependency` is reachable through the shared package's manifest dependencies. */
+function isSharedPackageDependency(sharedKey, dependency) {
+	const sharedPackage = getPackageName(sharedKey);
+	let reachable = sharedDependencyCache.get(sharedPackage);
+	if (!reachable) {
+		reachable = /* @__PURE__ */ new Set();
+		const visited = /* @__PURE__ */ new Set();
+		const queue = [getInstalledPackageJson(sharedPackage, { packageName: sharedPackage })];
+		while (queue.length) {
+			const installed = queue.shift();
+			if (!installed || visited.has(installed.dir)) continue;
+			visited.add(installed.dir);
+			const manifest = installed.packageJson;
+			for (const dep of Object.keys({
+				...manifest.dependencies,
+				...manifest.peerDependencies,
+				...manifest.optionalDependencies
+			})) {
+				reachable.add(dep);
+				queue.push(getDependencyManifest(dep, installed.dir));
+			}
+		}
+		sharedDependencyCache.set(sharedPackage, reachable);
+	}
+	return reachable.has(dependency);
+}
+const sharedRuntimeDependencyCache = /* @__PURE__ */ new Map();
+const SOURCE_FILE_RE = /\.(?:[cm]?js|[cm]?ts|jsx|tsx)$/;
+const NON_RUNTIME_SOURCE_RE = /(?:\.d\.[cm]?ts|\.(?:test|spec|stories)\.[cm]?[jt]sx?)$/;
+const NON_RUNTIME_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	"__tests__",
+	"dist",
+	"build"
+]);
+/** Bundled artifacts of a published package never import workspace packages; skip them instead of scanning megabytes. */
+const MAX_SCANNED_SOURCE_BYTES = 256 * 1024;
+const BARE_PACKAGE_SPECIFIER_RE = /^(?:@[^\s'"`()\/]+\/)?[^\s'"`()\/.@][^\s'"`()\/]*(?:\/[^\s'"`()]*)?$/;
+/** Module specifiers evaluated by a source file. */
+function getRuntimeModuleSpecifiers(code) {
+	return findModuleImportDescriptors(code).filter(({ typeOnly }) => !typeOnly).map(({ source }) => source);
+}
+/** Bare specifiers a source file imports at runtime. */
+function getRuntimeImportSpecifiers(code) {
+	return getRuntimeModuleSpecifiers(code).filter((specifier) => BARE_PACKAGE_SPECIFIER_RE.test(specifier) && !isBuiltin(specifier));
+}
+function collectAllRuntimeImports(dir, into) {
+	let entries;
+	try {
+		entries = readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if (entry.isDirectory()) {
+			if (!NON_RUNTIME_DIRS.has(entry.name)) collectAllRuntimeImports(path$1.join(dir, entry.name), into);
+			continue;
+		}
+		if (!SOURCE_FILE_RE.test(entry.name) || NON_RUNTIME_SOURCE_RE.test(entry.name)) continue;
+		const file = path$1.join(dir, entry.name);
+		let code;
+		try {
+			if (statSync(file).size > MAX_SCANNED_SOURCE_BYTES) continue;
+			code = readFileSync(file, "utf-8");
+		} catch {
+			continue;
+		}
+		for (const specifier of getRuntimeImportSpecifiers(code)) into.add(specifier);
+	}
+}
+const SOURCE_EXTENSIONS = [
+	"",
+	".js",
+	".mjs",
+	".cjs",
+	".ts",
+	".mts",
+	".cts",
+	".jsx",
+	".tsx"
+];
+function resolveLocalRuntimeImport(importer, specifier) {
+	if (!specifier.startsWith(".")) return;
+	const resolved = path$1.resolve(path$1.dirname(importer), specifier);
+	return SOURCE_EXTENSIONS.flatMap((extension) => [`${resolved}${extension}`, path$1.join(resolved, `index${extension}`)]).find((candidate) => existsSync(candidate));
+}
+function collectReachableRuntimeImports(entry, dir, into) {
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [entry];
+	let scanned = false;
+	while (queue.length) {
+		const file = queue.shift();
+		const relative = path$1.relative(dir, file);
+		if (relative.startsWith("..") || path$1.isAbsolute(relative) || visited.has(file)) continue;
+		visited.add(file);
+		let code;
+		try {
+			if (statSync(file).size > MAX_SCANNED_SOURCE_BYTES) continue;
+			code = readFileSync(file, "utf-8");
+			scanned = true;
+		} catch {
+			continue;
+		}
+		for (const specifier of getRuntimeModuleSpecifiers(code)) {
+			if (BARE_PACKAGE_SPECIFIER_RE.test(specifier) && !isBuiltin(specifier)) {
+				into.add(specifier);
+				continue;
+			}
+			const local = resolveLocalRuntimeImport(file, specifier);
+			if (local) queue.push(local);
+		}
+	}
+	return scanned;
+}
+/**
+* Whether `dependency` is reachable from the shared package through the imports its source files
+* (and those of the workspace packages they pull in) actually evaluate. Unlike the manifest walk
+* above this ignores `import type` edges and stops at `node_modules` boundaries, so it approximates
+* the fallback's evaluation graph rather than the package's declared closure — in a monorepo the
+* latter covers far more than the module graph ever does.
+*/
+function isSharedPackageRuntimeDependency(sharedKey, dependency) {
+	const sharedPackage = getPackageName(sharedKey);
+	let reachable = sharedRuntimeDependencyCache.get(sharedKey);
+	if (!reachable) {
+		reachable = /* @__PURE__ */ new Set();
+		const visited = /* @__PURE__ */ new Set();
+		const queue = [{
+			request: sharedKey,
+			installed: getInstalledPackageJson(sharedPackage, { packageName: sharedPackage })
+		}];
+		while (queue.length) {
+			const { request, installed } = queue.shift();
+			if (!installed) continue;
+			const visitKey = `${installed.dir}\0${request}`;
+			if (visited.has(visitKey)) continue;
+			visited.add(visitKey);
+			const specifiers = /* @__PURE__ */ new Set();
+			const entry = getInstalledPackageEntry(request, {
+				cwd: installed.dir,
+				packageName: getPackageName(request)
+			});
+			if (!entry || !collectReachableRuntimeImports(entry, installed.dir, specifiers)) collectAllRuntimeImports(installed.dir, specifiers);
+			for (const specifier of specifiers) {
+				const dep = getPackageName(specifier);
+				if (dep === sharedPackage) continue;
+				reachable.add(dep);
+				const manifest = getDependencyManifest(dep, installed.dir);
+				if (manifest && !isNodeModulePath(manifest.dir)) queue.push({
+					request: specifier,
+					installed: manifest
+				});
+			}
+		}
+		sharedRuntimeDependencyCache.set(sharedKey, reachable);
+	}
+	return reachable.has(dependency);
+}
 function proxySharedModule(options) {
 	const { shared = {}, federationOptions, getParsePromise = () => Promise.resolve() } = options;
 	let _config;
@@ -8352,6 +8952,10 @@ function proxySharedModule(options) {
 				setTreeShakingBuildMode(command === "build", federationOptions);
 				resetTreeShakingExports(federationOptions);
 				emittedTreeShakingProviders.clear();
+				sharedDependencyCache.clear();
+				dependencyManifestCache.clear();
+				sharedRuntimeDependencyCache.clear();
+				workspacePackageNameCache.clear();
 				const isVinext = hasPackageDependency("vinext");
 				const isAstro = hasPackageDependency("astro");
 				const isRolldown = getIsRolldown(this);
@@ -8440,6 +9044,11 @@ function proxySharedModule(options) {
 				}
 				const key = findSharedKeyForSource(source, shared);
 				if (!key) return;
+				const importerPackage = getSharedPackageFromFile(importer, shared);
+				if (importerPackage === getPackageName(key)) return;
+				if (importerPackage) {
+					if (!isNodeModulePath(importer) && !Object.keys(shared).some((sharedKey) => getPackageName(sharedKey) === importerPackage) ? isSharedPackageRuntimeDependency(key, importerPackage) : isSharedPackageDependency(key, importerPackage)) return;
+				}
 				if (useDirectReactImport && key === "react") return;
 				if (isAssetLikeImport(source)) return;
 				if (isBuildConfigImporter(importer)) return;
@@ -8905,6 +9514,7 @@ function pluginSSRRemoteEntry(options) {
 	const virtualExposesSSRId = getVirtualExposesSSRId(options);
 	let cachedSsrRemoteEntrySource;
 	const ssrOutputFilename = getSsrRemoteEntryFileName(options.filename);
+	const ssrExposesFileName = getSsrExposesFileName(options.filename);
 	let ssrOutputFiles = /* @__PURE__ */ new Set();
 	let ssrOutputDir = "";
 	let clientOutputDir = "";
@@ -9032,13 +9642,13 @@ function pluginSSRRemoteEntry(options) {
 			});
 			const ssrPath = `${base}/${ssrEntryFileName}`;
 			server.middlewares.use(ssrPath, (_req, res) => {
-				const exposesUrl = `${base}/${options.filename.replace(/\.[^.]+$/, "")}.exposes.js`;
+				const exposesUrl = `${base}/${ssrExposesFileName}`;
 				const code = getSsrRemoteEntrySource().replace(JSON.stringify(virtualExposesSSRId), JSON.stringify(exposesUrl));
 				res.setHeader("Content-Type", "application/javascript");
 				res.setHeader("Access-Control-Allow-Origin", "*");
 				res.end(code);
 			});
-			const exposesPath = `${base}/${options.filename.replace(/\.[^.]+$/, "")}.exposes.js`;
+			const exposesPath = `${base}/${ssrExposesFileName}`;
 			server.middlewares.use(exposesPath, (_req, res) => {
 				res.setHeader("Content-Type", "application/javascript");
 				res.setHeader("Access-Control-Allow-Origin", "*");
@@ -9049,7 +9659,7 @@ function pluginSSRRemoteEntry(options) {
 			if (id === remoteEntrySSRId || id.startsWith(remoteEntrySSRId)) return id;
 			if (id === virtualExposesSSRId || id.startsWith(virtualExposesSSRId)) return id;
 			if (id === `/__mf_ssr__/${getSsrRemoteEntryFileName(options.filename)}`) return remoteEntrySSRId;
-			if (id === `/__mf_ssr__/${options.filename.replace(/\.[^.]+$/, "")}.exposes.js`) return virtualExposesSSRId;
+			if (id === `/__mf_ssr__/${ssrExposesFileName}`) return virtualExposesSSRId;
 		},
 		load(id) {
 			if (id === remoteEntrySSRId || id.startsWith(remoteEntrySSRId)) return getSsrRemoteEntrySource();
@@ -9583,6 +10193,22 @@ function isFile(candidate) {
 function isReactRouterBuildClientRouteInput(entry) {
 	return /[?&]__react-router-build-client-route(?:[=&]|$)/.test(entry);
 }
+/**
+* Files whose JSX the compiler rewrites to an automatic-runtime import.
+* Vite only applies the JSX transform to these extensions by default.
+*/
+const JSX_SOURCE_EXTENSIONS = [".jsx", ".tsx"];
+function getAutomaticJsxRuntime(config) {
+	for (const candidate of [config.oxc, config.esbuild]) {
+		if (!candidate || typeof candidate !== "object") continue;
+		const transform = candidate;
+		const jsx = transform.jsx;
+		const runtime = typeof jsx === "object" ? jsx.runtime : jsx;
+		if (runtime && runtime !== "automatic") return void 0;
+		if (runtime !== "automatic") continue;
+		return `${(typeof jsx === "object" ? jsx.importSource : void 0) ?? transform.jsxImportSource ?? "react"}/${(typeof jsx === "object" ? jsx.development : void 0) ?? transform.jsxDev ?? true ? "jsx-dev-runtime" : "jsx-runtime"}`;
+	}
+}
 function registerEntryImports(options, projectRoot, recordShared = true, entryFiles = []) {
 	const sourceExtensions = [
 		".mjs",
@@ -9597,6 +10223,7 @@ function registerEntryImports(options, projectRoot, recordShared = true, entryFi
 	const root = path$1.resolve(projectRoot);
 	const pending = [];
 	const visited = /* @__PURE__ */ new Map();
+	let hasJsxSource = false;
 	const enqueue = (request, importer = path$1.join(root, "index.html"), preloadRemotes = false) => {
 		const cleanRequest = request.replace(/[?#].*$/, "");
 		if (!cleanRequest.startsWith(".") && !cleanRequest.startsWith("/") && !path$1.isAbsolute(cleanRequest)) return;
@@ -9628,7 +10255,8 @@ function registerEntryImports(options, projectRoot, recordShared = true, entryFi
 		const { file, preloadRemotes } = pending.pop();
 		if (visited.get(file) || visited.has(file) && !preloadRemotes) continue;
 		visited.set(file, preloadRemotes);
-		const code = readFileSync(file, "utf8");
+		const code = getScannableModuleSource(file, readFileSync(file, "utf8"));
+		if (JSX_SOURCE_EXTENSIONS.some((extension) => file.endsWith(extension))) hasJsxSource = true;
 		for (const { source: request, kind, typeOnly } of findModuleImportDescriptors(code)) {
 			const isStatic = kind === "static" && !typeOnly;
 			const remoteKey = preloadRemotes && isStatic && request ? Object.keys(options.remotes).find((name) => request === name || request.startsWith(`${name}/`)) : void 0;
@@ -9641,6 +10269,14 @@ function registerEntryImports(options, projectRoot, recordShared = true, entryFi
 			else if (request && !typeOnly) enqueue(request, file, preloadRemotes && isStatic);
 		}
 	}
+	return hasJsxSource;
+}
+function materializeAutomaticJsxRuntime(options, runtime) {
+	if (!findSharedKey(runtime, options.shared)) return false;
+	addUsedShares(runtime, options);
+	const packageName = getPackageName(runtime);
+	if (packageName !== runtime && findSharedKey(packageName, options.shared)) addUsedShares(packageName, options);
+	return true;
 }
 /**
 * Plugin that runs FIRST to register generated virtual modules in the config hook.
@@ -9650,6 +10286,7 @@ function registerEntryImports(options, projectRoot, recordShared = true, entryFi
 function createEarlyVirtualModulesPlugin(options) {
 	const { shared, remotes } = options;
 	const isLitShare = (pkg) => pkg === "lit" || pkg.startsWith("lit/");
+	let hasClientJsxSource = false;
 	return {
 		name: "vite:module-federation-early-init",
 		enforce: "pre",
@@ -9672,7 +10309,10 @@ function createEarlyVirtualModulesPlugin(options) {
 					config.optimizeDeps.exclude.push(...Object.keys(remotes || {}));
 				}
 			}
-			if (!config.build?.ssr && (Object.keys(shared ?? {}).length > 0 || Object.keys(remotes ?? {}).length > 0)) registerEntryImports(options, root, _command === "serve", resolvedConfiguredEntryFiles);
+			if (!config.build?.ssr && (Object.keys(shared ?? {}).length > 0 || Object.keys(remotes ?? {}).length > 0)) {
+				const hasJsxSource = registerEntryImports(options, root, _command === "serve", resolvedConfiguredEntryFiles);
+				if (_command === "serve") hasClientJsxSource = hasJsxSource;
+			}
 			if (shared && Object.keys(shared).length > 0) {
 				if (_command === "serve") {
 					excludeSharedSubDependencies(shared);
@@ -9700,6 +10340,8 @@ function createEarlyVirtualModulesPlugin(options) {
 								if (isSharedResolverInternalImporter(importer)) return;
 								const key = findSharedKey(source, shared);
 								if (!key) return;
+								const importerPackage = getSharedPackageFromFile(importer, shared, root);
+								if (!isReactDomSelfReference(source, importer) && (importerPackage === getPackageName(key) || importerPackage && isSharedPackageDependency(key, importerPackage))) return;
 								if (isAssetLikeImport(source)) return;
 								const shareItem = shared[key];
 								const isReactSingleton = source === "react" && key === "react" && shareItem.shareConfig?.singleton === true;
@@ -9738,7 +10380,9 @@ function createEarlyVirtualModulesPlugin(options) {
 									if (isSharedResolverInternalImporter(args.importer)) return;
 									const key = findSharedKey(args.path, shared);
 									if (!key || isAssetLikeImport(args.path)) return;
-									if (getPackageNameFromNodeModulePath(args.importer) === getPackageName(args.path) && !isReactDomSelfReference(args.path, args.importer)) return;
+									const importerPackage = getSharedPackageFromFile(args.importer, shared, root);
+									if (importerPackage === getPackageName(args.path) && !isReactDomSelfReference(args.path, args.importer)) return;
+									if (importerPackage && isSharedPackageDependency(key, importerPackage)) return;
 									addUsedShares(args.path, options);
 									if (args.kind === "import-statement" || args.kind === "dynamic-import") {
 										const shareItem = shared[key];
@@ -9838,6 +10482,10 @@ export default __mfShared.default ?? __mfShared;`
 			}
 		},
 		configResolved(config) {
+			if (hasClientJsxSource) {
+				const automaticJsxRuntime = getAutomaticJsxRuntime(config);
+				if (automaticJsxRuntime && materializeAutomaticJsxRuntime(options, automaticJsxRuntime)) writeLocalSharedImportMap(options);
+			}
 			const viteMajor = parseInt(version, 10);
 			const hasRemotes = Object.keys(options.remotes).length > 0;
 			if (!getSsrCapabilities(viteMajor, config.command, hasRemotes).injectSsrEntryLoader) return;
@@ -9883,7 +10531,7 @@ function applyBuildTimeRuntimeDefines(define, options, { target, isAstro, defaul
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-sJeW2nss.js").then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-BhONN9dR.js").then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {
@@ -9924,7 +10572,7 @@ function federation(mfUserOptions) {
 	const virtualExposesId = getVirtualExposesId(options);
 	const moduleParseController = createModuleParseController();
 	const moduleParsePlugins = pluginModuleParseEnd_default((id) => {
-		return id.includes(getHostAutoInitPath(options)) || id.includes(remoteEntryId) || id.includes(virtualExposesId) || id.includes("virtual:mf-localSharedImportMap") || id.includes("__loadShare__") || id.includes("__prebuild__") || id.includes("__treeShakingProvider__") || id.includes("__mf_tree_shaking_graph__");
+		return id.includes(getHostAutoInitPath(options)) || id.includes(getPendingSharesPath(options)) || id.includes(remoteEntryId) || id.includes(virtualExposesId) || id.includes("virtual:mf-localSharedImportMap") || id.includes("__loadShare__") || id.includes("__prebuild__") || id.includes("__treeShakingProvider__") || id.includes("__mf_tree_shaking_graph__");
 	}, {
 		moduleParseTimeout: options.moduleParseTimeout,
 		moduleParseIdleTimeout: options.moduleParseIdleTimeout,
@@ -10026,6 +10674,7 @@ function federation(mfUserOptions) {
 				}
 				if (id.includes("__prebuild__") && refreshPreBuildModuleForEnvironment(id, this, loadOptions) === "not-owned") return;
 				if (id.includes("__H_A_I__") && isOwnedHostAutoInitId(id, options)) refreshHostAutoInit(options, getLoadHookExportConditions(this, loadOptions));
+				if (id.includes("__P_S__") && isOwnedPendingSharesId(id, options)) refreshPendingShares(options);
 				const virtualModule = VirtualModule.findById(id);
 				if (!virtualModule) return;
 				if (command === "build" && (id.includes("__loadShare__") || id.includes("__loadRemote__"))) return;