@module-federation/vite 1.23.4 → 1.23.6

package/lib/index.js

@@ -1,6 +1,6 @@
-import { _ as resolvePublicPath, a as matchesSharedSource, c as filterId, d as getNodeModulesSuffix, f as isAssetLikeImport, g as normalizeNodeModulePath, h as isViteOptimizableEntry, i as invalidateSharedKeyMatcher, l as getBasePath$1, m as isNuxtClientBase, n as getSharedRequest, p as isNodeModulePath, r as getSharedRuntimeKey, s as ensureTrailingSlash, t as findSharedKey, u as getCommonSharedSubpaths, v as stripQueryAndHash, y as stripViteFsPrefix } from "./sharedKeyMatcher-Od_nYxJA.js";
-import { a as CodeRewriter, c as isAbsoluteUrl, d as resolveHashPlaceholderFileName, i as createCodePositionMap, l as normalizePathForImport, o as createSourceMap, r as mfWarn, t as createModuleFederationError, u as rebaseImport } from "./logger-DOwfTlw5.js";
-import { C as isReactCoreShare, S as REACT_DOM_CLIENT_SHARE, _ as resolveModulePath, a as getIsRolldown, b as supportsCodeSplittingGroupDebugName, c as getPackageNameFromNodeModulePath, d as isNuxtProjectRoot, f as isPackageExportAvailable, g as resolveImportPath, h as packageNameEncode, i as getInstalledPackageJson, l as getSharedCacheDescriptor, m as packageNameDecode, n as getDependencyNames, o as getPackageDetectionCwd, p as isPackageInstalled, r as getInstalledPackageEntry, s as getPackageName, u as hasPackageDependency, v as setPackageDetectionCwd, x as REACT_CLIENT_INTERNALS_KEY, y as sharedCacheHelperCode } from "./dtsConstants-DSTzyKSG.js";
+import { a as CodeRewriter, c as isAbsoluteUrl, d as rebaseImport, f as resolveHashPlaceholderFileName, i as createCodePositionMap, l as isHttpUrl, o as createSourceMap, r as mfWarn, t as createModuleFederationError, u as normalizePathForImport } from "./logger-D67aJYOe.js";
+import { _ as removeTrailingSlash, a as matchesSharedSource, b as stripViteFsPrefix, c as filterId, d as getNodeModulesSuffix, f as isAssetLikeImport, g as normalizeNodeModulePath, h as isViteOptimizableEntry, i as invalidateSharedKeyMatcher, l as getBasePath$1, m as isNuxtClientBase, n as getSharedRequest, p as isNodeModulePath, r as getSharedRuntimeKey, s as ensureTrailingSlash, t as findSharedKey, u as getCommonSharedSubpaths, v as resolvePublicPath, x as toRelativeImport, y as stripQueryAndHash } from "./sharedKeyMatcher-C04bVN1q.js";
+import { C as supportsCodeSplittingGroupDebugName, E as isReactCoreShare, S as sharedCacheHelperCode, T as REACT_DOM_CLIENT_SHARE, _ as packageNameDecode, a as getInstalledPackageEntry, b as resolveModulePath, c as getPackageDetectionCwd, d as getPackageNameFromNodeModulePath, f as getSharedCacheDescriptor, g as isPackageInstalled, h as isPackageExportAvailable, i as getDependencyNames, l as getPackageExportSpecifiersForFile, m as isNuxtProjectRoot, n as formatDevServerHostForOrigin, o as getInstalledPackageJson, p as hasPackageDependency, r as watchFileEvents, s as getIsRolldown, u as getPackageName, v as packageNameEncode, w as REACT_CLIENT_INTERNALS_KEY, x as setPackageDetectionCwd, y as resolveImportPath } from "./dtsConstants-CDuC8Bb7.js";
 import { createRequire } from "node:module";
 import * as fs$2 from "fs";
 import { existsSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "fs";
@@ -14,7 +14,6 @@ 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";
 import { inferAutoPublicPath } from "@module-federation/sdk";
 import { readFile } from "node:fs/promises";
 //#region src/utils/regexEscape.ts
@@ -259,8 +258,8 @@ function getPluginEnvironmentName(ctx) {
 /**
 * Classify a plugin hook context's Vite environment. Environment names are
 * user-defined, so Vite's `config.consumer` is the semantic role; fall back to
-* the name only when it is missing (Vite 5–7). Returns `undefined` when the hook
-* has no environment context at all.
+* the name only when it is missing. Returns `undefined` when the hook has no
+* environment context at all (Vite 5).
 */
 function resolveEnvironmentConsumerTarget(ctx) {
 	if (ctx == null || typeof ctx !== "object") return void 0;
@@ -271,7 +270,7 @@ function resolveEnvironmentConsumerTarget(ctx) {
 	const envName = getPluginEnvironmentName(ctx);
 	return !envName || envName === "client" ? "client" : "server";
 }
-/** Vite 5–7 hooks have no environment context and keep their client build behavior. */
+/** Hooks without an environment context (Vite 5) keep their client build behavior. */
 function isClientEnvironment(ctx) {
 	return resolveEnvironmentConsumerTarget(ctx) !== "server";
 }
@@ -721,6 +720,11 @@ function normalizeLibrary(library) {
 	if (!library) return void 0;
 	return library;
 }
+/** An explicit `manifest.disableAssetsAnalyze` wins; otherwise `fallback` applies. */
+function resolveDisableAssetsAnalyze(manifest, fallback) {
+	if (typeof manifest === "object" && manifest !== null && Object.hasOwn(manifest, "disableAssetsAnalyze")) return manifest.disableAssetsAnalyze === true;
+	return fallback;
+}
 function normalizeManifest(manifest) {
 	if (manifest === void 0) return;
 	if (typeof manifest === "boolean") return manifest;
@@ -977,6 +981,16 @@ function getSsrCapabilities(viteMajor, command, hasRemotes, isSsr = false) {
 	};
 }
 //#endregion
+//#region src/utils/runtimePluginSpecifier.ts
+function getRuntimePluginSpecifier(plugin) {
+	return typeof plugin === "string" ? plugin : plugin[0];
+}
+/** Drop SSR-only plugins from a client graph; a server graph keeps them all. */
+function filterRuntimePluginsForTarget(runtimePlugins, ssrOnlySpecifiers, isServer) {
+	if (isServer) return [...runtimePlugins];
+	return runtimePlugins.filter((plugin) => !ssrOnlySpecifiers.has(getRuntimePluginSpecifier(plugin)));
+}
+//#endregion
 //#region src/utils/serializeRuntimeOptions.ts
 const UNSAFE_JS_CHAR_MAP = {
 	"<": "\\u003C",
@@ -1074,16 +1088,6 @@ function isParsableExpression(source) {
 	}
 }
 //#endregion
-//#region src/utils/runtimePluginSpecifier.ts
-function getRuntimePluginSpecifier(plugin) {
-	return typeof plugin === "string" ? plugin : plugin[0];
-}
-/** Drop SSR-only plugins from a client graph; a server graph keeps them all. */
-function filterRuntimePluginsForTarget(runtimePlugins, ssrOnlySpecifiers, isServer) {
-	if (isServer) return [...runtimePlugins];
-	return runtimePlugins.filter((plugin) => !ssrOnlySpecifiers.has(getRuntimePluginSpecifier(plugin)));
-}
-//#endregion
 //#region src/utils/importAnalysis.ts
 const analysisByBuild = /* @__PURE__ */ new WeakMap();
 /**
@@ -1233,7 +1237,62 @@ function collectReExport(node, source, record, requireAllExports) {
 	}
 	record(names, source);
 }
+const NEEDS_AST_RE = /\brequire\s*(?:\?\.\s*)?(?:\(|\/[*/])|\bexport(?:\s|\/\*[^*]*\*+(?:[^/*][^*]*\*+)*\/|\/\/[^\n]*\n)*\{(?:\s|\/\*[^*]*\*+(?:[^/*][^*]*\*+)*\/|\/\/[^\n]*\n)*\}/;
+/**
+* Vite 8 parses with oxc, whose module record lists static imports, re-exports
+* and dynamic imports without materializing the AST. Same result as the AST
+* walk below; `undefined` when this input needs the AST.
+*/
+function analyzeImportsFromModuleRecord(code) {
+	const parseSync = vite.parseSync;
+	if (typeof parseSync !== "function" || NEEDS_AST_RE.test(code)) return void 0;
+	const result = parseSync("file.js", code, {
+		lang: "js",
+		preserveParens: false
+	});
+	if (result.errors.length > 0) return null;
+	const { staticImports, staticExports, dynamicImports } = result.module;
+	const found = [];
+	const isStringName = (name) => name.start !== null && (code[name.start] === "\"" || code[name.start] === "'");
+	const add = (start, source, names) => found.push({
+		start,
+		usage: {
+			source,
+			usedExports: names
+		}
+	});
+	for (const declaration of staticImports) {
+		const source = declaration.moduleRequest.value;
+		let names = declaration.entries.length === 0 ? null : [];
+		for (const { importName } of declaration.entries) if (importName.kind === "Default") names?.push("default");
+		else if (importName.kind === "Name" && importName.name && !isStringName(importName)) names?.push(importName.name);
+		else names = null;
+		add(declaration.start, source, names);
+	}
+	const importStarts = new Set(staticImports.map((declaration) => declaration.start));
+	for (const declaration of staticExports) {
+		const request = declaration.entries[0]?.moduleRequest;
+		if (!request || importStarts.has(declaration.start)) continue;
+		const source = request.value;
+		let names = [];
+		for (const { importName } of declaration.entries) if (importName.kind === "Name" && importName.name && !isStringName(importName)) names?.push(importName.name);
+		else names = null;
+		add(declaration.start, source, names);
+	}
+	const dynamicStarts = /* @__PURE__ */ new Set();
+	for (const { start, moduleRequest } of dynamicImports) {
+		if (dynamicStarts.has(start)) continue;
+		dynamicStarts.add(start);
+		const text = code.slice(moduleRequest.start, moduleRequest.end);
+		const quote = text[0];
+		if (text.length >= 2 && (quote === "\"" || quote === "'" || quote === "`") && text.at(-1) === quote && !text.includes("\\") && !text.slice(1, -1).includes(quote) && !(quote === "`" && text.includes("${"))) add(start, text.slice(1, -1), null);
+		else if (text.includes("\\")) return;
+	}
+	return found.sort((a, b) => a.start - b.start).map(({ usage }) => usage);
+}
 function analyzeImports(code) {
+	const fromModuleRecord = analyzeImportsFromModuleRecord(code);
+	if (fromModuleRecord !== void 0) return fromModuleRecord;
 	let ast;
 	try {
 		ast = vite.parseAst(code);
@@ -1299,13 +1358,8 @@ function analyzeImports(code) {
 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 = {
@@ -1358,7 +1412,7 @@ function getExportRecords(sharedKey, request, options) {
 	inferredUsage.forEach((byRequest, configuredKey) => {
 		const wildcard = byRequest.get("*");
 		const exact = byRequest.get(request);
-		const configuredRequest = getSharedRequest(configuredKey, options?.shared?.[configuredKey]);
+		const configuredRequest = getSharedRequest(configuredKey, options.shared?.[configuredKey]);
 		const keyBase = configuredRequest.endsWith("/") ? configuredRequest.slice(0, -1) : configuredRequest;
 		const requestMatchesConfiguredKey = request === keyBase || request.startsWith(`${keyBase}/`);
 		if (wildcard && requestMatchesConfiguredKey) records.push(wildcard);
@@ -1772,7 +1826,10 @@ function generateExposes(options, remoteDependencyMap = {}, command = "build", r
             link.rel = "stylesheet";
             link.href = href;
             link.onload = () => resolve();
-            link.onerror = () => reject(new Error(\`[Module Federation] Failed to load CSS asset: \${href}\`));
+            link.onerror = () => {
+              injectedCssHrefs.delete(href);
+              reject(new Error(\`[Module Federation] Failed to load CSS asset: \${href}\`));
+            };
             document.head.appendChild(link);
           });
         })
@@ -2034,24 +2091,6 @@ ${exportStatement}
 `);
 }
 //#endregion
-//#region src/plugins/pluginReactMixedModeGuard.ts
-function createReactMixedModeRuntimeGuard() {
-	return `const __mfReactInternals = mod[${JSON.stringify(REACT_CLIENT_INTERNALS_KEY)}];
-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
 function getTypeArgumentStartContext(source, start) {
 	let previous = start - 1;
@@ -2220,6 +2259,9 @@ function escapeGeneratedStringLiteral(value) {
 		}
 	});
 }
+function getDefaultOrNamespaceExpression(namespace) {
+	return `Reflect.get(${namespace}, "default") ?? ${namespace}`;
+}
 function getSharedCacheDescriptorLiteral(pkg, shareItem) {
 	return JSON.stringify(getSharedCacheDescriptor(pkg, shareItem));
 }
@@ -2281,8 +2323,37 @@ function hasCodeMatch(source, regex, codePositions) {
 	while ((match = regex.exec(source)) !== null) if (codePositions[match.index]) return true;
 	return false;
 }
+/**
+* True when the file contains a top-level static `import`/`export` declaration.
+* Local identifiers named `module` or `exports` (webpack/rspack helpers,
+* function parameters, etc.) must not override that module format.
+*/
+function hasEsmModuleSyntax(source, codePositions) {
+	const keywordRegex = /(?<![$\w])(?:import|export)\b/g;
+	let match;
+	let braceDepth = 0;
+	let braceScanIndex = 0;
+	while ((match = keywordRegex.exec(source)) !== null) {
+		for (; braceScanIndex < match.index; braceScanIndex++) {
+			if (!codePositions[braceScanIndex]) continue;
+			if (source[braceScanIndex] === "{") braceDepth++;
+			else if (source[braceScanIndex] === "}") braceDepth--;
+		}
+		if (!codePositions[match.index]) continue;
+		if (braceDepth !== 0) continue;
+		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;
+		return true;
+	}
+	return false;
+}
 function hasCommonJsExports(source) {
 	const codePositions = createCodePositionMap(source);
+	if (hasEsmModuleSyntax(source, codePositions)) return false;
 	if (hasCodeMatch(source, /\bmodule\s*(?:\.exports|\[\s*['"]exports['"]\s*\])/g, codePositions)) return true;
 	const exportsRegex = /\bexports\s*(?:\.|\[|[,)]|=(?!=|>))/g;
 	let match;
@@ -2455,160 +2526,59 @@ function resolveReExportModule(filePath, specifier, exportConditions) {
 		return;
 	}
 }
-/** Marks a template-literal frame whose text (not its interpolation) is being scanned. */
-const TEMPLATE_TEXT = Symbol("templateText");
 function getAdditionalTopLevelDeclaratorNames(source, start, codePositions) {
 	const names = [];
 	let depth = 0;
-	let quote;
-	let escaped = false;
-	let canStartRegex = true;
-	const templateFrames = [];
-	const inTemplateText = () => templateFrames[templateFrames.length - 1] === TEMPLATE_TEXT;
 	for (let index = start; index < source.length; index++) {
 		const char = source[index];
-		if (inTemplateText()) {
-			if (escaped) escaped = false;
-			else if (char === "\\") escaped = true;
-			else if (char === "$" && source[index + 1] === "{") {
-				templateFrames.push(depth);
-				index++;
-				canStartRegex = true;
-			} else if (char === "`") {
-				templateFrames.pop();
-				canStartRegex = false;
-			}
-			continue;
-		}
-		if (quote) {
-			if (escaped) escaped = false;
-			else if (char === "\\") escaped = true;
-			else if (char === quote) quote = void 0;
-			continue;
-		}
-		if (char === "`") {
-			templateFrames.push(TEMPLATE_TEXT);
-			canStartRegex = false;
-			continue;
-		}
-		if (char === "\"" || char === "'") {
-			quote = char;
-			canStartRegex = false;
-			continue;
-		}
+		if (!codePositions[index]) 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;
-			continue;
-		}
-		if (char === "/" && source[index + 1] === "*") {
-			const commentEnd = source.indexOf("*/", index + 2);
-			if (commentEnd === -1) return void 0;
-			index = commentEnd + 1;
-			continue;
-		}
-		if (char === "/" && canStartRegex) {
-			let regexEscaped = false;
-			let inCharacterClass = false;
-			let closed = false;
-			for (index++; index < source.length; index++) {
-				const regexChar = source[index];
-				if (regexEscaped) {
-					regexEscaped = false;
-					continue;
-				}
-				if (regexChar === "\\") {
-					regexEscaped = true;
-					continue;
-				}
-				if (regexChar === "[") {
-					inCharacterClass = true;
-					continue;
-				}
-				if (regexChar === "]" && inCharacterClass) {
-					inCharacterClass = false;
-					continue;
-				}
-				if (regexChar === "/" && !inCharacterClass) {
-					closed = true;
-					while (/[$_\p{ID_Continue}]/u.test(source[index + 1] || "")) index++;
-					break;
-				}
-				if (regexChar === "\n" || regexChar === "\r") return void 0;
-			}
-			if (!closed) return void 0;
-			canStartRegex = false;
-			continue;
-		}
-		if (char === "/") {
-			canStartRegex = true;
-			continue;
-		}
 		if (/[$_\p{ID_Start}]/u.test(char)) {
 			const tokenStart = index;
 			while (/[$_\u200C\u200D\p{ID_Continue}]/u.test(source[index + 1] || "")) index++;
 			const token = source.slice(tokenStart, index + 1);
-			if (depth === 0 && templateFrames.length === 0 && token === "export") {
+			if (depth === 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;
 		}
 		if (/\d/.test(char)) {
 			while (/[\w.]/.test(source[index + 1] || "")) index++;
-			canStartRegex = false;
-			continue;
-		}
-		if ((char === "+" || char === "-") && source[index + 1] === char) {
-			index++;
 			continue;
 		}
-		if (char === "!" && source[index + 1] !== "=") continue;
 		if (char === "<") {
 			const typeArgumentEnd = findLikelyTypeArgumentEnd(source, index, codePositions);
 			if (typeArgumentEnd !== void 0) {
 				index = typeArgumentEnd;
-				canStartRegex = false;
 				continue;
 			}
 		}
 		if (char === "(" || char === "[" || char === "{") {
 			depth++;
-			canStartRegex = true;
 			continue;
 		}
 		if (char === ")" || char === "]" || char === "}") {
-			if (char === "}" && templateFrames.length > 0 && templateFrames[templateFrames.length - 1] === depth) {
-				templateFrames.pop();
-				canStartRegex = false;
-				continue;
-			}
 			depth = Math.max(0, depth - 1);
-			canStartRegex = false;
 			continue;
 		}
-		if (templateFrames.length === 0 && depth === 0 && char === ",") {
+		if (depth === 0 && char === ",") {
 			let bindingStart = index + 1;
 			while (/\s/.test(source[bindingStart] || "")) bindingStart++;
 			const binding = source.slice(bindingStart).match(new RegExp(`^(${JS_IDENTIFIER_PATTERN})`, "u"));
 			if (!binding || !isValidEsmExportName(binding[1])) return void 0;
 			names.push(binding[1]);
 			index = bindingStart + binding[1].length - 1;
-			canStartRegex = false;
 			continue;
 		}
-		if (templateFrames.length === 0 && depth === 0 && char === ";") return names;
-		if (!/\s/.test(char)) canStartRegex = char !== ".";
+		if (depth === 0 && char === ";") return names;
 	}
 	return names;
 }
@@ -2895,7 +2865,15 @@ function getWorkspacePackageJson(pkg) {
 		fromResolvedEntry: resolved
 	})?.packageJson;
 }
+const sharedDependencyGraphPackageJsonCache = /* @__PURE__ */ new Map();
 function getSharedDependencyGraphPackageJson(pkg) {
+	const cacheKey = `${getPackageDetectionCwd()}\0${pkg}`;
+	if (sharedDependencyGraphPackageJsonCache.has(cacheKey)) return sharedDependencyGraphPackageJsonCache.get(cacheKey);
+	const packageJson = resolveSharedDependencyGraphPackageJson(pkg);
+	sharedDependencyGraphPackageJsonCache.set(cacheKey, packageJson);
+	return packageJson;
+}
+function resolveSharedDependencyGraphPackageJson(pkg) {
 	const installedPackageJson = getInstalledPackageJson(pkg, { packageName: getPackageName(pkg) })?.packageJson;
 	if (installedPackageJson) return installedPackageJson;
 	try {
@@ -2904,7 +2882,16 @@ function getSharedDependencyGraphPackageJson(pkg) {
 	} catch {}
 	return getWorkspacePackageJson(pkg);
 }
+const sharedSingletonConsumedByPeerCache = /* @__PURE__ */ new WeakMap();
 function isSharedSingletonConsumedByPeer(pkg, options = getNormalizeModuleFederationOptions(), requireFederationRuntimeDependency = false) {
+	if (!options) return computeSharedSingletonConsumedByPeer(pkg, options, requireFederationRuntimeDependency);
+	let cache = sharedSingletonConsumedByPeerCache.get(options);
+	if (!cache) sharedSingletonConsumedByPeerCache.set(options, cache = /* @__PURE__ */ new Map());
+	const cacheKey = `${getPackageDetectionCwd()}\0${pkg}\0${requireFederationRuntimeDependency}`;
+	if (!cache.has(cacheKey)) cache.set(cacheKey, computeSharedSingletonConsumedByPeer(pkg, options, requireFederationRuntimeDependency));
+	return cache.get(cacheKey);
+}
+function computeSharedSingletonConsumedByPeer(pkg, options, requireFederationRuntimeDependency) {
 	const shared = options?.shared || {};
 	if (!requireFederationRuntimeDependency && Object.entries(shared).some(([key, item]) => key !== pkg && key.startsWith(`${pkg}/`) && item.shareConfig.singleton === true)) return true;
 	const sharedKeyByPackageName = /* @__PURE__ */ new Map();
@@ -2984,24 +2971,9 @@ function resolveConcreteSharedImportSource(pkg, projectRoot) {
 }
 const TREE_SHAKING_PROVIDER_TAG = "__treeShakingProvider__";
 const TREE_SHAKING_GRAPH_QUERY = "__mf_tree_shaking_graph__";
-const legacySharedVirtualModuleState = {
-	preBuildCacheMap: {},
-	preBuildShareItemMap: {},
-	treeShakingProviderCacheMap: {},
-	materializedTreeShakingProviders: /* @__PURE__ */ new Set(),
-	loadShareCacheMap: {},
-	warnedMissingImportFalse: /* @__PURE__ */ new Set(),
-	coalescableLoadShares: /* @__PURE__ */ new Set()
-};
 const sharedVirtualModuleStates = /* @__PURE__ */ new WeakMap();
 const sharedVirtualModuleStatesByOwner = /* @__PURE__ */ new Map();
 function getSharedVirtualModuleState(options) {
-	if (!options) try {
-		const currentOptions = getNormalizeModuleFederationOptions();
-		return sharedVirtualModuleStates.get(currentOptions) ?? legacySharedVirtualModuleState;
-	} catch {
-		return legacySharedVirtualModuleState;
-	}
 	let state = sharedVirtualModuleStates.get(options);
 	if (!state) {
 		state = {
@@ -3061,8 +3033,7 @@ function getConcreteTreeShakingExportUsage(pkg, shareItem, options) {
 	return getTreeShakingExportUsage(pkg, shareItem, shareItem?.name, options);
 }
 function getTreeShakingSharedProviderName(pkg, options) {
-	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
-	return `${getSharedVirtualModuleState(options).ownerKey ?? resolvedOptions.internalName ?? resolvedOptions.name}__tree_shaking__${packageNameEncode(pkg)}`;
+	return `${getSharedVirtualModuleState(options).ownerKey ?? options.internalName ?? options.name}__tree_shaking__${packageNameEncode(pkg)}`;
 }
 function getTreeShakingSharedProviderImportId(pkg, options) {
 	const { treeShakingProviderCacheMap } = getSharedVirtualModuleState(options);
@@ -3120,7 +3091,6 @@ export default { get, init };
 	materializedTreeShakingProviders.add(pkg);
 }
 function writePreBuildLibPath(pkg, shareItem, options, exportConditions) {
-	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const { preBuildCacheMap, preBuildShareItemMap } = getSharedVirtualModuleState(options);
 	if (!preBuildCacheMap[pkg]) preBuildCacheMap[pkg] = createScopedSharedVirtualModule(pkg, PREBUILD_TAG, options);
 	preBuildShareItemMap[pkg] = shareItem;
@@ -3149,9 +3119,8 @@ function writePreBuildLibPath(pkg, shareItem, options, exportConditions) {
 	}
 	if (pkg === "react/jsx-dev-runtime") {
 		preBuildCacheMap[pkg].writeSync(`
-    import __mfPrebuildDefault from ${escapeGeneratedStringLiteral(importSource)};
     import * as __mfPrebuildNamespace from ${escapeGeneratedStringLiteral(importSource)};
-    const __mfPrebuildExports = __mfPrebuildDefault ?? __mfPrebuildNamespace;
+    const __mfPrebuildExports = ${getDefaultOrNamespaceExpression("__mfPrebuildNamespace")};
     export const Fragment = __mfPrebuildExports.Fragment;
     export const jsxDEV = __mfPrebuildExports.jsxDEV;
     export default __mfPrebuildExports;
@@ -3160,9 +3129,8 @@ function writePreBuildLibPath(pkg, shareItem, options, exportConditions) {
 	}
 	if (pkg === "react/jsx-runtime") {
 		preBuildCacheMap[pkg].writeSync(`
-    import __mfPrebuildDefault from ${escapeGeneratedStringLiteral(importSource)};
     import * as __mfPrebuildNamespace from ${escapeGeneratedStringLiteral(importSource)};
-    const __mfPrebuildExports = __mfPrebuildDefault ?? __mfPrebuildNamespace;
+    const __mfPrebuildExports = ${getDefaultOrNamespaceExpression("__mfPrebuildNamespace")};
     export const Fragment = __mfPrebuildExports.Fragment;
     export const jsx = __mfPrebuildExports.jsx;
     export const jsxs = __mfPrebuildExports.jsxs;
@@ -3172,7 +3140,7 @@ function writePreBuildLibPath(pkg, shareItem, options, exportConditions) {
 	}
 	const namedExports = getSharedNamedExports(pkg, shareItem, exportConditions) ?? [];
 	if (namedExports.length > 0) {
-		const mutableExports = new Set(isLocalOnlyContainer(resolvedOptions) ? getSharedMutableExports(pkg, shareItem, exportConditions) : []);
+		const mutableExports = new Set(isLocalOnlyContainer(options) ? getSharedMutableExports(pkg, shareItem, exportConditions) : []);
 		const copiedExports = namedExports.filter((name) => !mutableExports.has(name));
 		const liveExports = namedExports.filter((name) => mutableExports.has(name));
 		const namedExportVars = copiedExports.map((_name, i) => `__mf_${i}`);
@@ -3185,26 +3153,23 @@ function writePreBuildLibPath(pkg, shareItem, options, exportConditions) {
     ${declarations}
     ${namedExportLine}
     ${liveExportLine}
-    export default Reflect.get(__mfPrebuildNamespace, "default") ?? __mfPrebuildNamespace;
+    export default ${getDefaultOrNamespaceExpression("__mfPrebuildNamespace")};
   `, true);
 		return;
 	}
 	preBuildCacheMap[pkg].writeSync(`
     import * as __mfPrebuildExports from ${escapeGeneratedStringLiteral(importSource)};
     export * from ${escapeGeneratedStringLiteral(importSource)};
-    // Reflect access avoids bundler warnings for ESM packages without a
-    // default export (for example antd/es/index.js), while preserving the
-    // namespace fallback for packages that do provide one.
-    export default Reflect.get(__mfPrebuildExports, "default") ?? __mfPrebuildExports;
+    export default ${getDefaultOrNamespaceExpression("__mfPrebuildExports")};
   `, true);
 }
 /** Re-render already materialized wrappers after import analysis discovers exports. */
-function refreshTreeShakingModules(options, command = "build", isRolldown = false, exportConditions) {
+function refreshTreeShakingModules(options, command = "build", exportConditions) {
 	const { preBuildShareItemMap } = getSharedVirtualModuleState(options);
 	for (const [pkg, shareItem] of Object.entries(preBuildShareItemMap)) {
 		if (!shareItem?.shareConfig.treeShaking) continue;
 		writePreBuildLibPath(pkg, shareItem, options, exportConditions);
-		writeLoadShareModule(pkg, shareItem, command, isRolldown, options, exportConditions);
+		writeLoadShareModule(pkg, shareItem, command, options, exportConditions);
 	}
 }
 function getPreBuildLibImportId(pkg, options) {
@@ -3218,16 +3183,11 @@ function getPreBuildShareItem(pkg, options) {
 function getSharedImportSource(pkg, shareItem, options) {
 	return getConcreteSharedImportSource(pkg, shareItem) || getPreBuildLibImportId(pkg, options);
 }
-function getLoadShareImportId(pkg, _isRolldown, options) {
+function getLoadShareModulePath(pkg, options) {
 	const { loadShareCacheMap } = getSharedVirtualModuleState(options);
 	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = createScopedSharedVirtualModule(pkg, LOAD_SHARE_TAG, options);
 	return loadShareCacheMap[pkg].getImportId();
 }
-function getLoadShareModulePath(pkg, isRolldown, options) {
-	const { loadShareCacheMap } = getSharedVirtualModuleState(options);
-	if (!loadShareCacheMap[pkg]) getLoadShareImportId(pkg, isRolldown, options);
-	return loadShareCacheMap[pkg].getImportId();
-}
 function getCachedSharedVirtualPkg(id, tag) {
 	if (!id.includes(tag)) return;
 	const normalized = normalizeVirtualModuleId(id);
@@ -3251,7 +3211,7 @@ function materializeCachedLoadShareModule(options) {
 	const key = options.findSharedKey(pkg, options.shared);
 	if (!key) return;
 	const shareItem = options.shared[key];
-	writeLoadShareModule(pkg, shareItem, options.command, options.isRolldown, options.federationOptions);
+	writeLoadShareModule(pkg, shareItem, options.command, options.federationOptions);
 	if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(pkg, shareItem, options.federationOptions);
 	options.addUsedShares(pkg);
 	options.writeLocalSharedImportMap();
@@ -3356,6 +3316,7 @@ function generateLazyWorkspaceSingletonExports(edges, namedExports, importSource
 	const trackPendingLoad = `__mfTrackPendingShareLoad(${deferredEntryFallback ? deferredEntryLoad : deferredInitLoad});`;
 	return `${declarations}
     const __mfApplyLazyShareExports = (mod) => {
+      exportModule = mod;
       ${assignments}
     };
     __mfSubscribeSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfApplyLazyShareExports);
@@ -3369,7 +3330,7 @@ function generateLazyWorkspaceSingletonExports(edges, namedExports, importSource
     } else {
       __mfApplyLazyShareExports(exportModule);
     }
-    export { __mf_default as default };${namedExportLine}${mutableExportLine}`;
+    export { __mf_default as default, exportModule as __moduleExports };${namedExportLine}${mutableExportLine}`;
 }
 const WORKSPACE_SINGLETON_SSR_LOCAL_SHARE = "__mfNormalizeShareModule(__mfLocalShare)";
 function prependWorkspaceSingletonSsrImport(code) {
@@ -3495,23 +3456,37 @@ function markLoadShareWrapperNotCoalescable(pkg, options, id) {
 function isCoalescableLoadShareWrapper(pkg, options, id) {
 	return getSharedVirtualModuleStateForId(id, options).coalescableLoadShares.has(pkg);
 }
-function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exportConditions, importFalseExportUsage) {
-	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
+/** Keeps runtime-shared React dispatchers usable when a mixed-mode remote swaps them in. */
+const REACT_MIXED_MODE_GUARD = `const __mfReactInternals = mod[${JSON.stringify(REACT_CLIENT_INTERNALS_KEY)}];
+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;
+}`;
+function writeLoadShareModule(pkg, shareItem, command, options, exportConditions, importFalseExportUsage) {
 	const { loadShareCacheMap, coalescableLoadShares } = getSharedVirtualModuleState(options);
 	const edges = createLocalPayloadEdges();
 	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = createScopedSharedVirtualModule(pkg, LOAD_SHARE_TAG, options);
 	let importLine = getRuntimeModuleCacheBootstrapCode(exportConditions);
 	const cacheDescriptor = getSharedCacheDescriptorLiteral(pkg, shareItem);
-	const cacheOwner = JSON.stringify(resolvedOptions.name);
-	const runtimeInitOwnerImportId = options ? getRuntimeInitStatusImportId(options) : void 0;
-	const treeShakingConsumer = command === "build" && shareItem.shareConfig.treeShaking ? resolvedOptions.name : void 0;
+	const cacheOwner = JSON.stringify(options.name);
+	const runtimeInitOwnerImportId = getRuntimeInitStatusImportId(options);
+	const treeShakingConsumer = command === "build" && shareItem.shareConfig.treeShaking ? options.name : void 0;
 	if (shareItem.shareConfig.import === false) {
 		const detectedNamedExports = getPackageNamedExports(pkg, exportConditions);
 		const namedExports = selectImportFalseNamedExports(detectedNamedExports, importFalseExportUsage);
 		let exportLine;
 		if (namedExports.length > 0) exportLine = generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor, treeShakingConsumer);
 		else {
-			const { warnedMissingImportFalse } = getSharedVirtualModuleState(resolvedOptions);
+			const { warnedMissingImportFalse } = getSharedVirtualModuleState(options);
 			if (detectedNamedExports === void 0 && !shareItem.shareConfig.suppressMissingImportWarning && !warnedMissingImportFalse.has(pkg)) {
 				warnedMissingImportFalse.add(pkg);
 				mfWarn(`Shared dependency "${pkg}" has import: false but is not installed locally.\n  Named imports (e.g. import { ... } from '${pkg}') will not work in production builds.\n  Install it as a devDependency to enable named export detection.`);
@@ -3537,20 +3512,22 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	const skipServePrebuildWarmup = command !== "build" && (pkg === "lit" || pkg.startsWith("lit/"));
 	const detectedNamedExports = getSharedNamedExports(pkg, shareItem, exportConditions);
 	const namedExports = detectedNamedExports ?? [];
-	const mutableExports = new Set(isLocalOnlyContainer(resolvedOptions) ? getSharedMutableExports(pkg, shareItem, exportConditions) : []);
+	const mutableExports = new Set(isLocalOnlyContainer(options) ? getSharedMutableExports(pkg, shareItem, exportConditions) : []);
 	const copiedNamedExports = namedExports.filter((name) => !mutableExports.has(name));
 	const liveNamedExports = namedExports.filter((name) => mutableExports.has(name));
 	const liveNamedExportLine = edges.reExportNames(liveNamedExports, sharedImportSource);
 	const hasCompleteExportCoverage = detectedNamedExports !== void 0;
-	const isWorkspaceSingleton = isWorkspacePackage && shareItem.shareConfig.singleton === true;
-	const usesDeferredSingletonFallback = hasCompleteExportCoverage && shareItem.shareConfig.eager !== true && (isWorkspacePackage || command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true || command === "build" && isRemoteContainer(resolvedOptions) && !isSharedSingletonConsumedByPeer(pkg, resolvedOptions, true));
-	const servesRemoteSingletonFallback = command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true;
-	const isConsumedByPeerSingleton = isSharedSingletonConsumedByPeer(pkg, resolvedOptions);
-	const usesEntryInjectedRemoteFallback = hasCompleteExportCoverage && !isWorkspaceSingleton && isRemoteContainer(resolvedOptions) && shareItem.shareConfig.singleton === true && resolvedOptions.hostInitInjectLocation === "entry" && (command === "build" || isConsumedByPeerSingleton);
-	const usesDeferredEntryInjectedSingletonFallback = usesEntryInjectedRemoteFallback && !isReactCoreShare(pkg) && (pkg === "react-dom/client" || shareItem.shareConfig.eager !== true && !isSharedSingletonConsumedByPeer(pkg, resolvedOptions, true));
+	const isSingleton = shareItem.shareConfig.singleton === true;
+	const isWorkspaceSingleton = isWorkspacePackage && isSingleton;
+	const usesDeferredSingletonFallback = hasCompleteExportCoverage && shareItem.shareConfig.eager !== true && (isWorkspacePackage || command !== "build" && isRemoteOnlyContainer(options) && isSingleton || command === "build" && isRemoteContainer(options) && !isSharedSingletonConsumedByPeer(pkg, options, true));
+	const servesRemoteSingletonFallback = command !== "build" && isRemoteOnlyContainer(options) && isSingleton;
+	const isConsumedByPeerSingleton = isSharedSingletonConsumedByPeer(pkg, options);
+	const usesEntryInjectedRemoteFallback = hasCompleteExportCoverage && !isWorkspaceSingleton && isRemoteContainer(options) && isSingleton && options.hostInitInjectLocation === "entry" && (command === "build" || isConsumedByPeerSingleton);
+	const usesDeferredEntryInjectedSingletonFallback = usesEntryInjectedRemoteFallback && !isReactCoreShare(pkg) && (pkg === "react-dom/client" || shareItem.shareConfig.eager !== true && !isSharedSingletonConsumedByPeer(pkg, options, true));
 	const usesEagerWorkspaceFallback = hasCompleteExportCoverage && isWorkspaceSingleton && !servesRemoteSingletonFallback && (isConsumedByPeerSingleton || shareItem.shareConfig.eager === true);
 	const usesDeferredTreeShakingFallback = hasCompleteExportCoverage && Boolean(treeShakingConsumer);
-	const reactMixedModeGuard = pkg === "react" ? createReactMixedModeRuntimeGuard() : "";
+	const rebindsSharedExports = isSingleton || options.shareStrategy === "version-first";
+	const reactMixedModeGuard = pkg === "react" && isSingleton ? REACT_MIXED_MODE_GUARD : "";
 	let exportLine;
 	let initBlock = "";
 	if (usesDeferredTreeShakingFallback) {
@@ -3575,7 +3552,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
     ${edges.reExportAll(coherentLocalSource)}`;
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
       __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
-	} else if (namedExports.length > 0 && shareItem.shareConfig.singleton === true) {
+	} else if (namedExports.length > 0 && rebindsSharedExports) {
 		const namedExportVars = copiedNamedExports.map((_name, i) => `__mf_${i}`);
 		exportLine = `${["let __mfDefaultExport;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ")}
     const __mfApplySharedExports = (mod) => {
@@ -3614,7 +3591,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
     ${liveNamedExportLine}`;
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
       __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
-	} else if (shareItem.shareConfig.singleton === true) {
+	} else if (rebindsSharedExports) {
 		exportLine = `let __mfDefaultExport;
     const __mfApplySharedDefaultExport = (mod) => {
       ${reactMixedModeGuard}
@@ -3634,7 +3611,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	const staticLocalShareSource = detectedNamedExports === void 0 ? coherentLocalSource : skipServePrebuildWarmup ? devImportSource : sharedImportSource;
 	const prebuildImportLine = usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback ? "" : usesDeferredSingletonFallback || usesDeferredTreeShakingFallback ? !servesRemoteSingletonFallback && usesDeferredSingletonFallback && command !== "build" && (isWorkspaceSingleton || isWorkspacePackage) ? edges.importNamespace(lazyLocalFallbackSource) : "" : edges.importNamespace(staticLocalShareSource);
 	const devDynamicImportLine = isWorkspacePackage ? "" : usesDeferredSingletonFallback || usesDeferredTreeShakingFallback || usesDeferredEntryInjectedSingletonFallback ? "" : command !== "build" && !skipServePrebuildWarmup ? `;() => import(${escapeGeneratedStringLiteral(devImportSource)}).catch(() => {});` : "";
-	const cacheHelpers = recordCoalescability(pkg, edges.none, command, shareItem.shareConfig, coalescableLoadShares) ? getSharedCacheHelpersImportCode(resolvedOptions) : sharedCacheHelperCode;
+	const cacheHelpers = recordCoalescability(pkg, edges.none, command, shareItem.shareConfig, coalescableLoadShares) ? getSharedCacheHelpersImportCode(options) : sharedCacheHelperCode;
 	const moduleBody = usesDeferredSingletonFallback || usesDeferredTreeShakingFallback || usesDeferredEntryInjectedSingletonFallback || usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback ? `
     ${usesDeferredEntryInjectedSingletonFallback ? "" : prebuildImportLine}
     ${devDynamicImportLine}
@@ -3659,10 +3636,9 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 }
 //#endregion
 //#region src/virtualModules/virtualRemoteEntry.ts
-let usedShares = /* @__PURE__ */ new Set();
 const usedSharesByOptions = /* @__PURE__ */ new WeakMap();
 const materializedSharesByOptions = /* @__PURE__ */ new WeakMap();
-function getScopedUsedShares(options) {
+function getUsedShares(options) {
 	let scoped = usedSharesByOptions.get(options);
 	if (!scoped) {
 		scoped = /* @__PURE__ */ new Set();
@@ -3670,25 +3646,17 @@ function getScopedUsedShares(options) {
 	}
 	return scoped;
 }
-function getUsedShares(options) {
-	if (options) return getScopedUsedShares(options);
-	return usedShares;
-}
 function addUsedShares(pkg, options) {
-	usedShares.add(pkg);
-	if (options) getScopedUsedShares(options).add(pkg);
-	if (options) {
-		let scoped = materializedSharesByOptions.get(options);
-		if (!scoped) {
-			scoped = /* @__PURE__ */ new Set();
-			materializedSharesByOptions.set(options, scoped);
-		}
-		scoped.add(pkg);
+	getUsedShares(options).add(pkg);
+	let scoped = materializedSharesByOptions.get(options);
+	if (!scoped) {
+		scoped = /* @__PURE__ */ new Set();
+		materializedSharesByOptions.set(options, scoped);
 	}
+	scoped.add(pkg);
 }
 function addConfiguredShare(pkg, options) {
-	usedShares.add(pkg);
-	if (options) getScopedUsedShares(options).add(pkg);
+	getUsedShares(options).add(pkg);
 }
 const LOCAL_SHARED_IMPORT_MAP_ID = "virtual:mf-localSharedImportMap";
 const LAZY_CONSUME_ONLY_SHARES_PLACEHOLDER = "__MF_LAZY_CONSUME_ONLY_SHARES__";
@@ -3710,15 +3678,13 @@ function getLocalSharedImportMapPath(options) {
 function getResolvedLocalSharedImportMapId(options) {
 	return `\0${getLocalSharedImportMapPath(options)}`;
 }
-let invalidateLocalSharedImportMap;
 const localSharedImportMapInvalidators = /* @__PURE__ */ new WeakMap();
 function setLocalSharedImportMapInvalidator(invalidator, options) {
-	if (!options) invalidateLocalSharedImportMap = invalidator;
-	else if (invalidator) localSharedImportMapInvalidators.set(options, invalidator);
+	if (invalidator) localSharedImportMapInvalidators.set(options, invalidator);
 	else localSharedImportMapInvalidators.delete(options);
 }
 function writeLocalSharedImportMap(options) {
-	(options ? localSharedImportMapInvalidators.get(options) : invalidateLocalSharedImportMap)?.();
+	localSharedImportMapInvalidators.get(options)?.();
 }
 function shouldUseDirectReactImport() {
 	const isVinext = hasPackageDependency("vinext");
@@ -3739,15 +3705,15 @@ function getDirectSharedCacheSeedImportPath(pkg, shareItem) {
 function generateLocalSharedImportMap(options) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const useDirectReactImport = shouldUseDirectReactImport();
-	const orderedShares = getOrderedUsedShares(options);
-	const sharesToMaterialize = new Set(getMaterializedShares(options));
+	const orderedShares = getOrderedUsedShares(resolvedOptions);
+	const sharesToMaterialize = new Set(getMaterializedShares(resolvedOptions));
 	const hasConsumeOnlyShare = orderedShares.some((pkg) => getNormalizeShareItem(pkg, resolvedOptions)?.shareConfig.import === false);
 	return `
     import {loadShare} from "@module-federation/runtime";
     ${orderedShares.map((pkg, index) => {
 		const shareItem = getNormalizeShareItem(pkg, resolvedOptions);
 		if (!shareItem || !shareItem.shareConfig.eager || shareItem.shareConfig.import === false) return "";
-		return `import * as __mfEagerShare_${index} from ${toSafeJsLiteral(getLocalSharedPackagePath(pkg, shareItem, options))};`;
+		return `import * as __mfEagerShare_${index} from ${toSafeJsLiteral(getLocalSharedPackagePath(pkg, shareItem, resolvedOptions))};`;
 	}).filter(Boolean).join("\n")}
     ${normalizeRuntimeShareCode}
     const __mfGetCachedReactFamily = (keys, reactKeys, localVersion, requiredExport) => {
@@ -3769,7 +3735,24 @@ function generateLocalSharedImportMap(options) {
         // A host seed from an older React family is not coherent with the newer cached react
         const cachedVersion = cached?.version ?? cached?.default?.version;
         if (cachedVersion !== undefined && isOlder(cachedVersion)) continue;
-        if (!requiredExport || typeof cached?.[requiredExport] === 'function' || typeof cached?.default?.[requiredExport] === 'function') return cached;
+        if (!requiredExport || typeof cached?.[requiredExport] === 'function' || typeof cached?.default?.[requiredExport] === 'function') {
+          const dom = typeof cached?.[requiredExport] === 'function' ? cached : cached?.default;
+          const internals = dom?.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+          if (!requiredExport || key.endsWith('/client') || !internals) return cached;
+          // React 18 root: mirror react-dom/client.js, or createRoot warns it was imported from "react-dom"
+          const client = {};
+          for (const name of ['createRoot', 'hydrateRoot']) {
+            client[name] = (...args) => {
+              internals.usingClientEntryPoint = true;
+              try {
+                return dom[name](...args);
+              } finally {
+                internals.usingClientEntryPoint = false;
+              }
+            };
+          }
+          return { ...client, default: client };
+        }
       }
       return undefined;
     };
@@ -3803,7 +3786,7 @@ function generateLocalSharedImportMap(options) {
 		return `
         ${toSafeJsLiteral(pkg)}: async () => {
           ${shareItem?.shareConfig.eager ? `let pkg = __mfEagerShare_${index};
-            return pkg;` : `let pkg = await import(${toSafeJsLiteral(getLocalSharedPackagePath(pkg, shareItem, options))});
+            return pkg;` : `let pkg = await import(${toSafeJsLiteral(getLocalSharedPackagePath(pkg, shareItem, resolvedOptions))});
             return pkg;`}
         }
       `;
@@ -3827,11 +3810,11 @@ function generateLocalSharedImportMap(options) {
 		const treeShakingConfig = canLiveRebind ? shareItem.shareConfig.treeShaking : void 0;
 		if (shareItem.shareConfig.import === false && !treeShakingConfig) return `
           ${toSafeJsLiteral(key)}: __mfConsumeOnly(${toSafeJsLiteral(key)}, ${toSafeJsLiteral(shareItem.version)}, ${toSafeJsLiteral(shareItem.scope)}, ${sharesToMaterialize.has(key)}, {singleton: ${shareItem.shareConfig.singleton}, requiredVersion: ${toSafeJsLiteral(shareItem.shareConfig.requiredVersion)}, strictVersion: ${shareItem.shareConfig.strictVersion}, eager: ${Boolean(shareItem.shareConfig.eager)}, ${shareItem.shareConfig.request !== void 0 ? `request: ${toSafeJsLiteral(shareItem.shareConfig.request)},` : ""} ${shareItem.shareConfig.shareKey !== void 0 ? `shareKey: ${toSafeJsLiteral(shareItem.shareConfig.shareKey)},` : ""}})`;
-		const treeShakingUsage = treeShakingConfig ? getTreeShakingExportUsage(key, shareItem, shareItem.name, options) : void 0;
+		const treeShakingUsage = treeShakingConfig ? getTreeShakingExportUsage(key, shareItem, shareItem.name, resolvedOptions) : void 0;
 		const treeShakingProviderExports = treeShakingUsage?.kind === "exports" ? treeShakingUsage.usedExports : [];
 		const treeShakingUsedExports = resolvedOptions.injectTreeShakingUsedExports === false ? treeShakingConfig?.usedExports || [] : treeShakingProviderExports;
 		const disableRuntimeInference = treeShakingConfig?.mode === "runtime-infer" && resolvedOptions.injectTreeShakingUsedExports === false;
-		const treeShakingProviderImportId = treeShakingConfig && !disableRuntimeInference && hasTreeShakingSharedProvider(key, shareItem, options) ? getTreeShakingSharedProviderImportId(key, options) : void 0;
+		const treeShakingProviderImportId = treeShakingConfig && !disableRuntimeInference && hasTreeShakingSharedProvider(key, shareItem, resolvedOptions) ? getTreeShakingSharedProviderImportId(key, resolvedOptions) : void 0;
 		const treeShakingStatus = treeShakingUsage?.kind === "full" || disableRuntimeInference || treeShakingConfig?.mode === "runtime-infer" && !treeShakingProviderImportId && shareItem.shareConfig.import !== false ? 0 : 1;
 		return `
           ${toSafeJsLiteral(key)}: {
@@ -3916,7 +3899,7 @@ function generateLocalSharedImportMap(options) {
         `;
 	}).filter((x) => x !== null).join(",")}
     }
-      const usedRemotes = [${Object.keys(getUsedRemotesMap(options)).map((key) => {
+      const usedRemotes = [${Object.keys(getUsedRemotesMap(resolvedOptions)).map((key) => {
 		const remote = resolvedOptions.remotes[key];
 		if (!remote) return null;
 		return `
@@ -3949,30 +3932,27 @@ function expandSharedPrefixKey(prefixKey, used) {
 	return [...expanded];
 }
 function getOrderedUsedShares(options) {
-	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const used = getUsedShares(options);
 	const shares = /* @__PURE__ */ new Set();
 	const addShare = (pkg) => {
-		const shareItem = getNormalizeShareItem(pkg, resolvedOptions);
+		const shareItem = getNormalizeShareItem(pkg, options);
 		shares.add(shareItem ? getCanonicalSharedKey(pkg, shareItem) : pkg);
 	};
 	used.forEach(addShare);
-	Object.keys(resolvedOptions.shared ?? {}).forEach((pkg) => {
-		const share = resolvedOptions.shared?.[pkg];
+	Object.keys(options.shared ?? {}).forEach((pkg) => {
+		const share = options.shared?.[pkg];
 		if (share && !getSharedRequest(pkg, share).endsWith("/")) addShare(pkg);
 	});
-	for (const [pkg, share] of Object.entries(resolvedOptions.shared ?? {})) if (share.shareConfig?.eager && getSharedRequest(pkg, share).endsWith("/")) for (const concrete of expandSharedPrefixKey(getSharedRequest(pkg, share), used)) addShare(concrete);
+	for (const [pkg, share] of Object.entries(options.shared ?? {})) if (share.shareConfig?.eager && getSharedRequest(pkg, share).endsWith("/")) for (const concrete of expandSharedPrefixKey(getSharedRequest(pkg, share), used)) addShare(concrete);
 	return orderSharedDependenciesFirst(Array.from(shares).sort((a, b) => {
 		const priority = (pkg) => pkg === "react" ? 0 : pkg === "react-dom" ? 1 : pkg.startsWith("react/") ? 2 : 3;
 		return priority(a) - priority(b) || a.localeCompare(b);
 	}));
 }
 function getMaterializedShares(options) {
-	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
-	const scopedRegistrations = options ? usedSharesByOptions.get(options) : void 0;
-	const shares = new Set(options && scopedRegistrations?.size ? materializedSharesByOptions.get(options) ?? [] : usedShares);
-	const usedForEager = options ? usedSharesByOptions.get(options) ?? [] : usedShares;
-	for (const [pkg, share] of Object.entries(resolvedOptions.shared ?? {})) {
+	const shares = new Set(materializedSharesByOptions.get(options));
+	const usedForEager = usedSharesByOptions.get(options) ?? [];
+	for (const [pkg, share] of Object.entries(options.shared ?? {})) {
 		if (!share.shareConfig?.eager) continue;
 		const request = getSharedRequest(pkg, share);
 		if (request.endsWith("/")) for (const concrete of expandSharedPrefixKey(request, usedForEager)) shares.add(concrete);
@@ -3986,17 +3966,18 @@ function getMaterializedShares(options) {
 	const pending = [...shares];
 	while (pending.length) {
 		const pkg = pending.pop();
-		const share = getNormalizeShareItem(pkg, resolvedOptions);
+		const share = getNormalizeShareItem(pkg, options);
 		const packageName = getPackageName(pkg);
 		const packageJson = getInstalledPackageJson(pkg)?.packageJson ?? (pkg !== packageName ? getInstalledPackageJson(packageName)?.packageJson : void 0);
 		const dependencies = {
 			...packageJson?.dependencies || {},
 			...packageJson?.peerDependencies || {},
-			...packageJson?.optionalDependencies || {}
+			...packageJson?.optionalDependencies || {},
+			...packageJson?.peerDependenciesMeta || {}
 		};
 		for (const dependency of Object.keys(dependencies)) {
 			const sharedDependency = configured.get(dependency);
-			const dependencyShare = sharedDependency ? getNormalizeShareItem(sharedDependency, resolvedOptions) : void 0;
+			const dependencyShare = sharedDependency ? getNormalizeShareItem(sharedDependency, options) : void 0;
 			if (sharedDependency && !shares.has(sharedDependency) && dependencyShare?.scope === share?.scope) {
 				shares.add(sharedDependency);
 				pending.push(sharedDependency);
@@ -4008,7 +3989,7 @@ function getMaterializedShares(options) {
 		return priority(a) - priority(b) || a.localeCompare(b);
 	});
 	return orderSharedDependenciesFirst([...new Set(sorted.map((pkg) => {
-		const shareItem = getNormalizeShareItem(pkg, resolvedOptions);
+		const shareItem = getNormalizeShareItem(pkg, options);
 		return shareItem ? getCanonicalSharedKey(pkg, shareItem) : pkg;
 	}))]);
 }
@@ -4028,7 +4009,8 @@ function getSharePrerequisites(ordered) {
 		const dependencies = {
 			...packageJson?.dependencies || {},
 			...packageJson?.peerDependencies || {},
-			...packageJson?.optionalDependencies || {}
+			...packageJson?.optionalDependencies || {},
+			...packageJson?.peerDependenciesMeta || {}
 		};
 		const prerequisites = Object.keys(dependencies).map((dependency) => roots.get(dependency)).filter((dependency) => Boolean(dependency));
 		if (pkg !== packageName && (packageName === "react" || packageName === "react-dom")) {
@@ -4072,7 +4054,8 @@ function orderSharedDependenciesFirst(sharedPackages) {
 		const dependencies = {
 			...packageJson?.dependencies || {},
 			...packageJson?.peerDependencies || {},
-			...packageJson?.optionalDependencies || {}
+			...packageJson?.optionalDependencies || {},
+			...packageJson?.peerDependenciesMeta || {}
 		};
 		Object.keys(dependencies).forEach((dependency) => {
 			const sharedDependency = sharedKeyByPackageName.get(dependency);
@@ -4312,21 +4295,33 @@ const externalSharedProviderSelectionHelperCode = `const __mfSelectExternalShare
 /**
 * A consume-only stub never outranks a provider: when registering this container's
 * `import: false` share replaces an unloaded provider of the same version (#1311),
-* the `afterRegisterShare` hook restores the provider. Registered once per instance.
+* the `afterRegisterShare` hook restores the provider, and a provider kept out by an
+* unloaded stub takes its slot. Registered once per instance.
 */
 function generateKeepProvidersOverStubsCode(runtimeVar) {
 	return `if (!${runtimeVar}.__mfKeepAdoptedProviders) {
       ${runtimeVar}.__mfKeepAdoptedProviders = true;
       ${runtimeVar}.sharedHandler?.hooks?.lifecycle?.afterRegisterShare?.on?.((args) => {
         const { shared, previousShared, registeredShared } = args || {};
+        const versions = ${runtimeVar}.shareScopeMap?.[args.scope]?.[args.pkgName];
+        if (!shared || !versions) return;
+        // The reverse: a stub already in the slot (e.g. a loaded-first parent's) keeps a provider
+        // out, and a webpack consumer reading the scope then falls back to its own copy.
+        if (shared.shareConfig?.import !== false) {
+          if (
+            registeredShared !== shared &&
+            registeredShared?.shareConfig?.import === false &&
+            !registeredShared.loaded &&
+            versions[shared.version] === registeredShared
+          ) versions[shared.version] = shared;
+          return;
+        }
         if (
-          shared?.shareConfig?.import !== false ||
           registeredShared !== shared ||
           !previousShared ||
           previousShared.shareConfig?.import === false
         ) return;
-        const versions = ${runtimeVar}.shareScopeMap?.[args.scope]?.[args.pkgName];
-        if (versions && versions[shared.version] === shared) versions[shared.version] = previousShared;
+        if (versions[shared.version] === shared) versions[shared.version] = previousShared;
       });
     }`;
 }
@@ -4408,6 +4403,19 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy, options, command = "b
             );
             return;
           }
+          // A Vite container seeds its own copy into the module cache before the Runtime
+          // marks its provider loaded. A non-singleton is cached under its version, so
+          // look the selected provider's copy up under that version, not this share's.
+          if (!share.shareConfig?.singleton && typeof externalProvider.version === 'string') {
+            const externalCached = __mfReadSharedCache(
+              __mfModuleCache.share,
+              __mfGetSharedCacheDescriptor(pkg, false, externalProvider.version, share.scope)
+            );
+            if (externalCached !== undefined) {
+              __mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, externalCached, externalProvider.from);
+              return;
+            }
+          }
           // Leave an unloaded webpack provider to the late bridge, which only takes a
           // non-singleton of this share's own version; any other version seeds locally.
           if (
@@ -4510,17 +4518,16 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy, options, command = "b
     var __mfDeferredSeedKeys = __mfSeedKeys.filter(
       (pkg) => __mfPreInitBlockedSeedKeys.has(__mfSeedIndex.get(pkg))
     );
-    await __mfSeedLocalShared(__mfImmediateSeedKeys);`;
+    await __mfSeedLocalShared(__mfImmediateSeedKeys).catch(__mfRejectInit);`;
 }
 function getBrowserImportPath(importPath) {
 	if (/^(?:[a-zA-Z]:[\\/]|\/)/.test(importPath) && !importPath.startsWith("/@")) return `/@fs/${importPath}`;
 	return importPath;
 }
 function getHostAutoInitSharedSeedItems(options) {
-	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	return getMaterializedShares(options).map((pkg) => ({
 		pkg,
-		shareItem: getShareItemForPreload(pkg, resolvedOptions)
+		shareItem: getShareItemForPreload(pkg, options)
 	})).filter(({ shareItem }) => shareItem?.shareConfig?.import === false).sort((a, b) => {
 		const priority = (pkg) => pkg === "vue" ? 0 : pkg === "pinia" ? 1 : 2;
 		const aIsLocal = !!getLocalProviderImportPath(a.pkg);
@@ -4531,7 +4538,7 @@ function getHostAutoInitSharedSeedItems(options) {
 function generateHostAutoInitSharedCacheSeedCode(command = "build", options) {
 	if (command === "build") return "";
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
-	return getHostAutoInitSharedSeedItems(options).map(({ pkg, shareItem }) => {
+	return getHostAutoInitSharedSeedItems(resolvedOptions).map(({ pkg, shareItem }) => {
 		if (!shareItem) return null;
 		return generateSharedCacheSeedItem(pkg, shareItem, getBrowserImportPath(getDirectSharedCacheSeedImportPath(pkg, shareItem)), resolvedOptions);
 	}).filter((item) => item !== null).join("\n");
@@ -4761,7 +4768,12 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   ${runtimeHelperImports.length ? `import {${runtimeHelperImports.join(", ")}} from "@module-federation/runtime/helpers";` : ""}
   ${pluginImportNames.filter((item) => !isSsrOnlyPlugin(item[1])).map((item) => item[1]).join("\n")}
   import __mfExposesMap from "${virtualExposesId}"
-  ${command === "build" ? getRuntimeInitResolveBootstrapCode(false, getRuntimeInitStatusImportId(options)) : getRuntimeInitBootstrapCode(false, getRuntimeInitStatusImportId(options), void 0, void 0, exportConditions) + "\n  const { initResolve } = globalThis[globalKey];"}
+  ${command === "build" ? getRuntimeInitResolveBootstrapCode(false, getRuntimeInitStatusImportId(options)) + "\n  const { initReject } = __mfResolveState;" : getRuntimeInitBootstrapCode(false, getRuntimeInitStatusImportId(options), void 0, void 0, exportConditions) + "\n  const { initResolve, initReject } = globalThis[globalKey];"}
+  // A failed seed must settle initPromise, or every pending share load hangs forever.
+  const __mfRejectInit = (err) => {
+    initReject(err);
+    throw err;
+  };
   ${getRuntimeModuleCacheBootstrapCode(exportConditions)}
   const initTokens = {}
   const shareScopeNames = Array.isArray(${toSafeJsLiteral(options.shareScope)}) ? ${toSafeJsLiteral(options.shareScope)} : [${toSafeJsLiteral(options.shareScope)}]
@@ -5655,7 +5667,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
     __mfReadyDeferredSeedKeys.push(...__mfDeferredSeedKeys.filter(
       (pkg) => !__mfBlockedSeedKeys.has(__mfSeedIndex.get(pkg))
     ));
-    await __mfSeedLocalShared(__mfReadyDeferredSeedKeys);
+    await __mfSeedLocalShared(__mfReadyDeferredSeedKeys).catch(__mfRejectInit);
     ${command === "build" ? `// A consume-only share reached only through import() is bridged when that import runs
     // (see pluginLazyConsumeOnlyShares), through the same provider selection init() uses.
     const __mfLazyShareLoads = new Map();
@@ -5712,13 +5724,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
 */
 const HOST_AUTO_INIT_TAG = "__H_A_I__";
 const hostAutoInitStates = /* @__PURE__ */ new WeakMap();
-const legacyHostAutoInitState = {
-	module: new VirtualModule("hostAutoInit", HOST_AUTO_INIT_TAG),
-	remoteEntryId: REMOTE_ENTRY_ID,
-	command: "build"
-};
 function getHostAutoInitState(options) {
-	if (!options) return legacyHostAutoInitState;
 	let state = hostAutoInitStates.get(options);
 	if (!state) {
 		const ownerKey = getLocalOwnerKey(options);
@@ -5734,7 +5740,7 @@ function getHostAutoInitState(options) {
 function generateHostAutoInitCode(remoteEntryImport, _command = "build", options, exportConditions) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const shouldPreloadShares = resolvedOptions.shareStrategy !== "loaded-first";
-	const hostInitShareBatches = toSafeJsLiteral(getShareBatches(options, false));
+	const hostInitShareBatches = toSafeJsLiteral(getShareBatches(resolvedOptions, false));
 	const cacheOwner = toSafeJsLiteral(resolvedOptions.name);
 	const preferLocalVinextReact = hasPackageDependency("vinext") && (!exportConditions?.includes("browser") || exportConditions.includes("worker"));
 	const hasConfiguredShared = hasShared(resolvedOptions);
@@ -5778,6 +5784,15 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
               )
             );
           const __mfHostInitShareBatches = ${hostInitShareBatches};
+          // The baked batches are generated before the build has seen every import, so a
+          // share first used later in the graph, such as react-dom/client, is missing from
+          // them. Negotiate those after the baked batches, once their package roots have
+          // settled (#1503).
+          {
+            const bakedKeys = new Set(__mfHostInitShareBatches.flat());
+            const lateKeys = Object.keys(usedShared).filter((pkg) => !bakedKeys.has(pkg));
+            if (lateKeys.length) __mfHostInitShareBatches.push(lateKeys);
+          }
           ${hostInitSharedProviderHelperCode}
           for (const __mfHostInitShareBatch of __mfHostInitShareBatches) {
             await Promise.all(__mfHostInitShareBatch.map(async (pkg) => {
@@ -5792,9 +5807,10 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
               if (
                 __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined &&
                 ${_command === "serve" ? `__mfReadSharedCacheOwner(__mfModuleCache.share, cacheDescriptor) !== undefined &&
-                      !(share.shareConfig?.singleton && __mfHasAlternativeSharedVersion(pkg, share))` : `(
-                        (!share.shareConfig?.singleton && __mfReadSharedCacheOwner(__mfModuleCache.share, cacheDescriptor) === ${cacheOwner}) ||
-                        (share.shareConfig?.singleton && !__mfHasAlternativeSharedVersion(pkg, share))
+                      !__mfHasAlternativeSharedVersion(pkg, share)` : `(
+                        !__mfHasAlternativeSharedVersion(pkg, share) &&
+                        (share.shareConfig?.singleton ||
+                          __mfReadSharedCacheOwner(__mfModuleCache.share, cacheDescriptor) === ${cacheOwner})
                       )`}
               ) return;
               // An import:false share has nothing to load until a foreign provider
@@ -5884,7 +5900,7 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
     export { initHost, hostInitPromise };
     `;
 }
-function writeHostAutoInit(remoteEntryId = REMOTE_ENTRY_ID, command = "build", options, exportConditions) {
+function writeHostAutoInit(remoteEntryId = REMOTE_ENTRY_ID, command, options, exportConditions) {
 	const state = getHostAutoInitState(options);
 	state.remoteEntryId = remoteEntryId;
 	state.command = command;
@@ -5912,13 +5928,8 @@ function isOwnedHostAutoInitId(id, options) {
 * 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 = {
@@ -5931,14 +5942,14 @@ function getPendingSharesState(options) {
 }
 function generatePendingSharesCode(command = "build", options) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
-	const pendingSharePkgs = command === "build" ? getMaterializedShares(options).filter((pkg) => {
+	const pendingSharePkgs = command === "build" ? getMaterializedShares(resolvedOptions).filter((pkg) => {
 		const shareItem = getShareItemForPreload(pkg, resolvedOptions);
 		if (!shareItem || pkg.endsWith("/")) return false;
 		if (shareItem.shareConfig.eager) return false;
 		return shareItem.shareConfig.import !== false && !shareItem.shareConfig.treeShaking;
 	}) : [];
 	if (command === "build" && shouldPreloadEntryDeferredReactDomClient(resolvedOptions) && !pendingSharePkgs.includes("react-dom/client")) pendingSharePkgs.push(REACT_DOM_CLIENT_SHARE);
-	const pendingShareImports = pendingSharePkgs.map((pkg) => `[${toSafeJsLiteral(pkg)}, () => import(${toSafeJsLiteral(getLoadShareModulePath(pkg, false, options))})]`);
+	const pendingShareImports = pendingSharePkgs.map((pkg) => `[${toSafeJsLiteral(pkg)}, () => import(${toSafeJsLiteral(getLoadShareModulePath(pkg, resolvedOptions))})]`);
 	return `
     ${getRuntimeModuleCacheBootstrapCode()}
     ${sharedCacheHelperCode}
@@ -5964,7 +5975,7 @@ function generatePendingSharesCode(command = "build", options) {
     }
   `;
 }
-function writePendingShares(command = "build", options) {
+function writePendingShares(command, options) {
 	const state = getPendingSharesState(options);
 	state.command = command;
 	state.module.writeSync(generatePendingSharesCode(command, options), true);
@@ -6023,20 +6034,11 @@ function refreshRemoteModuleForEnvironment(id, options, exportConditions) {
 	virtual.write(generateRemotes(metadata.remote, metadata.command, metadata.enableSsrInit, metadata.consumer, options, exportConditions));
 	return true;
 }
-const usedRemotesMap = {};
 const usedRemotesByOptions = /* @__PURE__ */ new WeakMap();
 const dynamicRemotesByOptions = /* @__PURE__ */ new WeakMap();
 const staticRemotesByOptions = /* @__PURE__ */ new WeakMap();
 const preloadRemotesByOptions = /* @__PURE__ */ new WeakMap();
 const EMPTY_STATIC_REMOTES = /* @__PURE__ */ new Set();
-function getScopedUsedRemotesMap(options) {
-	let scoped = usedRemotesByOptions.get(options);
-	if (!scoped) {
-		scoped = {};
-		usedRemotesByOptions.set(options, scoped);
-	}
-	return scoped;
-}
 function recordUsedRemote(map, remoteKey, remoteModule) {
 	ensureUsedRemoteKey(map, remoteKey).add(remoteModule);
 }
@@ -6045,16 +6047,18 @@ function ensureUsedRemoteKey(map, remoteKey) {
 	return map[remoteKey];
 }
 function ensureUsedRemote(remoteKey, options) {
-	ensureUsedRemoteKey(usedRemotesMap, remoteKey);
-	if (options) ensureUsedRemoteKey(getScopedUsedRemotesMap(options), remoteKey);
+	ensureUsedRemoteKey(getUsedRemotesMap(options), remoteKey);
 }
 function addUsedRemote(remoteKey, remoteModule, options) {
-	recordUsedRemote(usedRemotesMap, remoteKey, remoteModule);
-	if (options) recordUsedRemote(getScopedUsedRemotesMap(options), remoteKey, remoteModule);
+	recordUsedRemote(getUsedRemotesMap(options), remoteKey, remoteModule);
 }
 function getUsedRemotesMap(options) {
-	if (options) return getScopedUsedRemotesMap(options);
-	return usedRemotesMap;
+	let usedRemotes = usedRemotesByOptions.get(options);
+	if (!usedRemotes) {
+		usedRemotes = {};
+		usedRemotesByOptions.set(options, usedRemotes);
+	}
+	return usedRemotes;
 }
 function markDynamicRemote(remote, options) {
 	let remotes = dynamicRemotesByOptions.get(options);
@@ -6124,12 +6128,6 @@ function getEagerDeferredClientInit() {
 	return `__mfRemotePending = __mfStartRemoteLoad().then(__mfAssignRemoteModule);
       exportModule = __mfCreateDeferredRemoteProxy();`;
 }
-function shouldIncludeDeferredProxy(initMode, consumer, eagerLoadClientRemote, deferRemoteLoad) {
-	if (eagerLoadClientRemote && consumer !== "server") return true;
-	if (initMode === "eager") return consumer !== "server" && (consumer === "unified" || !eagerLoadClientRemote);
-	if (consumer === "client" && eagerLoadClientRemote) return false;
-	return deferRemoteLoad || consumer !== "server";
-}
 /** Codegen shared by every remote virtual module (no top-level await). */
 function getRemoteModuleRuntimeHelpers() {
 	return `
@@ -6170,12 +6168,16 @@ function getDeferredProxyHelper(remoteCacheKey) {
     function __mfCreateDeferredRemoteProxy() {
       let pendingPromise;
       const ensurePending = () => {
-        pendingPromise ||= __mfStartRemoteLoad();
+        if (!pendingPromise) {
+          pendingPromise = __mfStartRemoteLoad();
+          // Property reads can start a load without an awaiter to handle failure.
+          pendingPromise.then(undefined, () => { pendingPromise = undefined; });
+        }
         return pendingPromise;
       };
       const getModule = () => __mfModuleCache.remote[${JSON.stringify(remoteCacheKey)}];
       const proxyTarget = function (...args) {
-        pendingPromise ||= __mfStartRemoteLoad();
+        ensurePending();
         const mod = getModule();
         const fn = mod && (mod.default ?? mod);
         if (fn !== undefined && fn !== null) {
@@ -6194,7 +6196,7 @@ function getDeferredProxyHelper(remoteCacheKey) {
           if (mod) {
             return prop in mod ? mod[prop] : mod.default?.[prop];
           }
-          pendingPromise ||= __mfStartRemoteLoad();
+          ensurePending();
           if (prop === "default") return proxyTarget;
           throw ensurePending();
         },
@@ -6234,9 +6236,19 @@ function getDeferredProxyHelper(remoteCacheKey) {
     }`;
 }
 function getLazyRemotePendingExport() {
-	return `export const __mf_remote_pending = __mfRemotePending ?? {
+	return `function __mfResetFailedRemotePending(pending) {
+  pending.then(undefined, () => {
+    if (__mfRemotePending === pending) __mfRemotePending = undefined;
+  });
+}
+if (__mfRemotePending) __mfResetFailedRemotePending(__mfRemotePending);
+export const __mf_remote_pending = {
   then(onFulfilled, onRejected) {
-    return (__mfRemotePending ??= __mfStartRemoteLoad().then(__mfAssignRemoteModule)).then(onFulfilled, onRejected);
+    if (!__mfRemotePending) {
+      __mfRemotePending = __mfStartRemoteLoad().then(__mfAssignRemoteModule);
+      __mfResetFailedRemotePending(__mfRemotePending);
+    }
+    return __mfRemotePending.then(onFulfilled, onRejected);
   },
 };`;
 }
@@ -6296,12 +6308,11 @@ export { __mfDefaultExport as default };`;
 function generateRemotes(id, command, enableSsrInit = false, consumer = "unified", options, exportConditions) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const isLoadedFirst = resolvedOptions.shareStrategy === "loaded-first";
-	const initMode = resolveRemoteInitMode(resolvedOptions.shareStrategy, consumer);
-	const deferRemoteLoad = shouldDeferRemoteLoad(initMode);
+	const deferRemoteLoad = shouldDeferRemoteLoad(resolveRemoteInitMode(resolvedOptions.shareStrategy, consumer));
 	const runtimeRemoteId = getRuntimeRemoteId(id, resolvedOptions.remotes, options);
 	const remoteRegistration = getRemoteRegistration(id, resolvedOptions.remotes, options);
 	const registerRemoteCode = isLoadedFirst && remoteRegistration ? `runtime.registerRemotes([${JSON.stringify(remoteRegistration)}]);` : "";
-	const hostAutoInitPath = getHostAutoInitPath(options);
+	const hostAutoInitPath = getHostAutoInitPath(resolvedOptions);
 	const ssrRemotes = getSsrRuntimeRemotes(resolvedOptions.remotes, options);
 	const browserHostInitCode = `import(${JSON.stringify(hostAutoInitPath)})
         .then((mod) => mod.hostInitPromise)
@@ -6314,20 +6325,13 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
     ${command === "serve" && consumer !== "server" ? browserHostInitCode : ""}`;
 	const remoteLoadRuntimePromise = command === "build" ? "__mfHostInitPromise()" : "initPromise";
 	const remoteCacheKey = `${getRuntimeRemoteCachePrefix(options)}${id}`;
-	const remoteLoadFailureHandler = command === "build" ? `.catch((error) => {
-            delete __mfModuleCache.remote[pendingKey];
-            throw error;
-          })` : `.catch((error) => {
-            delete __mfModuleCache.remote[pendingKey];
-            throw error;
-          })`;
 	const remoteLoadCode = `
     function __mfStartRemoteLoad() {
       ${`
       const remoteCacheKey = ${JSON.stringify(remoteCacheKey)};
       const pendingKey = "__mf_pending__" + remoteCacheKey;
       if (!__mfModuleCache.remote[pendingKey]) {
-        __mfModuleCache.remote[pendingKey] = ${remoteLoadRuntimePromise}
+        const pending = ${remoteLoadRuntimePromise}
           .then((runtime) => {
             ${registerRemoteCode}
             const moduleCacheKey = Symbol.for(${JSON.stringify(MODULE_CACHE_SHARE_SCOPE_KEY)});
@@ -6344,22 +6348,25 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
             delete __mfModuleCache.remote[pendingKey];
             return mod;
           })
-          ${remoteLoadFailureHandler};
+          .catch((error) => {
+            if (__mfModuleCache.remote[pendingKey] === pending) {
+              delete __mfModuleCache.remote[pendingKey];
+            }
+            throw error;
+          });
+        __mfModuleCache.remote[pendingKey] = pending;
       }
       return __mfModuleCache.remote[pendingKey];`}
     }`;
 	const realRemoteInit = `__mfRemotePending = __mfStartRemoteLoad().then(__mfAssignRemoteModule);`;
-	const deferredClientInit = `exportModule = __mfCreateDeferredRemoteProxy();`;
-	const eagerLoadClientRemote = id === remoteRegistration?.alias || shouldEagerLoadClientRemoteInDev(command, enableSsrInit);
-	const eagerClientInit = eagerLoadClientRemote ? getEagerDeferredClientInit() : deferredClientInit;
-	const loadedFirstClientInit = eagerLoadClientRemote ? getEagerDeferredClientInit() : deferredClientInit;
+	const clientInit = id === remoteRegistration?.alias || shouldEagerLoadClientRemoteInDev(command, enableSsrInit) ? getEagerDeferredClientInit() : `exportModule = __mfCreateDeferredRemoteProxy();`;
 	const environmentSplitInit = (clientInit, serverInit) => consumer === "client" ? clientInit : consumer === "server" ? serverInit : `if (${SERVER_ENV_GUARD}) {
       ${serverInit}
     } else {
       ${clientInit}
     }`;
-	const initExportModule = initMode === "eager" ? environmentSplitInit(eagerClientInit, realRemoteInit) : environmentSplitInit(loadedFirstClientInit, realRemoteInit);
-	const includeProxyHelper = shouldIncludeDeferredProxy(initMode, consumer, eagerLoadClientRemote, deferRemoteLoad);
+	const initExportModule = environmentSplitInit(clientInit, realRemoteInit);
+	const includeProxyHelper = consumer !== "server";
 	const deferredProxyCode = getDeferredProxyHelper(remoteCacheKey);
 	return `
     ${importLine}
@@ -6380,9 +6387,9 @@ const isPreloadableVirtualMfChunk = (name) => name.includes("virtual_mf") && !na
 const HOST_INIT_PRELOAD_CHUNKS = [
 	(name) => name === "hostInit",
 	(name) => name === "remoteEntry",
-	isPreloadableVirtualMfChunk,
-	(name) => name === "index"
+	isPreloadableVirtualMfChunk
 ];
+const isHostInitPreloadSeed = (chunk) => chunk.isEntry || HOST_INIT_PRELOAD_CHUNKS.some((match) => match(chunk.name));
 const isRemoteWarmupExcluded = (name) => name.includes("__prebuild__") || name.includes("__loadShare__");
 const REMOTE_ENTRY_WARMUP_CHUNKS = [(name) => name === "hostInit", (name) => isPreloadableVirtualMfChunk(name) && !isRemoteWarmupExcluded(name)];
 function getChunksByFileName(bundle) {
@@ -6419,7 +6426,7 @@ function injectHostInitPreloads(html, bundle, resolvePath, externalHrefs = []) {
 		hrefs.push(href);
 	}
 	const chunksByFileName = getChunksByFileName(bundle);
-	const seeds = Array.from(chunksByFileName.values()).filter((chunk) => HOST_INIT_PRELOAD_CHUNKS.some((match) => match(chunk.name)));
+	const seeds = Array.from(chunksByFileName.values()).filter(isHostInitPreloadSeed);
 	for (const fileName of collectPreloadChunkFiles(chunksByFileName, seeds)) {
 		const href = resolvePath(fileName);
 		if (existingHrefs.has(href)) continue;
@@ -6514,7 +6521,7 @@ const ROLLDOWN_RUNTIME_GLOBAL = "__rolldown_runtime__";
 * in every chunk and HMR patch it serves.
 */
 function renameBundledDevRuntime(req, res, remoteName) {
-	if (!req.url || !stripQueryAndHash(req.url).endsWith(".js")) return;
+	if (!req.url || !/\.m?js$/.test(stripQueryAndHash(req.url))) return;
 	const runtimeGlobal = `__mf_rt_${createHash("sha256").update(remoteName).digest("hex").slice(0, 10)}__`;
 	const end = res.end;
 	res.end = function(chunk, ...args) {
@@ -6531,6 +6538,7 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 	const ENTRY_BOOTSTRAP_QUERY = `?${ENTRY_BOOTSTRAP_PARAM}`;
 	const waitsForInit = entryName === "hostInit";
 	const getEntryPath = () => typeof entryPath === "function" ? entryPath() : entryPath;
+	const getFederationOptions = () => federationOptions ?? getNormalizeModuleFederationOptions();
 	let devEntryPath = "";
 	let entryFiles = [];
 	let htmlFilePath;
@@ -6550,8 +6558,14 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 	let isBundledDevRemote = false;
 	let bundledDevRemoteEntryCode;
 	let resolveBundledDevRemoteEntryCode;
+	function isBuildCommand() {
+		return _command === "build" || viteConfig?.command === "build";
+	}
+	function isLoadedFirstClientBuildFor(shareStrategy) {
+		return isBuildCommand() && waitsForInit && !viteConfig?.build?.ssr && shareStrategy === "loaded-first";
+	}
 	function skipSvelteKitSsrBuild() {
-		return (_command === "build" || viteConfig?.command === "build") && viteConfig?.build?.ssr && hasPackageDependency("@sveltejs/kit");
+		return isBuildCommand() && viteConfig?.build?.ssr && hasPackageDependency("@sveltejs/kit");
 	}
 	function isSvelteKitServerModule(id) {
 		return hasPackageDependency("@sveltejs/kit") && (id.includes(".svelte-kit/generated/") || id.includes("/@sveltejs/kit/src/runtime/server/"));
@@ -6586,10 +6600,6 @@ const __mfCurrentScript = document.currentScript;
 	function walkHtmlFiles(dir) {
 		return walkFiles(dir, (fileName) => fileName.endsWith(".html"));
 	}
-	function toRelativeImport(fromFile, targetFile) {
-		const relative = normalizePathForImport(path$1.relative(path$1.dirname(fromFile), targetFile));
-		return relative.startsWith(".") ? relative : `./${relative}`;
-	}
 	function patchSvelteKitStaticHtml() {
 		const buildDir = path$1.resolve(viteConfig.root, "build");
 		let initFile = emittedFileName ? path$1.resolve(buildDir, emittedFileName) : void 0;
@@ -6610,10 +6620,10 @@ const __mfCurrentScript = document.currentScript;
 		return patched;
 	}
 	function getRemoteEntryPreloadUrls() {
-		const normalizedOptions = federationOptions ?? getNormalizeModuleFederationOptions();
-		const isLoadedFirstClientBuild = (_command === "build" || viteConfig?.command === "build") && waitsForInit && !viteConfig?.build?.ssr && normalizedOptions.shareStrategy === "loaded-first";
+		const normalizedOptions = getFederationOptions();
+		const isLoadedFirstClientBuild = isLoadedFirstClientBuildFor(normalizedOptions.shareStrategy);
 		if (normalizedOptions.shareStrategy === "loaded-first" && !isLoadedFirstClientBuild) return [];
-		const remoteSources = isLoadedFirstClientBuild ? Array.from(getPreloadRemotes(normalizedOptions)) : Object.keys(getUsedRemotesMap(federationOptions));
+		const remoteSources = isLoadedFirstClientBuild ? Array.from(getPreloadRemotes(normalizedOptions)) : Object.keys(getUsedRemotesMap(normalizedOptions));
 		return Array.from(new Set(remoteSources.flatMap((remote) => {
 			const registration = getRemoteRegistration(remote, normalizedOptions.remotes, federationOptions);
 			return registration && (registration.type === "module" || registration.type === "esm") && /^(?:https?:)?\/\//.test(registration.entry) && !/\.json(?:[?#]|$)/i.test(registration.entry) ? [registration.entry] : [];
@@ -6652,10 +6662,10 @@ const __mfCurrentScript = document.currentScript;
 		const entryImportDeclaration = isEncodedVirtualEntry ? `const __mfEntryUrl = ${JSON.stringify(entrySrc)};
 ` : "";
 		const entryImportExpression = isEncodedVirtualEntry ? "import(/* @vite-ignore */ __mfEntryUrl)" : importExpression(entrySrc);
-		const normalizedOptions = federationOptions ?? getNormalizeModuleFederationOptions();
-		const isLoadedFirstClientBuild = (_command === "build" || viteConfig?.command === "build") && waitsForInit && !viteConfig?.build?.ssr && normalizedOptions.shareStrategy === "loaded-first";
+		const normalizedOptions = getFederationOptions();
+		const isLoadedFirstClientBuild = isLoadedFirstClientBuildFor(normalizedOptions.shareStrategy);
 		const shouldPreloadRemotes = !options?.skipRemotePreload && (normalizedOptions.shareStrategy !== "loaded-first" || isLoadedFirstClientBuild);
-		const remoteSources = isLoadedFirstClientBuild ? Array.from(getPreloadRemotes(normalizedOptions)) : Object.entries(getUsedRemotesMap(federationOptions)).flatMap(([, remotes]) => Array.from(remotes)).filter((remote) => !federationOptions || !isDynamicOnlyRemote(remote, federationOptions));
+		const remoteSources = isLoadedFirstClientBuild ? Array.from(getPreloadRemotes(normalizedOptions)) : Object.entries(getUsedRemotesMap(normalizedOptions)).flatMap(([, remotes]) => Array.from(remotes)).filter((remote) => !federationOptions || !isDynamicOnlyRemote(remote, federationOptions));
 		const remotePreloads = shouldPreloadRemotes ? remoteSources.sort().map((remote) => {
 			const registration = isLoadedFirstClientBuild ? getRemoteRegistration(remote, normalizedOptions.remotes, federationOptions) : void 0;
 			return `__mfPreloadRemote(${JSON.stringify(getRuntimeRemoteId(remote, normalizedOptions.remotes, federationOptions))}, ${JSON.stringify(remote)}${registration ? `, ${JSON.stringify(registration)}` : ""})`;
@@ -6670,7 +6680,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			const shareItem = getNormalizeShareItem(pkg, federationOptions);
 			const isExplicitShare = Object.hasOwn(federationOptions.shared, pkg);
 			return shareItem?.shareConfig?.singleton === true && shareItem?.shareConfig?.import !== false && !shareItem?.shareConfig?.treeShaking && (isExplicitShare || typeof shareItem?.shareConfig?.import === "string" || Boolean(getProjectResolvedImportPath(pkg)));
-		}).map((pkg) => getLoadShareModulePath(pkg, false, federationOptions)) : [];
+		}).map((pkg) => getLoadShareModulePath(pkg, federationOptions)) : [];
 		const sharedPreloadBlock = sharedPreloadSources.length === 0 ? "" : options?.isBundled ? `
   await Promise.all([${sharedPreloadSources.map((src) => `[${JSON.stringify(src)}, import(${JSON.stringify(src)})]`).join(", ")}].map(([src, load]) => load.catch((err) => console.warn("[module-federation] shared preload failed:", src, err))));` : `
   const __mfSharedPreloadUrls = ${JSON.stringify(sharedPreloadSources.map(toViteEncodedId))};
@@ -6708,8 +6718,8 @@ 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);
+		const pendingSharesBlock = waitsForInit && isBuildCommand() ? `
+  const __mfPendingShares = await ${importExpression(options?.pendingSharesSrc ?? getPendingSharesPath(getFederationOptions()))}.catch(() => undefined);
   if (__mfPendingShares && typeof __mfPendingShares.preloadPendingShares === "function") await __mfPendingShares.preloadPendingShares();` : "";
 		const importCode = `
 (async () => {
@@ -6961,6 +6971,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 				if (resolved && !resolved.external && (_command === "serve" || !resolved.id.startsWith("\0"))) addEntryFile(resolveProjectId(resolved.id));
 			}
 			if (_command === "serve") return;
+			if (entryName === "hostInit" && federationOptions && !hasRemotes(federationOptions) && isServerBuildContext(this, viteConfig)) return;
 			if (skipSvelteKitSsrBuild()) return;
 			if (this.environment?.name === "ssr") return;
 			const hasHash = fileName?.includes?.("[hash");
@@ -6975,7 +6986,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			if (waitsForInit) pendingSharesEmitId = this.emitFile({
 				name: "pendingShares",
 				type: "chunk",
-				id: getPendingSharesPath(federationOptions),
+				id: getPendingSharesPath(getFederationOptions()),
 				preserveSignature: "strict"
 			});
 			if (htmlFilePath) addHtmlScriptEntries(htmlFilePath);
@@ -6984,7 +6995,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			if (isBundledDevRemote && _command === "serve") {
 				const remoteEntryChunk = Object.values(bundle).find((output) => output.type === "chunk" && output.isEntry && output.facadeModuleId === getEntryPath());
 				if (remoteEntryChunk?.type === "chunk") {
-					const code = `export { ${remoteEntryChunk.exports.join(", ")} } from ${JSON.stringify(`./${remoteEntryChunk.fileName}`)};\n`;
+					const code = `${Object.values(bundle).some((output) => output.type === "chunk" && output.code.includes("new ViteDevRuntime(")) ? "" : `import ${JSON.stringify(`${viteConfig.base}bundledDevClient.mjs`)};\n`}export { ${remoteEntryChunk.exports.join(", ")} } from ${JSON.stringify(`./${remoteEntryChunk.fileName}`)};\n`;
 					bundledDevRemoteEntryCode = Promise.resolve(code);
 					resolveBundledDevRemoteEntryCode?.(code);
 				}
@@ -7027,7 +7038,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			let bootstrapIndex = 0;
 			for (const fileName of htmlFileNames) {
 				let htmlAsset = bundle[fileName];
-				if (htmlAsset.type === "chunk") return;
+				if (htmlAsset.type === "chunk") continue;
 				let htmlContent = htmlAsset.source.toString() || "";
 				const initPath = resolvePath(file, fileName);
 				const scriptRegex = /<script\b(?=[^>]*\btype=["']module["'])(?=[^>]*\bsrc=["']([^"']+)["'])[^>]*>\s*<\/script>/gi;
@@ -7077,7 +7088,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 		load(id) {
 			return virtualEntryCode.get(id);
 		},
-		transform(code, id) {
+		transform(code, id, transformOptions) {
 			if (skipSvelteKitSsrBuild()) return;
 			if (viteConfig?.command === "build" && !waitsForInit) return;
 			if (isSvelteKitServerModule(id)) return;
@@ -7089,7 +7100,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			if (normalizeModuleId(id).endsWith(".html")) return;
 			const projectId = resolveProjectId(id);
 			if (skipTransformIds.has(projectId)) return;
-			if (!isClientEnvironment(this)) return;
+			if (isServerBuildContext(this, viteConfig) || transformOptions?.ssr) return;
 			const isVinext = hasPackageDependency("vinext");
 			if (isVinext && inject === "html" && id.includes("virtual:vite-rsc/remove-duplicate-server-css")) {
 				const namespaceReactImport = `import * as React from 'react';`;
@@ -7390,21 +7401,6 @@ 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";
@@ -7412,7 +7408,7 @@ const REMOTE_HMR_CONNECT_RETRY_DELAY_MS = 1e3;
 const REMOTE_HMR_CONNECT_MAX_RETRIES = 10;
 function getBasePath(base) {
 	if (!base) return "/";
-	if (base.startsWith("http://") || base.startsWith("https://")) try {
+	if (isHttpUrl(base)) try {
 		return new URL(base).pathname || "/";
 	} catch {
 		return "/";
@@ -7511,14 +7507,8 @@ function setupRemoteBroadcast(server, options) {
 			}
 		});
 	};
-	server.watcher.on("change", broadcast);
-	server.watcher.on("add", broadcast);
-	server.watcher.on("unlink", broadcast);
-	server.httpServer?.once("close", () => {
-		server.watcher.off("change", broadcast);
-		server.watcher.off("add", broadcast);
-		server.watcher.off("unlink", broadcast);
-	});
+	const stopWatching = watchFileEvents(server.watcher, broadcast);
+	server.httpServer?.once("close", stopWatching);
 }
 /**
 * Installs the host-side full-reload relay. For each configured remote:
@@ -7580,9 +7570,13 @@ function setupHostFullReloadRelay(server, options) {
 				if (!message || message.event !== "mf:remote-update") return;
 				server.ws.send({ type: "full-reload" });
 			};
-			ws.onopen = () => clearReconnectTimer(remoteName);
+			let opened = false;
+			ws.onopen = () => {
+				opened = true;
+				clearReconnectTimer(remoteName);
+			};
 			ws.onerror = (error) => mfWarn(`Remote HMR socket error for "${remoteName}":`, error);
-			ws.onclose = () => scheduleReconnect(remoteName, remote, attempt, "socket closed");
+			ws.onclose = () => scheduleReconnect(remoteName, remote, opened ? 0 : attempt, "socket closed");
 			connections.push(ws);
 		} catch (error) {
 			mfWarn(`Failed to connect remote HMR for "${remoteName}" on attempt ${attempt + 1}: ${getStringPreview(error)}`);
@@ -7603,9 +7597,7 @@ function setupHostFullReloadRelay(server, options) {
 		if (shouldIgnoreFile(file, options)) return;
 		server.ws.send({ type: "full-reload" });
 	};
-	server.watcher.on("change", triggerHostReload);
-	server.watcher.on("add", triggerHostReload);
-	server.watcher.on("unlink", triggerHostReload);
+	watchFileEvents(server.watcher, triggerHostReload);
 	server.httpServer?.once("close", teardown);
 }
 //#endregion
@@ -7676,8 +7668,8 @@ function collectHostTags(server, options, adapters) {
 	return tags;
 }
 function pluginDevRemoteHmr(options) {
-	const isHost = Object.keys(options.remotes).length > 0;
-	const isRemote = Object.keys(options.exposes).length > 0;
+	const isHost = hasRemotes(options);
+	const isRemote = isRemoteContainer(options);
 	let adapters = [];
 	let strategy = "full-reload";
 	let root;
@@ -7955,9 +7947,10 @@ function pluginExternalRuntimeCore() {
 //#endregion
 //#region src/virtualModules/index.ts
 function initVirtualModules(command, remoteEntryId, enableSsrInit = false, options) {
-	writeLocalSharedImportMap(options);
-	writeHostAutoInit(remoteEntryId, command, options);
-	writeRuntimeInitStatus(command, enableSsrInit, getHostAutoInitPath(options), options, options ? getSsrRuntimeRemotes(options.remotes, options) : void 0);
+	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
+	writeLocalSharedImportMap(resolvedOptions);
+	writeHostAutoInit(remoteEntryId, command, resolvedOptions);
+	writeRuntimeInitStatus(command, enableSsrInit, getHostAutoInitPath(resolvedOptions), options, options ? getSsrRuntimeRemotes(options.remotes, options) : void 0);
 }
 //#endregion
 //#region src/utils/cssModuleHelpers.ts
@@ -8206,16 +8199,15 @@ function pluginLazyConsumeOnlyShares(options) {
 		renderChunk(code, chunk, _outputOptions, meta) {
 			const renderedChunk = chunk;
 			const chunks = meta?.chunks;
-			if (!chunks || Object.keys(options.exposes).length === 0) return null;
+			if (!chunks || !isRemoteContainer(options)) return null;
 			if (isServerBuildContext(this, viteConfig)) return null;
 			let graph = graphs.get(chunks);
 			if (!graph) {
-				const isRolldown = getIsRolldown(this);
 				const wrapperShares = /* @__PURE__ */ new Map();
 				for (const shareKey of getUsedShares(options)) {
 					const shareConfig = getNormalizeShareItem(shareKey, options)?.shareConfig;
 					if (shareConfig?.import !== false || shareConfig.eager || shareConfig.treeShaking) continue;
-					wrapperShares.set(normalizeVirtualModuleId(getLoadShareModulePath(shareKey, isRolldown, options)), shareKey);
+					wrapperShares.set(normalizeVirtualModuleId(getLoadShareModulePath(shareKey, options)), shareKey);
 				}
 				const root = viteConfig?.root ?? process.cwd();
 				graph = buildLazyShareGraph(chunks, wrapperShares, new Set(Object.values(options.exposes).map((expose) => stripKnownJsExtension(path$1.resolve(root, expose.import)))));
@@ -8235,15 +8227,16 @@ function pluginLazyConsumeOnlyShares(options) {
 				break;
 			}
 			const chunkDir = path$1.posix.dirname(renderedChunk.fileName);
-			const codePositions = createCodePositionMap(code);
+			let codePositions;
 			let usesHelper = false;
 			for (const match of isImportMapChunk ? [] : code.matchAll(DYNAMIC_IMPORT_REGEX)) {
 				const [expression, , specifier] = match;
 				const start = match.index;
-				if (!codePositions[start]) continue;
 				const target = path$1.posix.normalize(path$1.posix.join(chunkDir, specifier));
 				const shares = graph.sharesByChunk.get(target);
 				if (!shares || !renderedChunk.dynamicImports.includes(target)) continue;
+				codePositions ??= createCodePositionMap(code);
+				if (!codePositions[start]) continue;
 				rewriter.overwrite(start, start + expression.length, `${helperName}(${JSON.stringify(shares)}).then(() => ${expression})`);
 				usesHelper = edited = true;
 			}
@@ -8266,7 +8259,7 @@ function ${helperName}(names) {
 }
 //#endregion
 //#region package.json
-var version$1 = "1.23.4";
+var version$1 = "1.23.6";
 //#endregion
 //#region src/virtualModules/virtualExposesSSR.ts
 /**
@@ -8363,7 +8356,7 @@ function generateRemoteEntrySSR(options) {
 	const virtualExposesSSRId = getVirtualExposesSSRId(options);
 	const sharedSingletons = getSsrSharedSingletons(options);
 	return `
-  import { init as runtimeInit } from "@module-federation/runtime";
+  ${hasRemotes(options) ? `import { hostInitPromise } from ${JSON.stringify(getHostAutoInitPath(options))};` : "import { init as runtimeInit } from \"@module-federation/runtime\";"}
 
   const sharedSingletons = ${JSON.stringify(sharedSingletons)};
   const moduleCacheKey = Symbol.for(${JSON.stringify(MODULE_CACHE_SHARE_SCOPE_KEY)});
@@ -8393,11 +8386,11 @@ function generateRemoteEntrySSR(options) {
    * to set up a minimal runtime instance for the remote container.
    */
   async function init(shared = {}, initScope = []) {
-    const initRes = runtimeInit({
+    const initRes = ${hasRemotes(options) ? "await hostInitPromise" : `runtimeInit({
       name: ${JSON.stringify(options.name)},
       remotes: [],
       shared: {},
-    });
+    })`};
     if (initScope.indexOf(initToken) >= 0) return;
     initScope.push(initToken);
     const shareScopeNames = Array.isArray(${JSON.stringify(options.shareScope)})
@@ -8542,13 +8535,13 @@ function collectImportedCss(chunks) {
 * dependency even though the expose statically imports it. Advertising it as a sync
 * asset makes a preloader fetch a provider the host is going to supply anyway.
 */
-function collectDeferredShareModules(options, isRolldown) {
+function collectDeferredShareModules(options) {
 	const deferred = /* @__PURE__ */ new Set();
 	for (const shareKey of getUsedShares(options)) {
 		const shareConfig = getNormalizeShareItem(shareKey, options)?.shareConfig;
 		if (shareConfig?.eager === true) continue;
 		if (shareConfig?.import === false) continue;
-		deferred.add(normalizeVirtualModuleId(getLoadShareModulePath(shareKey, isRolldown, options)));
+		deferred.add(normalizeVirtualModuleId(getLoadShareModulePath(shareKey, options)));
 	}
 	return deferred;
 }
@@ -8563,9 +8556,9 @@ function isDeferredShareChunk(chunk, deferredShareModules) {
 	if (!chunk || chunk.type !== "chunk" || deferredShareModules.size === 0) return false;
 	return [chunk.facadeModuleId, ...chunk.moduleIds ?? []].some((id) => typeof id === "string" && deferredShareModules.has(normalizeVirtualModuleId(id)));
 }
-function expandExposeAssets(filesMap, exposeModules, bundle, remoteEntryFileName, options, isRolldown) {
+function expandExposeAssets(filesMap, exposeModules, bundle, remoteEntryFileName, options) {
 	if (exposeModules.length === 0) return;
-	const deferredShareModules = collectDeferredShareModules(options, isRolldown);
+	const deferredShareModules = collectDeferredShareModules(options);
 	const containerChunks = remoteEntryFileName ? collectStaticChunks(bundle, [remoteEntryFileName]) : [];
 	const bootstrapChunks = containerChunks.slice(1);
 	const seen = new Set(containerChunks.map((chunk) => chunk.fileName));
@@ -8624,15 +8617,8 @@ const Manifest = (providedOptions) => {
 	const { name, filename, getPublicPath, manifest: manifestOptions, varFilename } = mfOptions;
 	let mfManifestName = manifestOptions === true ? "mf-manifest.json" : typeof manifestOptions === "object" ? normalizePathForImport(path$1.join(manifestOptions?.filePath || "", manifestOptions?.fileName || "mf-manifest.json")) : void 0;
 	let mfManifestStatsName = mfManifestName ? getStatsFileName(mfManifestName) : void 0;
-	const isConsumerProject = Object.keys(mfOptions.exposes).length === 0;
+	const isConsumerProject = !isRemoteContainer(mfOptions);
 	let disableAssetsAnalyze = false;
-	const getDefaultDisableAssetsAnalyze = (command) => command === "serve" && isConsumerProject && (typeof manifestOptions !== "object" || !Object.hasOwn(manifestOptions, "disableAssetsAnalyze"));
-	const getConfiguredDisableAssetsAnalyze = (command) => {
-		if (typeof manifestOptions === "object" && manifestOptions !== null) {
-			if (Object.hasOwn(manifestOptions, "disableAssetsAnalyze")) return manifestOptions.disableAssetsAnalyze === true;
-		}
-		return getDefaultDisableAssetsAnalyze(command);
-	};
 	let root;
 	let remoteEntryFile;
 	let ssrRemoteEntryFile;
@@ -8660,7 +8646,7 @@ const Manifest = (providedOptions) => {
 		configureServer(server) {
 			server.middlewares.use((req, res, next) => {
 				const devRemoteEntryFile = resolveHashPlaceholderFileName(filename);
-				if (devRemoteEntryFile !== filename && Object.keys(mfOptions.exposes).length > 0 && req.url?.startsWith((viteConfig.base + devRemoteEntryFile).replace(/^\/?/, "/"))) {
+				if (devRemoteEntryFile !== filename && isRemoteContainer(mfOptions) && req.url?.startsWith((viteConfig.base + devRemoteEntryFile).replace(/^\/?/, "/"))) {
 					req.url = req.url.replace(devRemoteEntryFile, filename);
 					next();
 					return;
@@ -8703,7 +8689,7 @@ const Manifest = (providedOptions) => {
 								types: resolveTypesMeta(mfOptions.dts),
 								globalName: name,
 								pluginVersion: version$1,
-								publicPath
+								...getPublicPath ? { getPublicPath } : { publicPath }
 							}
 						});
 						res.end(JSON.stringify(manifest));
@@ -8723,7 +8709,7 @@ const Manifest = (providedOptions) => {
 			_command = command;
 			if (!config.build) config.build = {};
 			if (!config.build.manifest) config.build.manifest = config.build.manifest || !!mfManifestName;
-			disableAssetsAnalyze = getConfiguredDisableAssetsAnalyze(command);
+			disableAssetsAnalyze = resolveDisableAssetsAnalyze(manifestOptions, command === "serve" && isConsumerProject);
 			_originalConfigBase = config.base;
 		},
 		configResolved(config) {
@@ -8802,7 +8788,7 @@ const Manifest = (providedOptions) => {
 					root,
 					stripKnownJsExtensions: true
 				});
-				expandExposeAssets(filesMap, exposesModules, bundle, foundRemoteEntryFile, mfOptions, getIsRolldown(this));
+				expandExposeAssets(filesMap, exposesModules, bundle, foundRemoteEntryFile, mfOptions);
 				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 = {
@@ -8988,43 +8974,89 @@ function getStatsFileName(manifestFileName) {
 //#endregion
 //#region src/utils/sharedSource.ts
 const pendingEntryLookups = /* @__PURE__ */ new Map();
+const pendingLookupImporters = /* @__PURE__ */ new Map();
+const increment = (map, key) => map.set(key, (map.get(key) ?? 0) + 1);
+const decrement = (map, key) => {
+	const remaining = map.get(key) - 1;
+	if (remaining) map.set(key, remaining);
+	else map.delete(key);
+};
 const getEntryLookupKey = (source, importer) => `${source}\0${importer}`;
+/**
+* Rolldown saves each this.resolve() call's options under the map's current size and deletes the
+* entry when the call settles, so an overlapping call can receive the wrong `custom` metadata.
+* Taking the first free key keeps every in-flight entry intact. A no-op when the internals differ.
+*/
+function patchRolldownResolveOptionKeys(context) {
+	const data = context?.data;
+	const map = data?.resolveOptionsMap;
+	if (!data || !(map instanceof Map) || typeof data.saveResolveOptions !== "function") return;
+	if (data.__mfFreeKeyPatch) return;
+	data.saveResolveOptions = (options) => {
+		let index = map.size;
+		while (map.has(index)) index++;
+		map.set(index, options);
+		return index;
+	};
+	data.__mfFreeKeyPatch = true;
+}
 /** Whether a resolveId call is one of the shared source resolver's own entry lookups. */
 function isSharedEntryLookup(source, importer, options) {
-	return options.custom?.__mfSharedEntryLookup === true || pendingEntryLookups.has(getEntryLookupKey(source, importer));
+	if (pendingEntryLookups.has(getEntryLookupKey(source, importer))) return true;
+	return options?.custom?.__mfSharedEntryLookupImporter === importer && pendingLookupImporters.has(importer);
 }
 /**
 * Runs one of the plugin's own `this.resolve()` calls (a shared entry lookup, a
-* parse-barrier external probe), marked so `isSharedEntryLookup` recognizes it
+* parse-barrier external probe), tracked so `isSharedEntryLookup` recognizes it
 * and the share hooks neither proxy it nor register a used share for it.
 */
 async function resolveInternally(context, source, importer, options = {}) {
 	const lookupKey = getEntryLookupKey(source, importer);
-	pendingEntryLookups.set(lookupKey, (pendingEntryLookups.get(lookupKey) ?? 0) + 1);
+	increment(pendingEntryLookups, lookupKey);
+	increment(pendingLookupImporters, importer);
 	try {
 		return await context.resolve(source, importer, {
 			...options,
-			skipSelf: true,
 			custom: {
 				...options.custom,
-				__mfSharedEntryLookup: true
-			}
+				__mfSharedEntryLookupImporter: importer
+			},
+			skipSelf: true
 		});
 	} finally {
-		const remaining = pendingEntryLookups.get(lookupKey) - 1;
-		if (remaining) pendingEntryLookups.set(lookupKey, remaining);
-		else pendingEntryLookups.delete(lookupKey);
+		decrement(pendingEntryLookups, lookupKey);
+		decrement(pendingLookupImporters, importer);
 	}
 }
 /** 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 wildcardSubpathCaches = /* @__PURE__ */ new Map();
+	async function resolveEntry(context, request, options, { root, conditions }) {
+		if (!path$1.isAbsolute(request) && !isPackageExportAvailable(request, {
+			cwd: root,
+			conditions
+		})) return void 0;
+		const importer = path$1.join(root, "package.json");
+		try {
+			const resolved = await resolveInternally(context, request, importer, options);
+			return resolved && !resolved.external ? resolved.id : void 0;
+		} catch {
+			return;
+		}
+	}
+	async function matchEntry(source, suffix, entryOptions, 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);
+		const packageSubpath = suffix.slice(packageName.length + 1);
+		if (packageSubpath) {
+			for (const specifier of getPackageExportSpecifiersForFile(packageName, packageSubpath, {
+				...entryOptions,
+				fromResolvedEntry: source
+			})) if (findSharedKey(specifier, shared)) candidates.add(specifier);
+		}
 		for (const key of Object.keys(shared)) {
 			const request = getSharedRequest(key, shared[key]);
 			if (getPackageName(request) !== packageName) continue;
@@ -9044,6 +9076,7 @@ function createSharedSourceResolver(shared, getResolutionConfig) {
 	return {
 		clear() {
 			caches.clear();
+			wildcardSubpathCaches.clear();
 		},
 		async resolve(context, source, options = {}) {
 			if (source.startsWith("\0") || source.includes("#")) return;
@@ -9054,32 +9087,39 @@ function createSharedSourceResolver(shared, getResolutionConfig) {
 				"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);
+			const getCache = (byEnvironment) => {
+				if (!cacheable) return;
+				let cache = byEnvironment.get(environment);
+				if (!cache) {
+					cache = /* @__PURE__ */ new Map();
+					byEnvironment.set(environment, cache);
+				}
+				return cache;
+			};
+			const directKey = findSharedKey(source, shared);
+			if (directKey) {
+				const request = getSharedRequest(directKey, shared[directKey]);
+				if (!(request.endsWith("/") && source !== removeTrailingSlash(request) && !getCommonSharedSubpaths(request).includes(source))) return source;
+				const cache = getCache(wildcardSubpathCaches);
+				let resolvable = cache?.get(source);
+				if (resolvable === void 0) {
+					resolvable = await resolveEntry(context, source, options, getResolutionConfig(context, options)) !== void 0;
+					cache?.set(source, resolvable);
+				}
+				return resolvable ? source : void 0;
 			}
+			const suffix = getNodeModulesSuffix(source);
+			if (!suffix) return;
+			const normalizedSource = stripViteFsPrefix(normalizeNodeModulePath(source));
+			const cache = getCache(caches);
 			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;
-				const importer = path$1.join(root, "package.json");
-				try {
-					const resolved = await resolveInternally(context, request, importer, options);
-					return resolved && !resolved.external ? resolved.id : void 0;
-				} catch {
-					return;
-				}
-			});
+			const config = getResolutionConfig(context, options);
+			const result = await matchEntry(normalizedSource, suffix, {
+				cwd: config.root,
+				conditions: config.conditions
+			}, (request) => resolveEntry(context, request, options, config));
 			cache?.set(normalizedSource, result);
 			return result;
 		}
@@ -9101,6 +9141,8 @@ function createModuleParseController() {
 		discardWarned: false,
 		externalSet: /* @__PURE__ */ new Set(),
 		resolutionProbed: /* @__PURE__ */ new Set(),
+		reached: /* @__PURE__ */ new Set(),
+		deferredImports: /* @__PURE__ */ new Map(),
 		lastLoadedModule: "",
 		lastParsedModule: ""
 	};
@@ -9124,6 +9166,8 @@ function resetParseState(controller) {
 	controller.parseEndSet = /* @__PURE__ */ new Set();
 	controller.externalSet = /* @__PURE__ */ new Set();
 	controller.resolutionProbed = /* @__PURE__ */ new Set();
+	controller.reached = /* @__PURE__ */ new Set();
+	controller.deferredImports = /* @__PURE__ */ new Map();
 	controller.discardWarned = false;
 	controller.lastLoadedModule = "";
 	controller.lastParsedModule = "";
@@ -9195,12 +9239,14 @@ function pluginModuleParseEnd_default(excludeFn, options, controller = createMod
 		},
 		async buildStart() {
 			resetParseState(controller);
-			if (idleTimeout) resetIdleTimeout(controller, idleTimeout);
-			else if (options.moduleParseTimeout) setParseTimeout(controller, options.moduleParseTimeout);
+			if (!idleTimeout && options.moduleParseTimeout) setParseTimeout(controller, options.moduleParseTimeout);
 			const entryImports = /* @__PURE__ */ new Set([...options.exposedModuleImports || [], ...configuredInputImports]);
 			for (const importSource of entryImports) {
 				const resolved = await this.resolve(importSource);
-				if (resolved && !resolved.external && !excludeFn(resolved.id)) controller.parseStartSet.add(resolved.id);
+				if (resolved && !resolved.external && !excludeFn(resolved.id)) {
+					controller.parseStartSet.add(resolved.id);
+					controller.reached.add(resolved.id);
+				}
 			}
 		},
 		load(id) {
@@ -9221,7 +9267,11 @@ function pluginModuleParseEnd_default(excludeFn, options, controller = createMod
 			if (idleTimeout) resetIdleTimeout(controller, idleTimeout);
 			const parsedModule = module;
 			const addPendingResolutions = (resolutions) => {
-				for (const resolution of resolutions || []) if (!resolution.external && !excludeFn(resolution.id)) controller.parseStartSet.add(resolution.id);
+				for (const resolution of resolutions || []) {
+					if (resolution.external) continue;
+					if (excludeFn(resolution.id)) reach(resolution.id);
+					else addPending(resolution.id);
+				}
 			};
 			const probeExternal = (pendingId) => {
 				if (typeof this.resolve !== "function") return;
@@ -9236,15 +9286,39 @@ function pluginModuleParseEnd_default(excludeFn, options, controller = createMod
 			};
 			const addPendingIds = (ids) => {
 				for (const pendingId of ids || []) {
-					if (controller.externalSet.has(pendingId) || matchesExternal(configuredExternal, pendingId, id) || excludeFn(pendingId)) continue;
-					controller.parseStartSet.add(pendingId);
+					if (controller.externalSet.has(pendingId) || matchesExternal(configuredExternal, pendingId, id)) continue;
+					if (excludeFn(pendingId)) {
+						reach(pendingId);
+						continue;
+					}
+					addPending(pendingId);
 					if (!controller.parseEndSet.has(pendingId)) probeExternal(pendingId);
 				}
 			};
-			addPendingResolutions(parsedModule.importedIdResolutions);
-			addPendingResolutions(parsedModule.dynamicallyImportedIdResolutions);
-			if (parsedModule.importedIdResolutions === void 0) addPendingIds(module.importedIds);
-			if (parsedModule.dynamicallyImportedIdResolutions === void 0) addPendingIds(module.dynamicallyImportedIds);
+			const seedImports = (resolutions, ids) => {
+				if (resolutions === void 0) addPendingIds(ids);
+				else addPendingResolutions(resolutions);
+			};
+			const reach = (moduleId) => {
+				if (controller.reached.has(moduleId)) return;
+				controller.reached.add(moduleId);
+				const seedDeferred = controller.deferredImports.get(moduleId);
+				controller.deferredImports.delete(moduleId);
+				seedDeferred?.();
+			};
+			const addPending = (pendingId) => {
+				controller.parseStartSet.add(pendingId);
+				reach(pendingId);
+			};
+			const seedAllImports = () => {
+				seedImports(parsedModule.importedIdResolutions, module.importedIds);
+				seedImports(parsedModule.dynamicallyImportedIdResolutions, module.dynamicallyImportedIds);
+			};
+			if (module.isEntry === false && !controller.reached.has(id)) controller.deferredImports.set(id, seedAllImports);
+			else {
+				controller.reached.add(id);
+				seedAllImports();
+			}
 			if (!excludeFn(id)) controller.parseEndSet.add(id);
 			scheduleParseCompletionCheck(controller);
 		},
@@ -9257,80 +9331,256 @@ function pluginModuleParseEnd_default(excludeFn, options, controller = createMod
 	}];
 }
 //#endregion
-//#region src/plugins/pluginProxyRemoteEntry.ts
-function resolveAbsoluteDevRemoteEntryUrl(publicPath, fileName) {
-	const base = new URL(publicPath);
-	base.pathname = ensureTrailingSlash(base.pathname);
-	return new URL(fileName, base).href;
+//#region src/utils/hostProvidesAllShared.ts
+/** Virtual-module prefix of the host's per-share re-export entries. */
+const SHARE_MODULE_PREFIX = "\0mf-host-provided-share:";
+/** `./a/b` → `a/b`, `.` → `index`: the fixed entry name of an expose, without `.js`. */
+function exposeEntryName(exposeKey) {
+	return exposeKey === "." ? "index" : exposeKey.replace(/^\.\//, "");
 }
-function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposesId, getParsePromise = () => Promise.resolve() }) {
-	let viteConfig, _command, root, originalConfigBase;
-	let exposeRemoteDependencies = {};
-	let exposeRemoteDependenciesDirty = true;
-	let refreshPromise;
-	let dependencyInvalidationVersion = 0;
-	let reactIslandExposes = /* @__PURE__ */ new Set();
-	const isHostAutoInitId = (id) => {
-		const cleanId = id.split("?")[0];
-		return cleanId.includes(getHostAutoInitPath(options)) || cleanId.includes(getHostAutoInitPath());
-	};
-	const getEnvironmentConditions = (context) => context.environment?.config?.resolve?.conditions;
-	const isSsrBuild = (context) => isServerBuildContext(context, viteConfig);
-	function isRemoteImport(source) {
-		return Object.keys(options.remotes).some((name) => source === name || source.startsWith(name + "/"));
-	}
-	function collectImportSources(code) {
-		const sources = /* @__PURE__ */ new Map();
-		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,
-			dynamic
-		})).sort((a, b) => a.source.localeCompare(b.source));
-	}
-	function shouldScanResolvedImport(id) {
-		if (!id || id.includes("\0")) return false;
-		if (id.includes("/node_modules/") || id.includes("\\node_modules\\")) return false;
-		return /\.(?:[cm]?[jt]sx?|vue|svelte)(?:\?|$)/.test(id);
-	}
-	async function collectRemoteDependencies(ctx, id, seen = /* @__PURE__ */ new Set()) {
-		if (seen.has(id) || !shouldScanResolvedImport(id)) return [];
-		seen.add(id);
-		let code;
-		try {
-			code = getScannableModuleSource(id, readFileSync$1(id, "utf8"));
-		} catch {
-			return [];
-		}
-		const dependencies = /* @__PURE__ */ new Set();
-		for (const { source, dynamic } of collectImportSources(code)) {
-			if (isRemoteImport(source)) {
-				if (!dynamic) dependencies.add(source);
-				continue;
-			}
-			let resolved;
-			try {
-				resolved = await ctx.resolve(source, id);
-			} catch {
-				continue;
-			}
-			if (!resolved?.id || !shouldScanResolvedImport(resolved.id)) continue;
-			for (const dependency of await collectRemoteDependencies(ctx, resolved.id, seen)) dependencies.add(dependency);
+/** Bare specifier a host uses for an expose: `remote` for `.`, `remote/a/b` otherwise. */
+function remoteSpecifier(remoteName, exposeKey) {
+	const entry = exposeEntryName(exposeKey);
+	return entry === "index" ? remoteName : `${remoteName}/${entry}`;
+}
+/** `id` is a remote alias or a subpath of one. */
+function isRemoteSpecifier(id, remoteKeys) {
+	return remoteKeys.some((key) => id === key || id.startsWith(`${key}/`));
+}
+/**
+* The shared key that owns `id`: an exact match, else the longest key `id` is a subpath
+* of (`lodash-es/debounce` → `lodash-es`). Used to spot an unshared subpath of a shared
+* package, which would bundle a private copy of that package into a remote.
+*/
+function sharedKeyOwning(id, sharedKeys) {
+	let owner;
+	for (const key of sharedKeys) {
+		if (id !== key && !id.startsWith(`${key}/`)) continue;
+		if (!owner || key.length > owner.length) owner = key;
+	}
+	return owner;
+}
+/** Chunk name of the host's re-export entry for a shared key. */
+function shareChunkName(key) {
+	return `shared/${key.replace(/^@/, "").replace(/[^\w-]+/g, "-")}`;
+}
+/** Reads a remote's `mf-manifest.json` from a URL or a path relative to `root`. */
+async function readHostProvidesAllSharedManifest(location, root) {
+	let source;
+	if (isAbsoluteUrl(location)) {
+		const response = await fetch(location);
+		if (!response.ok) throw new Error(`Failed to fetch ${location}: ${response.status} ${response.statusText}`);
+		source = await response.text();
+	} else source = await readFile(path$1.resolve(root, location), "utf8");
+	const manifest = JSON.parse(source);
+	if (!manifest.metaData || !Array.isArray(manifest.exposes)) throw new Error(`${location} is not a Module Federation manifest.`);
+	if (manifest.metaData.remoteEntry) throw new Error(`${location} describes a Module Federation runtime remote (it has a remoteEntry). Build the remote with \`experiments: { hostProvidesAllShared: true }\`.`);
+	return manifest;
+}
+/** URL prefix of a remote's files: `metaData.publicPath`, `auto` inferred from the manifest URL. */
+function remotePublicPath(manifest, location) {
+	const publicPath = manifest.metaData.publicPath ?? "auto";
+	if (publicPath !== "auto") return ensureTrailingSlash(publicPath);
+	if (!isAbsoluteUrl(location)) throw new Error(`${location}: publicPath is "auto", which can only be inferred from a manifest URL. Reference the manifest by URL or set \`base\` / \`publicPath\` in the remote build.`);
+	return ensureTrailingSlash(inferAutoPublicPath(location));
+}
+/** Import-map entries (`remote/Expose` → URL) for every expose of every remote. */
+async function collectRemoteImports(remotes, root) {
+	const imports = {};
+	for (const [alias, remote] of Object.entries(remotes)) {
+		const manifest = await readHostProvidesAllSharedManifest(remote.entry, root);
+		const publicPath = remotePublicPath(manifest, remote.entry);
+		for (const expose of manifest.exposes) {
+			const file = expose.assets.js.sync[0];
+			if (!expose.path || !file) continue;
+			imports[remoteSpecifier(alias, expose.path)] = isAbsoluteUrl(remote.entry) ? new URL(file, new URL(publicPath, remote.entry)).href : publicPath + file;
+		}
+	}
+	return imports;
+}
+/** Top-level options that only the Module Federation runtime or `remoteEntry.js` pipeline reads. */
+const IGNORED_OPTIONS = [
+	"filename",
+	"ssrFilename",
+	"varFilename",
+	"library",
+	"runtime",
+	"shareScope",
+	"shareStrategy",
+	"runtimePlugins",
+	"implementation",
+	"getPublicPath",
+	"ignoreOrigin",
+	"virtualModuleDir",
+	"hostInitInjectLocation",
+	"bundleAllCSS",
+	"treeShakingDir",
+	"injectTreeShakingUsedExports",
+	"treeShakingSharedPlugins",
+	"treeShakingSharedExcludePlugins",
+	"moduleParseTimeout",
+	"moduleParseIdleTimeout",
+	"target",
+	"ssrExternals",
+	"ssrEntryLoader",
+	"disableRemote",
+	"disableShared",
+	"disableSnapshot"
+];
+const IGNORED_EXPERIMENTS = [
+	"externalRuntime",
+	"provideExternalRuntime",
+	"ssrMode"
+];
+/** Per-share options: version negotiation, aliasing and fallbacks do not exist in this mode. */
+const IGNORED_SHARE_OPTIONS = [
+	"eager",
+	"requiredVersion",
+	"strictVersion",
+	"import",
+	"request",
+	"shareKey",
+	"name",
+	"version",
+	"shareScope",
+	"treeShaking",
+	"allowNodeModulesSuffixMatch",
+	"suppressMissingImportWarning"
+];
+const isSet = (value) => value !== void 0 && value !== false && !(Array.isArray(value) && value.length === 0);
+/** A single warning naming every option the user set that import-map mode ignores. */
+function getIgnoredOptionWarning(options) {
+	const shared = options.shared;
+	const ignored = [
+		...IGNORED_OPTIONS.filter((key) => isSet(options[key])).map((key) => `\`${key}\``),
+		...IGNORED_EXPERIMENTS.filter((key) => isSet(options.experiments?.[key])).map((key) => `\`experiments.${key}\``),
+		...shared && !Array.isArray(shared) ? Object.entries(shared).flatMap(([key, config]) => typeof config === "object" && config !== null ? IGNORED_SHARE_OPTIONS.filter((option) => option === "import" ? config.import !== void 0 : isSet(config[option])).map((option) => `\`shared.${key}.${option}\``) : []) : []
+	];
+	if (ignored.length === 0) return void 0;
+	return `experiments.hostProvidesAllShared: ${ignored.join(", ")} ignored. The Module Federation runtime is not used and the host provides the only copy of every shared key.`;
+}
+//#endregion
+//#region src/utils/remoteDependencies.ts
+function collectImportSources(code) {
+	const sources = /* @__PURE__ */ new Map();
+	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,
+		dynamic
+	})).sort((a, b) => a.source.localeCompare(b.source));
+}
+function shouldScanResolvedImport(id) {
+	if (!id || id.includes("\0")) return false;
+	if (isNodeModulePath(id)) return false;
+	return /\.(?:[cm]?[jt]sx?|vue|svelte)(?:\?|$)/.test(id);
+}
+async function readModuleEdges(ctx, id, isRemoteImport) {
+	let code;
+	try {
+		code = getScannableModuleSource(id, readFileSync$1(id, "utf8"));
+	} catch {
+		return {
+			remotes: [],
+			staticImports: [],
+			dynamicImports: []
+		};
+	}
+	const edges = {
+		remotes: [],
+		staticImports: [],
+		dynamicImports: []
+	};
+	for (const { source, dynamic } of collectImportSources(code)) {
+		if (isRemoteImport(source)) {
+			if (!dynamic) edges.remotes.push(source);
+			continue;
+		}
+		let resolved;
+		try {
+			resolved = await ctx.resolve(source, id);
+		} catch {
+			continue;
+		}
+		if (resolved?.id && shouldScanResolvedImport(resolved.id)) (dynamic ? edges.dynamicImports : edges.staticImports).push(resolved.id);
+	}
+	return edges;
+}
+/**
+* Static remote imports in the module graph rooted at `id`: the remotes whose
+* bindings must be ready before the graph is used. `followDynamicImports: false`
+* stops at local `import()` boundaries, which wait for their own remotes.
+*/
+async function collectRemoteDependencies(ctx, id, isRemoteImport, { followDynamicImports = true, cache = /* @__PURE__ */ new Map() } = {}) {
+	const dependencies = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Set();
+	const pending = [id];
+	while (pending.length) {
+		const current = pending.pop();
+		if (seen.has(current) || !shouldScanResolvedImport(current)) continue;
+		seen.add(current);
+		let edges = cache.get(current);
+		if (!edges) {
+			edges = readModuleEdges(ctx, current, isRemoteImport);
+			cache.set(current, edges);
 		}
-		return Array.from(dependencies).sort();
+		const { remotes, staticImports, dynamicImports } = await edges;
+		for (const remote of remotes) dependencies.add(remote);
+		pending.push(...staticImports);
+		if (followDynamicImports) pending.push(...dynamicImports);
+	}
+	return Array.from(dependencies).sort();
+}
+//#endregion
+//#region src/plugins/pluginProxyRemoteEntry.ts
+function resolveAbsoluteDevRemoteEntryUrl(publicPath, fileName) {
+	const base = new URL(publicPath);
+	base.pathname = ensureTrailingSlash(base.pathname);
+	return new URL(fileName, base).href;
+}
+function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposesId, getParsePromise = () => Promise.resolve() }) {
+	let viteConfig, _command, root, originalConfigBase;
+	let exposeRemoteDependencies = {};
+	let exposeRemoteDependenciesDirty = true;
+	let refreshPromise;
+	let dependencyInvalidationVersion = 0;
+	let reactIslandExposes = /* @__PURE__ */ new Set();
+	let isTanStackStart = false;
+	const isHostAutoInitId = (id) => {
+		return id.split("?")[0].includes(getHostAutoInitPath(options));
+	};
+	const getEnvironmentConditions = (context) => context.environment?.config?.resolve?.conditions;
+	const isSsrBuild = (context) => isServerBuildContext(context, viteConfig);
+	const loadRemoteEntryCode = (context) => getParsePromise().then((_) => generateRemoteEntry(options, virtualExposesId, _command, getEnvironmentConditions(context), isSsrBuild(context)));
+	const loadExposesCode = async (context) => {
+		await refreshExposeRemoteDependencies(context);
+		return generateExposes(options, exposeRemoteDependencies, _command, reactIslandExposes);
+	};
+	function isRemoteImport(source) {
+		return isRemoteSpecifier(source, Object.keys(options.remotes));
 	}
 	async function refreshExposeRemoteDependencies(ctx) {
 		if (!exposeRemoteDependenciesDirty) return;
+		if (!hasRemotes(options)) {
+			exposeRemoteDependencies = {};
+			exposeRemoteDependenciesDirty = false;
+			return;
+		}
 		if (!refreshPromise) {
 			const refreshVersion = dependencyInvalidationVersion;
 			refreshPromise = (async () => {
 				const next = {};
+				const cache = /* @__PURE__ */ new Map();
+				const followDynamicImports = options.shareStrategy !== "loaded-first";
 				for (const [exposeKey, expose] of Object.entries(options.exposes)) {
 					const resolved = await ctx.resolve(expose.import);
-					next[exposeKey] = resolved?.id ? await collectRemoteDependencies(ctx, resolved.id) : [];
+					next[exposeKey] = resolved?.id ? await collectRemoteDependencies(ctx, resolved.id, isRemoteImport, {
+						followDynamicImports,
+						cache
+					}) : [];
 				}
 				exposeRemoteDependencies = next;
 				if (refreshVersion === dependencyInvalidationVersion) exposeRemoteDependenciesDirty = false;
@@ -9350,6 +9600,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		configResolved(config) {
 			viteConfig = config;
 			root = config.root;
+			isTanStackStart = config.plugins?.some((plugin) => plugin.name === "tanstack-start-core:config") ?? false;
 			reactIslandExposes = getReactIslandExposes(options, root);
 		},
 		config(config, { command }) {
@@ -9358,7 +9609,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		},
 		async buildStart() {
 			await refreshExposeRemoteDependencies(this);
-			if (_command !== "build" || hasPackageDependency("@tanstack/react-start", root)) return;
+			if (_command !== "build" || isTanStackStart) return;
 			for (const expose of Object.values(options.exposes)) {
 				const resolved = await this.resolve(expose.import);
 				if (resolved) this.emitFile({
@@ -9384,21 +9635,15 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 			}
 		},
 		async load(id) {
-			if (id === remoteEntryId) return getParsePromise().then((_) => generateRemoteEntry(options, virtualExposesId, _command, getEnvironmentConditions(this), isSsrBuild(this)));
-			if (id === virtualExposesId) {
-				await refreshExposeRemoteDependencies(this);
-				return generateExposes(options, exposeRemoteDependencies, _command, reactIslandExposes);
-			}
+			if (id === remoteEntryId) return loadRemoteEntryCode(this);
+			if (id === virtualExposesId) return loadExposesCode(this);
 			if (_command === "serve" && isHostAutoInitId(id)) return id;
 		},
 		async transform(code, id) {
 			return mapCodeToCodeWithSourcemap(await (async () => {
 				if (!filterId(id)) return;
-				if (id.includes(remoteEntryId)) return getParsePromise().then((_) => generateRemoteEntry(options, virtualExposesId, _command, getEnvironmentConditions(this), isSsrBuild(this)));
-				if (id === virtualExposesId) {
-					await refreshExposeRemoteDependencies(this);
-					return generateExposes(options, exposeRemoteDependencies, _command, reactIslandExposes);
-				}
+				if (id.includes(remoteEntryId)) return loadRemoteEntryCode(this);
+				if (id === virtualExposesId) return loadExposesCode(this);
 				if (isHostAutoInitId(id)) {
 					if (_command === "serve") {
 						const host = formatDevServerHostForOrigin(viteConfig.server?.host);
@@ -9512,7 +9757,7 @@ function pluginProxyRemotes_default(options) {
 		},
 		configResolved(config) {
 			hasMultiEnvironment = Boolean(config.environments?.ssr);
-			enableSsrInit = getSsrCapabilities(parseInt(version, 10), command, Object.keys(remotes).length > 0, isSsrConfig(config)).enableSsrInitBootstrap;
+			enableSsrInit = getSsrCapabilities(parseInt(version, 10), command, hasRemotes(options), isSsrConfig(config)).enableSsrInitBootstrap;
 		},
 		resolveId(source, importer) {
 			const resolvedIslandConsumerId = resolveReactIslandConsumerId(source);
@@ -9645,6 +9890,20 @@ function getSharedPackageFromFile(importer, shared, cwd = getPackageDetectionCwd
 	const normalizedImporter = normalizePathForImport(importer);
 	return [...cached.entries].find(([dir]) => normalizedImporter === dir || normalizedImporter.startsWith(`${dir}/`))?.[1] ?? getWorkspacePackageNameFromFile(normalizedImporter);
 }
+/**
+* Whether an import of its own package from `importer` keeps an ordinary module edge. Internal
+* files and files of shared subpaths do; a file published only under an unshared subpath (e.g.
+* `vue/sub` when only `vue` is shared) imports the shared root like any consumer.
+*/
+function keepsOwnPackageEdge(importer, shared, cwd = getPackageDetectionCwd()) {
+	const nodeModulePackage = importer && getPackageNameFromNodeModulePath(importer);
+	if (!nodeModulePackage) return true;
+	if (getInstalledPackageJson(nodeModulePackage, { cwd })?.packageJson.exports == null) return true;
+	const packageSubpath = getNodeModulesSuffix(importer)?.slice(nodeModulePackage.length + 1);
+	if (!packageSubpath) return true;
+	const specifiers = getPackageExportSpecifiersForFile(nodeModulePackage, packageSubpath, { cwd });
+	return specifiers.length === 0 || specifiers.some((specifier) => findSharedKey(specifier, shared));
+}
 const workspacePackageNameCache = /* @__PURE__ */ new Map();
 /** Name from the nearest `package.json` above `file`, for files outside `node_modules`. */
 function getWorkspacePackageNameFromFile(file) {
@@ -9939,7 +10198,6 @@ function proxySharedModule(options) {
 	const getBuildImportAnalysis = (environment) => getImportAnalysis(environment ?? _config ?? options);
 	let _command = "serve";
 	let useDirectReactImport = false;
-	let useRolldown = false;
 	let isProduction = false;
 	let rootResolveConditions;
 	let ssrResolveConditions;
@@ -9968,7 +10226,7 @@ function proxySharedModule(options) {
 		root: _config?.root || getPackageDetectionCwd(),
 		conditions: getRuntimeDependencyConditions(context, resolveOptions)
 	}));
-	const refreshTreeShakingForEnvironment = (context) => refreshTreeShakingModules(federationOptions, _command, getIsRolldown(context), getEnvironmentConditions(context));
+	const refreshTreeShakingForEnvironment = (context) => refreshTreeShakingModules(federationOptions, _command, getEnvironmentConditions(context));
 	const normalizeTreeShakingOutputPath = (value) => {
 		const normalized = normalizePathForImport(value);
 		if (path$1.posix.isAbsolute(normalized) || /^[A-Za-z]:\//.test(normalized) || normalized.split("/").includes("..")) throw new Error(`Invalid treeShakingDir "${value}": absolute paths and parent segments are not allowed.`);
@@ -9980,8 +10238,7 @@ function proxySharedModule(options) {
 	};
 	const getTreeShakingProviderFileName = (pkg, shareItem) => {
 		if (!shareItem.shareConfig.treeShaking) return void 0;
-		const normalizedOptions = federationOptions ?? getNormalizeModuleFederationOptions();
-		const outputDir = normalizedOptions.treeShakingDir ? normalizeTreeShakingOutputPath(normalizedOptions.treeShakingDir) : void 0;
+		const outputDir = federationOptions.treeShakingDir ? normalizeTreeShakingOutputPath(federationOptions.treeShakingDir) : void 0;
 		const fileName = outputDir ? path$1.posix.join(outputDir, `${getTreeShakingSharedProviderName(pkg, federationOptions)}.js`) : void 0;
 		if (!fileName) return void 0;
 		return fileName;
@@ -10045,9 +10302,7 @@ function proxySharedModule(options) {
 				workspacePackageNameCache.clear();
 				const isVinext = hasPackageDependency("vinext");
 				const isAstro = hasPackageDependency("astro");
-				const isRolldown = getIsRolldown(this);
 				_command = command;
-				useRolldown = isRolldown;
 				useDirectReactImport = isVinext || isAstro;
 				if (command === "serve") excludeSharedSubDependencies(shared);
 			},
@@ -10057,9 +10312,7 @@ function proxySharedModule(options) {
 				rootResolveConditions = config.resolve?.conditions ? [...config.resolve.conditions] : void 0;
 				ssrResolveConditions = config.ssr?.resolve?.conditions ? [...config.ssr.resolve.conditions] : void 0;
 				ssrTarget = config.ssr?.target ?? "node";
-				const isRolldown = getIsRolldown(this);
-				const resolvedOptions = federationOptions ?? getNormalizeModuleFederationOptions();
-				const registerConfiguredShare = _command === "build" && Object.keys(resolvedOptions.exposes).length > 0 ? addUsedShares : addConfiguredShare;
+				const registerConfiguredShare = _command === "build" && isRemoteContainer(federationOptions) ? addUsedShares : addConfiguredShare;
 				Object.keys(shared).forEach((key) => {
 					if (key.endsWith("/") || getSharedRequest(key, shared[key]).endsWith("/")) return;
 					const runtimeKey = getSharedRuntimeKey(key, shared[key]);
@@ -10067,7 +10320,7 @@ function proxySharedModule(options) {
 						registerConfiguredShare(runtimeKey, federationOptions);
 						return;
 					}
-					writeLoadShareModule(runtimeKey, shared[key], _command, isRolldown, federationOptions);
+					writeLoadShareModule(runtimeKey, shared[key], _command, federationOptions);
 					if (shared[key].shareConfig.import !== false) writePreBuildLibPath(runtimeKey, shared[key], federationOptions);
 					registerConfiguredShare(runtimeKey, federationOptions);
 				});
@@ -10079,6 +10332,7 @@ function proxySharedModule(options) {
 			},
 			buildStart() {
 				sharedSourceResolver.clear();
+				patchRolldownResolveOptionKeys(this);
 				if (_command !== "build") return;
 				if (hasAnalyzableShares) getBuildImportAnalysis(this.environment).clear();
 				resetTreeShakingExports(federationOptions);
@@ -10153,7 +10407,7 @@ function proxySharedModule(options) {
 					return taggedModule.name === sharedKey || matchesSharedSource(sharedSource, taggedModule.name);
 				};
 				const importerPackage = getSharedPackageFromFile(importer, shared);
-				if (importerPackage === getPackageName(key)) return;
+				if (importerPackage === getPackageName(key) && keepsOwnPackageEdge(importer, shared)) return;
 				if (importerPackage && shared[key].shareConfig.import !== false) {
 					const importerIsUnsharedWorkspacePackage = !isNodeModulePath(importer) && !Object.keys(shared).some((sharedKey) => getPackageName(sharedKey) === importerPackage);
 					const request = getSharedRequest(key, shared[key]);
@@ -10173,10 +10427,10 @@ function proxySharedModule(options) {
 					const localSource = getPrebuildResolutionSource(shareSource, shared[key]);
 					return tryResolveFromProjectRoot(localSource) || localSource;
 				}
-				const loadSharePath = getLoadShareModulePath(shareSource, useRolldown, federationOptions);
+				const loadSharePath = getLoadShareModulePath(shareSource, federationOptions);
 				if (!materializedLoadShareSources.has(shareSource)) {
 					materializedLoadShareSources.add(shareSource);
-					writeLoadShareModule(shareSource, shared[key], _command, useRolldown, federationOptions);
+					writeLoadShareModule(shareSource, shared[key], _command, federationOptions);
 					if (shared[key].shareConfig.import !== false) writePreBuildLibPath(shareSource, shared[key], federationOptions);
 					addUsedShares(shareSource, federationOptions);
 					writeLocalSharedImportMap(federationOptions);
@@ -10309,6 +10563,13 @@ function applyRewrites(code, imports, id) {
 			ms.overwrite(imp.start, imp.end, wrapDynamicImport(imp.originalText));
 			changed = true;
 			break;
+		case "local-dynamic": {
+			if (imp.remotes.length === 0) break;
+			const ready = imp.remotes.map((remote) => `import(${JSON.stringify(remote)}).then(function(__mf_m__) { return __mf_m__.__mf_remote_pending; })`);
+			ms.overwrite(imp.start, imp.end, `Promise.all([${imp.originalText}, ${ready.join(", ")}]).then(function(__mf_r__) { return __mf_r__[0]; })`);
+			changed = true;
+			break;
+		}
 	}
 	if (!changed) return;
 	if (dependencyPendingIds.length > 0) ms.overwrite(code.length, code.length, `\nexport const __mf_remote_dependency_pending = Promise.all([${dependencyPendingIds.join(", ")}]);`);
@@ -10317,7 +10578,7 @@ function applyRewrites(code, imports, id) {
 		map: ms.generateMap(id)
 	};
 }
-async function collectFromAST(ast, code, isRemoteImport) {
+async function collectFromAST(ast, code, isRemoteImport, collectLocalDynamic) {
 	const result = [];
 	walkAST(ast, { enter(node) {
 		if (node.type === "ImportDeclaration" && node.source?.value) {
@@ -10367,19 +10628,28 @@ async function collectFromAST(ast, code, isRemoteImport) {
 			const source = node.source;
 			if (source.type !== "Literal" && source.type !== "StringLiteral" && source.type !== "TemplateLiteral") return;
 			const value = source.type === "TemplateLiteral" ? source.quasis?.length === 1 ? source.quasis[0].value?.cooked : void 0 : source.value;
-			if (!value || !isRemoteImport(value)) return;
-			result.push({
+			if (!value) return;
+			const originalText = code.slice(node.start, node.end);
+			if (isRemoteImport(value)) result.push({
 				kind: "dynamic",
 				source: value,
 				start: node.start,
 				end: node.end,
-				originalText: code.slice(node.start, node.end)
+				originalText
+			});
+			else if (collectLocalDynamic) result.push({
+				kind: "local-dynamic",
+				source: value,
+				start: node.start,
+				end: node.end,
+				originalText,
+				remotes: []
 			});
 		}
 	} });
 	return result;
 }
-function collectFromRegex(code, isRemoteImport) {
+function collectFromRegex(code, isRemoteImport, collectLocalDynamic) {
 	const result = [];
 	const codePositions = createCodePositionMap(code);
 	const importAttributes = String.raw`(?:\s+(?:with|assert)\s+\{[^;]*\})?`;
@@ -10446,26 +10716,35 @@ function collectFromRegex(code, isRemoteImport) {
 	for (const match of code.matchAll(/import\(\s*(?:\/\*[\s\S]*?\*\/\s*)?(['"])([^'"]+)\1\s*\)/g)) {
 		const [full, , source] = match;
 		if (!codePositions[match.index]) continue;
-		if (!isRemoteImport(source)) continue;
-		result.push({
-			kind: "dynamic",
+		const position = {
 			source,
 			start: match.index,
-			end: match.index + full.length,
+			end: match.index + full.length
+		};
+		if (isRemoteImport(source)) result.push({
+			kind: "dynamic",
+			...position,
 			originalText: full
 		});
+		else if (collectLocalDynamic) result.push({
+			kind: "local-dynamic",
+			...position,
+			originalText: full,
+			remotes: []
+		});
 	}
 	return result.length > 0 ? result : void 0;
 }
 function pluginRemoteNamedExports(options) {
 	const remoteNames = Object.keys(options.remotes);
+	const waitsAtDynamicImports = options.shareStrategy === "loaded-first";
+	let remoteDependencyCache = /* @__PURE__ */ new Map();
 	let root = process.cwd();
-	const isNodeModulesId = (id) => id.includes("/node_modules/") || id.includes("\\node_modules\\");
 	function isRemoteImport(source, importerId) {
 		return remoteNames.some((name) => {
 			if (source.startsWith(name + "/")) return true;
 			if (source !== name) return false;
-			return !isNodeModulesId(importerId) || !getInstalledPackageEntry(source, { cwd: root });
+			return !isNodeModulePath(importerId) || !getInstalledPackageEntry(source, { cwd: root });
 		}) || source.includes("__loadRemote__");
 	}
 	return {
@@ -10474,21 +10753,46 @@ function pluginRemoteNamedExports(options) {
 		configResolved(config) {
 			root = config.root || process.cwd();
 		},
+		watchChange() {
+			remoteDependencyCache = /* @__PURE__ */ new Map();
+		},
 		async transform(code, id) {
 			if (remoteNames.length === 0) return;
 			if (id.includes("__loadRemote__") || id.includes("__loadShare__")) return;
 			if (!JS_EXTENSIONS_RE.test(id)) return;
-			if (!remoteNames.some((name) => code.includes(name))) return;
-			const matchesRemoteImport = (source) => isRemoteImport(source, id);
-			for (const { kind, source, typeOnly } of findModuleImportDescriptors(code)) if (kind === "static" && !typeOnly && matchesRemoteImport(source)) markStaticRemote(source, options);
+			const collectLocalDynamic = waitsAtDynamicImports && !isNodeModulePath(id) && /\bimport\s*\(/.test(code);
+			if (!collectLocalDynamic && !remoteNames.some((name) => code.includes(name))) return;
+			const descriptors = findModuleImportDescriptors(code);
+			const resolvedElsewhere = /* @__PURE__ */ new Set();
+			for (const source of new Set(descriptors.map((d) => d.source))) {
+				if (source.includes("__loadRemote__") || !isRemoteImport(source, id)) continue;
+				const resolved = await this.resolve(source, id);
+				if (resolved && !resolved.id.includes("__loadRemote__")) resolvedElsewhere.add(source);
+			}
+			const matchesRemoteImport = (source) => !resolvedElsewhere.has(source) && isRemoteImport(source, id);
+			for (const { kind, source, typeOnly } of descriptors) if (kind === "static" && !typeOnly && matchesRemoteImport(source)) markStaticRemote(source, options);
 			let imports;
 			try {
-				imports = await collectFromAST(this.parse(code), code, matchesRemoteImport);
+				imports = await collectFromAST(this.parse(code), code, matchesRemoteImport, collectLocalDynamic);
 			} catch {
 				if ((id.includes(".vue") || id.includes(".svelte")) && /^\s*</.test(code)) return;
-				imports = collectFromRegex(code, matchesRemoteImport);
+				imports = collectFromRegex(code, matchesRemoteImport, collectLocalDynamic);
 			}
 			if (!imports) return;
+			for (const localImport of imports) {
+				if (localImport.kind !== "local-dynamic") continue;
+				let resolved;
+				try {
+					resolved = await this.resolve(localImport.source, id);
+				} catch {
+					continue;
+				}
+				if (!resolved?.id) continue;
+				localImport.remotes = await collectRemoteDependencies(this, resolved.id, (source) => isRemoteSpecifier(source, remoteNames), {
+					followDynamicImports: false,
+					cache: remoteDependencyCache
+				});
+			}
 			for (const remoteImport of imports) if (remoteImport.kind === "dynamic") markDynamicRemote(remoteImport.source, options);
 			return applyRewrites(code, imports, id);
 		}
@@ -10654,7 +10958,7 @@ function pluginSSRRemoteEntry(options) {
 		const environmentName = environment?.name;
 		const hasSsrEnvironment = Boolean(viteConfig?.environments?.ssr);
 		const isLegacySsrBuild = Boolean(environment?.config?.build?.ssr ?? viteConfig?.build?.ssr);
-		return Object.keys(options.exposes).length > 0 && !(hasSsrEnvironment && environmentName !== "ssr" || !hasSsrEnvironment && !isLegacySsrBuild);
+		return isRemoteContainer(options) && !(hasSsrEnvironment && environmentName !== "ssr" || !hasSsrEnvironment && !isLegacySsrBuild);
 	};
 	const getSsrRemoteEntrySource = () => {
 		if (cachedSsrRemoteEntrySource === void 0) cachedSsrRemoteEntrySource = generateRemoteEntrySSR(options);
@@ -10756,8 +11060,13 @@ function pluginSSRRemoteEntry(options) {
 							} };
 						} catch {}
 					}
+					const fetchedId = body.data.name === "fetchModule" ? body.data.data[0] : void 0;
+					const shared = typeof fetchedId === "string" && !!findSharedKey(fetchedId, options.shared);
 					res.setHeader("Content-Type", "application/json");
-					res.end(JSON.stringify(result));
+					res.end(JSON.stringify(shared ? {
+						...result,
+						shared
+					} : result));
 				} catch (e) {
 					res.setHeader("Content-Type", "application/json");
 					res.end(JSON.stringify({ error: { message: String(e instanceof Error ? e.message : e) } }));
@@ -10793,6 +11102,12 @@ function pluginSSRRemoteEntry(options) {
 			const isRolldown = getIsRolldown(this);
 			const environment = this.environment;
 			if (!isSsrRemoteEntryBuild(environment)) return;
+			if (!isRolldown && hasRemotes(options)) this.emitFile({
+				type: "chunk",
+				id: getHostAutoInitPath(options),
+				name: "hostInit",
+				preserveSignature: "strict"
+			});
 			if (isRolldown) this.emitFile({
 				type: "chunk",
 				id: remoteEntrySSRId,
@@ -10800,7 +11115,7 @@ function pluginSSRRemoteEntry(options) {
 				fileName: ssrOutputFilename,
 				preserveSignature: "strict"
 			});
-			else if (Object.keys(options.exposes).length > 0 && !isNuxtLike()) this.emitFile({
+			else if (isRemoteContainer(options) && !isNuxtLike()) this.emitFile({
 				type: "chunk",
 				id: virtualExposesSSRId,
 				name: "ssrExposes",
@@ -10815,11 +11130,12 @@ function pluginSSRRemoteEntry(options) {
 				const exposesChunk = findNuxtExposesChunk(bundle) ?? findEmittedExposesChunk(bundle);
 				if (!isRolldown && isSsrRemoteEntryBuild(environment)) {
 					let source = getSsrRemoteEntrySource();
-					if (exposesChunk) {
-						let exposesImport = path$1.posix.relative(path$1.posix.dirname(ssrOutputFilename), exposesChunk);
-						if (!exposesImport.startsWith(".")) exposesImport = `./${exposesImport}`;
-						source = source.replace(/import\("virtual:mf-exposes-ssr:[^"]+"\)/g, `import("${exposesImport}")`);
+					if (hasRemotes(options)) {
+						const hostInitId = getHostAutoInitPath(options);
+						const hostInitChunk = Object.values(bundle).find((file) => file.type === "chunk" && file.facadeModuleId?.includes(hostInitId));
+						if (hostInitChunk) source = source.replace(JSON.stringify(hostInitId), JSON.stringify(toRelativeImport(ssrOutputFilename, hostInitChunk.fileName)));
 					}
+					if (exposesChunk) source = source.replace(/import\("virtual:mf-exposes-ssr:[^"]+"\)/g, `import("${toRelativeImport(ssrOutputFilename, exposesChunk)}")`);
 					this.emitFile({
 						type: "asset",
 						fileName: ssrOutputFilename,
@@ -10983,6 +11299,68 @@ const VarRemoteEntry = (providedOptions) => {
 	}
 };
 //#endregion
+//#region src/plugins/pluginSsrRuntimeInit.ts
+/** Register the SSR host before application evaluation, without preloading remotes. */
+function pluginSsrRuntimeInit(options) {
+	if (!hasRemotes(options)) return [];
+	let command;
+	let legacySsr = false;
+	let supported = false;
+	const server = (ctx, ssr) => supported && isServerContext(ctx, ssr === true || legacySsr);
+	return [{
+		name: "module-federation-ssr-runtime-init",
+		enforce: "post",
+		config(_config, env) {
+			command = env.command;
+		},
+		configResolved(config) {
+			legacySsr = Boolean(config.build.ssr);
+			supported = getSsrCapabilities(parseInt(version, 10), command, true, isSsrConfig(config)).enableSsrInitBootstrap;
+		},
+		resolveId: {
+			order: "pre",
+			handler(id, _importer, resolveOptions) {
+				if (server(this, resolveOptions.ssr) && id === options.implementation) return {
+					id: options.implementation,
+					external: false
+				};
+			}
+		},
+		transform(code, id, transformOptions) {
+			if (!server(this, transformOptions?.ssr)) return;
+			if (isOwnedHostAutoInitId(id, options)) {
+				const pluginImports = options.runtimePlugins.map((plugin, index) => `import plugin${index} from ${toSafeJsLiteral(getRuntimePluginSpecifier(plugin))};`).join("\n");
+				const plugins = options.runtimePlugins.map((plugin, index) => `plugin${index}(${Array.isArray(plugin) ? serializeRuntimeOptions(plugin[1]) : ""})`).join(",");
+				return {
+					code: `
+            import { init } from ${toSafeJsLiteral(options.implementation)};
+            import { usedShared, usedRemotes } from ${toSafeJsLiteral(getLocalSharedImportMapPath(options))};
+            ${pluginImports}
+            ${getRuntimeInitBootstrapCode(false, getRuntimeInitStatusImportId(options))}
+            globalThis[globalKey].ssrInitStarted = true;
+            const runtime = init({
+              name: ${toSafeJsLiteral(options.name)},
+              remotes: usedRemotes,
+              shared: usedShared,
+              plugins: [${plugins}],
+              shareStrategy: ${toSafeJsLiteral(options.shareStrategy)},
+            });
+            const hostInitPromise = Promise.resolve(runtime);
+            globalThis[globalKey].initResolve(runtime);
+            function initHost() { return hostInitPromise; }
+            export { initHost, hostInitPromise };
+          `,
+					map: null
+				};
+			}
+			if (!(command === "build" && this.getModuleInfo(id)?.isEntry) && !findModuleImportSources(code).includes("@module-federation/runtime")) return;
+			const injection = `import ${toSafeJsLiteral(getHostAutoInitPath(options))};\n`;
+			if (code.includes(injection.trim())) return;
+			return mapCodeToCodeWithSourcemap(injection + code);
+		}
+	}];
+}
+//#endregion
 //#region src/utils/aliasToArrayPlugin.ts
 var aliasToArrayPlugin_default = {
 	name: "alias-transform-plugin",
@@ -11131,145 +11509,6 @@ function sanitizeFederationControlChunk(code, fileName, filename) {
 	return nextCode;
 }
 //#endregion
-//#region src/utils/isTestEnv.ts
-/**
-* Detects whether the current process is running in a test environment
-* Set `MFE_VITE_NO_TEST_ENV_CHECK=true` to load federation plugins during tests.
-*/
-function isTestEnv() {
-	if (process.env.MFE_VITE_NO_TEST_ENV_CHECK === "true") return false;
-	return process.env.NODE_ENV === "test" || process.env.VITEST != null || process.env.JEST_WORKER_ID != null;
-}
-//#endregion
-//#region src/utils/hostProvidesAllShared.ts
-/** Virtual-module prefix of the host's per-share re-export entries. */
-const SHARE_MODULE_PREFIX = "\0mf-host-provided-share:";
-/** `./a/b` → `a/b`, `.` → `index`: the fixed entry name of an expose, without `.js`. */
-function exposeEntryName(exposeKey) {
-	return exposeKey === "." ? "index" : exposeKey.replace(/^\.\//, "");
-}
-/** Bare specifier a host uses for an expose: `remote` for `.`, `remote/a/b` otherwise. */
-function remoteSpecifier(remoteName, exposeKey) {
-	const entry = exposeEntryName(exposeKey);
-	return entry === "index" ? remoteName : `${remoteName}/${entry}`;
-}
-/** `id` is a remote alias or a subpath of one. */
-function isRemoteSpecifier(id, remoteKeys) {
-	return remoteKeys.some((key) => id === key || id.startsWith(`${key}/`));
-}
-/**
-* The shared key that owns `id`: an exact match, else the longest key `id` is a subpath
-* of (`lodash-es/debounce` → `lodash-es`). Used to spot an unshared subpath of a shared
-* package, which would bundle a private copy of that package into a remote.
-*/
-function sharedKeyOwning(id, sharedKeys) {
-	let owner;
-	for (const key of sharedKeys) {
-		if (id !== key && !id.startsWith(`${key}/`)) continue;
-		if (!owner || key.length > owner.length) owner = key;
-	}
-	return owner;
-}
-/** Chunk name of the host's re-export entry for a shared key. */
-function shareChunkName(key) {
-	return `shared/${key.replace(/^@/, "").replace(/[^\w-]+/g, "-")}`;
-}
-/** Reads a remote's `mf-manifest.json` from a URL or a path relative to `root`. */
-async function readHostProvidesAllSharedManifest(location, root) {
-	let source;
-	if (isAbsoluteUrl(location)) {
-		const response = await fetch(location);
-		if (!response.ok) throw new Error(`Failed to fetch ${location}: ${response.status} ${response.statusText}`);
-		source = await response.text();
-	} else source = await readFile(path$1.resolve(root, location), "utf8");
-	const manifest = JSON.parse(source);
-	if (!manifest.metaData || !Array.isArray(manifest.exposes)) throw new Error(`${location} is not a Module Federation manifest.`);
-	if (manifest.metaData.remoteEntry) throw new Error(`${location} describes a Module Federation runtime remote (it has a remoteEntry). Build the remote with \`experiments: { hostProvidesAllShared: true }\`.`);
-	return manifest;
-}
-/** URL prefix of a remote's files: `metaData.publicPath`, `auto` inferred from the manifest URL. */
-function remotePublicPath(manifest, location) {
-	const publicPath = manifest.metaData.publicPath ?? "auto";
-	if (publicPath !== "auto") return ensureTrailingSlash(publicPath);
-	if (!isAbsoluteUrl(location)) throw new Error(`${location}: publicPath is "auto", which can only be inferred from a manifest URL. Reference the manifest by URL or set \`base\` / \`publicPath\` in the remote build.`);
-	return ensureTrailingSlash(inferAutoPublicPath(location));
-}
-/** Import-map entries (`remote/Expose` → URL) for every expose of every remote. */
-async function collectRemoteImports(remotes, root) {
-	const imports = {};
-	for (const [alias, remote] of Object.entries(remotes)) {
-		const manifest = await readHostProvidesAllSharedManifest(remote.entry, root);
-		const publicPath = remotePublicPath(manifest, remote.entry);
-		for (const expose of manifest.exposes) {
-			const file = expose.assets.js.sync[0];
-			if (!expose.path || !file) continue;
-			imports[remoteSpecifier(alias, expose.path)] = isAbsoluteUrl(remote.entry) ? new URL(file, new URL(publicPath, remote.entry)).href : publicPath + file;
-		}
-	}
-	return imports;
-}
-/** Top-level options that only the Module Federation runtime or `remoteEntry.js` pipeline reads. */
-const IGNORED_OPTIONS = [
-	"filename",
-	"ssrFilename",
-	"varFilename",
-	"library",
-	"runtime",
-	"shareScope",
-	"shareStrategy",
-	"runtimePlugins",
-	"implementation",
-	"getPublicPath",
-	"ignoreOrigin",
-	"virtualModuleDir",
-	"hostInitInjectLocation",
-	"bundleAllCSS",
-	"treeShakingDir",
-	"injectTreeShakingUsedExports",
-	"treeShakingSharedPlugins",
-	"treeShakingSharedExcludePlugins",
-	"moduleParseTimeout",
-	"moduleParseIdleTimeout",
-	"target",
-	"ssrExternals",
-	"ssrEntryLoader",
-	"disableRemote",
-	"disableShared",
-	"disableSnapshot"
-];
-const IGNORED_EXPERIMENTS = [
-	"externalRuntime",
-	"provideExternalRuntime",
-	"ssrMode"
-];
-/** Per-share options: version negotiation, aliasing and fallbacks do not exist in this mode. */
-const IGNORED_SHARE_OPTIONS = [
-	"eager",
-	"requiredVersion",
-	"strictVersion",
-	"import",
-	"request",
-	"shareKey",
-	"name",
-	"version",
-	"shareScope",
-	"treeShaking",
-	"allowNodeModulesSuffixMatch",
-	"suppressMissingImportWarning"
-];
-const isSet = (value) => value !== void 0 && value !== false && !(Array.isArray(value) && value.length === 0);
-/** A single warning naming every option the user set that import-map mode ignores. */
-function getIgnoredOptionWarning(options) {
-	const shared = options.shared;
-	const ignored = [
-		...IGNORED_OPTIONS.filter((key) => isSet(options[key])).map((key) => `\`${key}\``),
-		...IGNORED_EXPERIMENTS.filter((key) => isSet(options.experiments?.[key])).map((key) => `\`experiments.${key}\``),
-		...shared && !Array.isArray(shared) ? Object.entries(shared).flatMap(([key, config]) => typeof config === "object" && config !== null ? IGNORED_SHARE_OPTIONS.filter((option) => option === "import" ? config.import !== void 0 : isSet(config[option])).map((option) => `\`shared.${key}.${option}\``) : []) : []
-	];
-	if (ignored.length === 0) return void 0;
-	return `experiments.hostProvidesAllShared: ${ignored.join(", ")} ignored. The Module Federation runtime is not used and the host provides the only copy of every shared key.`;
-}
-//#endregion
 //#region src/plugins/pluginHostProvidesAllSharedHost.ts
 const ESM_SYNTAX_RE = /(^|[\s;])(export|import)[\s{*]/m;
 const DEFAULT_EXPORT_RE = /export\s+default\b|export\s*\{[^}]*\bas\s+default\b/;
@@ -11495,28 +11734,6 @@ function pluginHostProvidesAllSharedRemote(options) {
 	};
 }
 //#endregion
-//#region src/utils/normalizeOptimizeDeps.ts
-var normalizeOptimizeDeps_default = {
-	name: "normalizeOptimizeDeps",
-	config: (config) => {
-		let { optimizeDeps } = config;
-		if (!optimizeDeps) {
-			config.optimizeDeps = {};
-			optimizeDeps = config.optimizeDeps;
-		}
-		if (!optimizeDeps.include) optimizeDeps.include = [];
-		if (!optimizeDeps.exclude) optimizeDeps.exclude = [];
-		if (!optimizeDeps.needsInterop) optimizeDeps.needsInterop = [];
-	},
-	configResolved: (config) => {
-		const include = config.optimizeDeps?.include;
-		const exclude = config.optimizeDeps?.exclude;
-		if (!include?.length || !exclude?.length) return;
-		const included = new Set(include);
-		config.optimizeDeps.exclude = exclude.filter((dep) => !included.has(dep));
-	}
-};
-//#endregion
 //#region src/utils/runtimeCapabilityOptimization.ts
 const RUNTIME_CAPABILITIES = [
 	{
@@ -11546,11 +11763,11 @@ function applyRuntimeCapabilityDefines(define, options, { defaultDisableSnapshot
 		}
 		if (explicitValue !== void 0 && !isEquivalentBooleanDefine(define[capability.define], explicitValue)) onConflict?.(`${capability.define} define (${define[capability.define]}) differs from ${capability.option} option (${explicitValue}). The existing define will not be overridden.`);
 	}
-	if (!("FEDERATION_HAS_EXPOSES" in define)) define["FEDERATION_HAS_EXPOSES"] = JSON.stringify(Object.keys(options.exposes).length > 0);
+	if (!("FEDERATION_HAS_EXPOSES" in define)) define["FEDERATION_HAS_EXPOSES"] = JSON.stringify(isRemoteContainer(options));
 }
 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.disableRemote && hasRemotes(options)) warnings.push("disableRemote is true, but remotes are configured. Remote 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;
 }
@@ -11718,15 +11935,8 @@ function isBarePackageSubpath(specifier) {
 * Vite then resolves the package's own dependency graph using its normal
 * scanner, preserving package and peer-dependency resolution semantics.
 */
-function includeLinkedSharedEntries(optimizeDeps, shared, projectRoot, exposes, outDir) {
+function collectLinkedSharedEntries(shared, projectRoot, exposes) {
 	const additions = /* @__PURE__ */ new Set();
-	const entries = new Set(Array.isArray(optimizeDeps.entries) ? optimizeDeps.entries : optimizeDeps.entries ? [optimizeDeps.entries] : [
-		"**/*.html",
-		"!**/node_modules/**",
-		`!**/${outDir.replace(/\\/g, "/")}/**`,
-		"!**/__tests__/**",
-		"!**/coverage/**"
-	]);
 	for (const [packageName, share] of Object.entries(shared ?? {})) {
 		if (share?.shareConfig?.import === false) continue;
 		const configuredImport = share?.shareConfig?.import;
@@ -11749,13 +11959,7 @@ function includeLinkedSharedEntries(optimizeDeps, shared, projectRoot, exposes,
 			if (existsSync(entry)) additions.add(entry);
 		}
 	}
-	if (additions.size === 0) return;
-	for (const entry of additions) entries.add(entry);
-	optimizeDeps.entries = [...entries];
-}
-function stabilizeOptimizeDeps(optimizeDeps) {
-	optimizeDeps.include = [...new Set(optimizeDeps.include ?? [])].sort();
-	optimizeDeps.exclude = [...new Set(optimizeDeps.exclude ?? [])].sort();
+	return [...additions];
 }
 function isFile(candidate) {
 	try {
@@ -11878,7 +12082,7 @@ function createEarlyVirtualModulesPlugin(options) {
 			const isVinext = hasPackageDependency("vinext");
 			initVirtualModules(_command, getRemoteEntryId(options), false, options);
 			const isRolldown = getIsRolldown(this);
-			if (remotes && Object.keys(remotes).length > 0) {
+			if (hasRemotes(options)) {
 				for (const key of Object.keys(remotes)) ensureUsedRemote(key, options);
 				if (_command === "serve") {
 					config.optimizeDeps = config.optimizeDeps || {};
@@ -11900,7 +12104,7 @@ function createEarlyVirtualModulesPlugin(options) {
 					const preparedShares = /* @__PURE__ */ new Map();
 					const writeSharedModules = (source, shareItem) => {
 						if (preparedShares.get(source) === shareItem) return;
-						writeLoadShareModule(source, shareItem, _command, isRolldown, options);
+						writeLoadShareModule(source, shareItem, _command, options);
 						if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(source, shareItem, options);
 						preparedShares.set(source, shareItem);
 					};
@@ -11916,7 +12120,7 @@ function createEarlyVirtualModulesPlugin(options) {
 								if (!id.startsWith("module-federation:optimized-require-")) return;
 								const sourcePackage = id.slice(36);
 								if (sourcePackage !== "react" && sourcePackage !== "react-dom") return;
-								const loadSharePath = getLoadShareModulePath(sourcePackage, isRolldown, options);
+								const loadSharePath = getLoadShareModulePath(sourcePackage, options);
 								const source = JSON.stringify(loadSharePath);
 								return "import * as __mfShared from " + source + ";\nexport * from " + source + ";\nexport default __mfShared.default ?? __mfShared;";
 							},
@@ -11929,7 +12133,7 @@ function createEarlyVirtualModulesPlugin(options) {
 								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 (!isReactDomSelfReference(source, importer) && (importerPackage === getPackageName(key) && keepsOwnPackageEdge(importer, shared, root) || importerPackage && isSharedPackageDependency(key, importerPackage))) return;
 								if (isAssetLikeImport(source)) return;
 								const shareItem = shared[key];
 								const isReactSingleton = source === "react" && key === "react" && shareItem.shareConfig?.singleton === true;
@@ -11942,7 +12146,7 @@ function createEarlyVirtualModulesPlugin(options) {
 									writeSharedModules(source, shareItem);
 									return { id: `module-federation:optimized-require-${source}` };
 								}
-								const loadSharePath = getLoadShareModulePath(source, isRolldown, options);
+								const loadSharePath = getLoadShareModulePath(source, options);
 								writeSharedModules(source, shareItem);
 								return {
 									id: loadSharePath,
@@ -11970,12 +12174,12 @@ function createEarlyVirtualModulesPlugin(options) {
 									const key = findSharedKey(args.path, shared);
 									if (!key || isAssetLikeImport(args.path)) return;
 									const importerPackage = getSharedPackageFromFile(args.importer, shared, root);
-									if (importerPackage === getPackageName(args.path) && !isReactDomSelfReference(args.path, args.importer)) return;
+									if (importerPackage === getPackageName(args.path) && !isReactDomSelfReference(args.path, args.importer) && keepsOwnPackageEdge(args.importer, shared, root)) return;
 									if (importerPackage && isSharedPackageDependency(key, importerPackage)) return;
 									addUsedShares(args.path, options);
 									if (args.kind === "import-statement" || args.kind === "dynamic-import") {
 										const shareItem = shared[key];
-										const loadSharePath = getLoadShareModulePath(args.path, isRolldown, options);
+										const loadSharePath = getLoadShareModulePath(args.path, options);
 										writeSharedModules(args.path, shareItem);
 										return {
 											path: loadSharePath,
@@ -11994,7 +12198,7 @@ function createEarlyVirtualModulesPlugin(options) {
 									const key = findSharedKey(args.path, shared);
 									if (!key) return;
 									const shareItem = shared[key];
-									const loadSharePath = getLoadShareModulePath(args.path, isRolldown, options);
+									const loadSharePath = getLoadShareModulePath(args.path, options);
 									writeSharedModules(args.path, shareItem);
 									return {
 										loader: "js",
@@ -12029,8 +12233,8 @@ export default __mfShared.default ?? __mfShared;`
 						addConfiguredShare(runtimeKey, options);
 						continue;
 					}
-					getLoadShareModulePath(runtimeKey, isRolldown, options);
-					writeLoadShareModule(runtimeKey, shareItem, _command, isRolldown, options);
+					getLoadShareModulePath(runtimeKey, options);
+					writeLoadShareModule(runtimeKey, shareItem, _command, options);
 					if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(runtimeKey, shareItem, options);
 					addConfiguredShare(runtimeKey, options);
 					if (_command === "serve" && shareItem.shareConfig?.import !== false) {
@@ -12052,8 +12256,8 @@ export default __mfShared.default ?? __mfShared;`
 								optimizeDeps.exclude.push(subpath);
 								continue;
 							}
-							getLoadShareModulePath(subpath, isRolldown, options);
-							writeLoadShareModule(subpath, shareItem, _command, isRolldown, options);
+							getLoadShareModulePath(subpath, options);
+							writeLoadShareModule(subpath, shareItem, _command, options);
 							writePreBuildLibPath(subpath, shareItem, options);
 							addConfiguredShare(subpath, options);
 							if (canResolveSubpath) {
@@ -12066,9 +12270,19 @@ export default __mfShared.default ?? __mfShared;`
 				writeLocalSharedImportMap(options);
 			}
 			if (_command === "serve") {
-				config.optimizeDeps ??= {};
-				includeLinkedSharedEntries(config.optimizeDeps, shared, root, options.exposes, config.build?.outDir ?? "dist");
-				stabilizeOptimizeDeps(config.optimizeDeps);
+				const generatedEntries = collectLinkedSharedEntries(shared, root, options.exposes);
+				if (generatedEntries.length > 0) {
+					config.optimizeDeps ??= {};
+					const outDir = config.build?.outDir ?? "dist";
+					const { entries } = config.optimizeDeps;
+					config.optimizeDeps.entries = [.../* @__PURE__ */ new Set([...entries === void 0 ? [
+						"**/*.html",
+						"!**/node_modules/**",
+						`!**/${outDir.replace(/\\/g, "/")}/**`,
+						"!**/__tests__/**",
+						"!**/coverage/**"
+					] : typeof entries === "string" ? [entries] : entries, ...generatedEntries])];
+				}
 			}
 		},
 		configResolved(config) {
@@ -12103,6 +12317,7 @@ export default __mfShared.default ?? __mfShared;`
 				resolveImportPath(ssrEntryLoaderSpecifier);
 				options.runtimePlugins.push([ssrEntryLoaderSpecifier, {
 					resolvedShared,
+					...config.command === "build" && { rebaseSharedAtRuntime: true },
 					...options.ssrEntryLoader
 				}]);
 			} catch {}
@@ -12132,7 +12347,7 @@ function withoutDynamicRemoteTypeHints(options) {
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-CVyHPAEq.js").then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-rZMRTCTz.js").then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {
@@ -12159,13 +12374,13 @@ function applyExternalRuntimeExperiments(options) {
 	}
 }
 function federation(mfUserOptions) {
-	if (isTestEnv()) return [];
+	if (process.env.MFE_VITE_NO_TEST_ENV_CHECK !== "true" && (process.env.NODE_ENV === "test" || process.env.VITEST != null || process.env.JEST_WORKER_ID != null)) return [];
 	const options = normalizeModuleFederationOptions(mfUserOptions);
 	if (!options.name) throw createModuleFederationError("name is required");
 	if (options.experiments.hostProvidesAllShared) {
 		const ignored = getIgnoredOptionWarning(mfUserOptions);
 		if (ignored) mfWarn(ignored);
-		return [Object.keys(options.exposes).length > 0 ? pluginHostProvidesAllSharedRemote(options) : pluginHostProvidesAllSharedHost(options), ...loadPluginDts(withoutDynamicRemoteTypeHints(options))];
+		return [isRemoteContainer(options) ? pluginHostProvidesAllSharedRemote(options) : pluginHostProvidesAllSharedHost(options), ...loadPluginDts(withoutDynamicRemoteTypeHints(options))];
 	}
 	applyExternalRuntimeExperiments(options);
 	const isVinext = hasPackageDependency("vinext");
@@ -12220,9 +12435,9 @@ function federation(mfUserOptions) {
 		const key = findSharedKey(pkg, shared);
 		if (!key) return "not-applicable";
 		const requestedModule = VirtualModule.findById(id);
-		const ownedModule = VirtualModule.findById(getLoadShareModulePath(pkg, false, options));
+		const ownedModule = VirtualModule.findById(getLoadShareModulePath(pkg, options));
 		if (!requestedModule || requestedModule !== ownedModule) return "not-owned";
-		writeLoadShareModule(pkg, shared[key], command, getIsRolldown(context), options, getLoadHookExportConditions(context, loadOptions), importFalseExportUsage);
+		writeLoadShareModule(pkg, shared[key], command, options, getLoadHookExportConditions(context, loadOptions), importFalseExportUsage);
 		return "refreshed";
 	};
 	const getCompleteImportFalseExportUsage = (id) => {
@@ -12365,9 +12580,7 @@ function federation(mfUserOptions) {
 			name: "vite:module-federation-virtual-modules",
 			enforce: "pre",
 			configureServer(server) {
-				server.watcher.on("change", invalidateSharedExportInspectionCache);
-				server.watcher.on("add", invalidateSharedExportInspectionCache);
-				server.watcher.on("unlink", invalidateSharedExportInspectionCache);
+				watchFileEvents(server.watcher, invalidateSharedExportInspectionCache);
 			},
 			resolveId(id) {
 				if (id === "@module-federation/vite/ssrEntryLoader") return resolveImportPath(id);
@@ -12377,7 +12590,6 @@ function federation(mfUserOptions) {
 						id,
 						shared: options.shared,
 						command,
-						isRolldown: getIsRolldown(this),
 						findSharedKey,
 						addUsedShares: (pkg) => addUsedShares(pkg, options),
 						writeLocalSharedImportMap: () => writeLocalSharedImportMap(options),
@@ -12438,14 +12650,29 @@ function federation(mfUserOptions) {
 				ssrResolveConditions = config.ssr?.resolve?.conditions ? [...config.ssr.resolve.conditions] : void 0;
 				ssrTarget = config.ssr?.target ?? "node";
 				isProduction = config.isProduction;
-				const ssrCapabilities = getSsrCapabilities(parseInt(version, 10), command, Object.keys(options.remotes).length > 0, isSsrConfig(config));
+				const ssrCapabilities = getSsrCapabilities(parseInt(version, 10), command, hasRemotes(options), isSsrConfig(config));
 				resolveSharedVersions(shared, config.root);
 				initVirtualModules(command, remoteEntryId, ssrCapabilities.enableSsrInitBootstrap, options);
 			}
 		},
 		aliasToArrayPlugin_default,
 		checkAliasConflicts({ shared }),
-		normalizeOptimizeDeps_default,
+		{
+			name: "normalizeOptimizeDeps",
+			config(config) {
+				config.optimizeDeps ||= {};
+				config.optimizeDeps.include ||= [];
+				config.optimizeDeps.exclude ||= [];
+				config.optimizeDeps.needsInterop ||= [];
+			},
+			configResolved(config) {
+				const include = config.optimizeDeps?.include;
+				const exclude = config.optimizeDeps?.exclude;
+				if (!include?.length || !exclude?.length) return;
+				const included = new Set(include);
+				config.optimizeDeps.exclude = exclude.filter((dep) => !included.has(dep));
+			}
+		},
 		...loadPluginDts(options),
 		pluginDevRemoteHmr(options),
 		{
@@ -12470,7 +12697,7 @@ function federation(mfUserOptions) {
 			entryName: "hostInit",
 			entryPath: () => getHostAutoInitPath(options),
 			inject: hostInitInjectLocation,
-			forceClientInjected: Object.keys(options.exposes).length > 0,
+			forceClientInjected: isRemoteContainer(options),
 			skipTransformFor: Object.values(options.exposes).map((expose) => expose.import),
 			federationOptions: options
 		}),
@@ -12668,10 +12895,6 @@ function federation(mfUserOptions) {
 						config.optimizeDeps.include.push(optimizeDep);
 					}
 				});
-				if (isRolldown) {
-					config.build ??= {};
-					config.build.target ??= "esnext";
-				}
 				const isBundledDev = Boolean(config.experimental?.bundledDev);
 				if (isRolldown && _command === "serve" && isBundledDev) {
 					config.build.rolldownOptions ??= {};
@@ -12715,6 +12938,7 @@ function federation(mfUserOptions) {
 		},
 		...Manifest(options),
 		...pluginSSRRemoteEntry(options),
+		...pluginSsrRuntimeInit(options),
 		...VarRemoteEntry(options),
 		{
 			name: "module-federation-vinext-fix-rsc-preload-as",
@@ -12751,20 +12975,12 @@ function federation(mfUserOptions) {
 		},
 		...(function() {
 			let disablePreload = false;
-			return Object.keys(options.exposes).length > 0 ? [{
+			return isRemoteContainer(options) ? [{
 				name: "module-federation-fix-preload",
 				enforce: "post",
 				apply: "build",
-				config(_config, { command }) {
-					const manifest = options.manifest;
-					const getDefaultDisableAssetsAnalyze = (cfgCommand) => cfgCommand === "serve" && (typeof manifest !== "object" || !Object.hasOwn(manifest, "disableAssetsAnalyze"));
-					const getConfiguredDisableAssetsAnalyze = (cfgCommand) => {
-						if (typeof manifest === "object" && manifest !== null) {
-							if (Object.hasOwn(manifest, "disableAssetsAnalyze")) return manifest.disableAssetsAnalyze === true;
-						}
-						return getDefaultDisableAssetsAnalyze(cfgCommand);
-					};
-					disablePreload = getConfiguredDisableAssetsAnalyze(command);
+				config() {
+					disablePreload = resolveDisableAssetsAnalyze(options.manifest, false);
 				},
 				generateBundle(_outputOptions, bundle, _isWrite) {
 					if (disablePreload) return;