@module-federation/vite 1.20.6 → 1.20.8

package/lib/index.js

@@ -13,6 +13,217 @@ 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";
+//#region src/utils/bundleHelpers.ts
+function isOutputChunk$1(chunk) {
+	return chunk.type === "chunk";
+}
+function escapeRegExp$2(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Whether `code` references `name` as a whole identifier.
+*
+* Not `\b`: a word boundary needs a `\w` on one side, and `$` is not one, so
+* `\b$8\b` matches nothing at all. Minifiers assign `$`-prefixed names to any
+* chunk with more than ~54 module-scope bindings, and a missed match here reads
+* as "unused", which orphans a still-referenced import.
+*/
+function isIdentifierReferenced(name, code) {
+	return new RegExp(`(?<![$\\w])${escapeRegExp$2(name)}(?![$\\w])`).test(code);
+}
+function getProxyBaseName(fileName) {
+	return fileName.replace(/^.*\//, "").replace(/\.js$/, "").replace(/-[A-Za-z0-9_-]+$/, "");
+}
+/**
+* Matches `function <name>(`. Escaped because an unescaped leading `$` is a
+* regex end-anchor, so the pattern would silently match nothing.
+*/
+function functionDeclarationRegExp(name) {
+	return new RegExp(`function\\s+${escapeRegExp$2(name)}\\s*\\(`);
+}
+function extractFunctionDeclaration(code, functionName) {
+	const funcRe = new RegExp(`function\\s+${escapeRegExp$2(functionName)}\\s*\\([^)]*\\)\\s*\\{`);
+	const funcStart = code.search(funcRe);
+	if (funcStart < 0) return;
+	let depth = 0;
+	for (let i = code.indexOf("{", funcStart); i < code.length; i++) if (code[i] === "{") depth++;
+	else if (code[i] === "}") {
+		depth--;
+		if (depth === 0) return code.slice(funcStart, i + 1);
+	}
+}
+/**
+* Resolve the local alias for a non-inlineable proxy binding.
+* If Rollup's deconflict renamed the alias but didn't update references
+* in the code body, fall back to proxyLocal so they stay in sync.
+*/
+function resolveProxyAlias(binding, proxyLocal, code, fullImport, claimedLocals = /* @__PURE__ */ new Set()) {
+	const codeWithoutImport = code.replace(fullImport, "");
+	const localUsedInCode = isIdentifierReferenced(binding.local, codeWithoutImport);
+	const claimedImportLocals = /* @__PURE__ */ new Set();
+	const importRe = /import\s*\{([^}]+)\}\s*from\s*["'][^"']+["']\s*;?/g;
+	let match;
+	while ((match = importRe.exec(codeWithoutImport)) !== null) for (const spec of match[1].split(",")) {
+		const parts = spec.trim().split(/\s+as\s+/);
+		claimedImportLocals.add((parts[1] || parts[0]).trim());
+	}
+	const local = !localUsedInCode && !claimedLocals.has(proxyLocal) && !claimedImportLocals.has(proxyLocal) ? proxyLocal : binding.local;
+	return {
+		imported: binding.imported,
+		local
+	};
+}
+function collectLoadShareProxyChunks(bundle, loadShareTag) {
+	const proxyChunks = /* @__PURE__ */ new Map();
+	for (const [fileName, chunk] of Object.entries(bundle)) {
+		if (!isOutputChunk$1(chunk)) continue;
+		if (fileName.includes(loadShareTag) && fileName.includes("commonjs-proxy")) proxyChunks.set(fileName, {
+			code: chunk.code,
+			fileName
+		});
+	}
+	return proxyChunks;
+}
+function collectSystemProxyInfos(proxyChunks, loadShareTag) {
+	const systemProxyInfo = /* @__PURE__ */ new Map();
+	for (const [proxyFileName, proxyInfo] of Array.from(proxyChunks.entries())) {
+		const depsMatch = proxyInfo.code.match(/System\.register\(\[([\s\S]*?)\]/);
+		if (!depsMatch) continue;
+		const loadShareDep = Array.from(depsMatch[1].matchAll(/["']([^"']+)["']/g)).map((m) => m[1]).find((dep) => dep.includes(loadShareTag) && !dep.includes("commonjs-proxy"));
+		if (!loadShareDep) continue;
+		const loadShareBindings = {};
+		for (const m of proxyInfo.code.matchAll(/([A-Za-z_$][\w$]*)\s*=\s*module\d+\.([A-Za-z_$][\w$]*)/g)) loadShareBindings[m[1]] = m[2];
+		const exportMap = {};
+		const objectExportMatch = proxyInfo.code.match(/exports\(\s*\{([\s\S]*?)\}\s*\)/);
+		if (objectExportMatch) for (const m of objectExportMatch[1].matchAll(/([A-Za-z_$][\w$]*)\s*:\s*([A-Za-z_$][\w$]*)/g)) {
+			const [, exported, local] = m;
+			const funcBody = extractFunctionDeclaration(proxyInfo.code, local);
+			if (funcBody) exportMap[exported] = {
+				type: "helper",
+				code: funcBody
+			};
+		}
+		for (const m of proxyInfo.code.matchAll(/exports\(\s*["']([^"']+)["']\s*,([\s\S]*?)\);/g)) {
+			const exported = m[1];
+			const expression = m[2];
+			for (const [local, exportName] of Object.entries(loadShareBindings).reverse()) if (isIdentifierReferenced(local, expression)) {
+				exportMap[exported] = {
+					type: "reexport",
+					exportName
+				};
+				break;
+			}
+		}
+		if (Object.keys(exportMap).length > 0) systemProxyInfo.set(proxyFileName, {
+			loadShareDep,
+			exportMap
+		});
+	}
+	return systemProxyInfo;
+}
+function rewriteEsmProxyConsumers(code, proxyChunks) {
+	let nextCode = code;
+	const claimedLocals = /* @__PURE__ */ new Set();
+	for (const [proxyFileName, proxyInfo] of Array.from(proxyChunks.entries())) {
+		const proxyBaseName = getProxyBaseName(proxyFileName);
+		const importMatch = new RegExp(`import\\s*\\{([^}]+)\\}\\s*from\\s*["']([^"']*${escapeRegExp$2(proxyBaseName)}[^"']*)["']\\s*;?`).exec(nextCode);
+		if (!importMatch) continue;
+		const fullImport = importMatch[0];
+		const bindings = importMatch[1].split(",").map((s) => {
+			const parts = s.trim().split(/\s+as\s+/);
+			return {
+				imported: parts[0].trim(),
+				local: (parts[1] || parts[0]).trim()
+			};
+		});
+		const exportMapMatch = proxyInfo.code.match(/export\s*\{([^}]+)\}/);
+		if (!exportMapMatch) continue;
+		const exportMap = {};
+		for (const entry of exportMapMatch[1].split(",")) {
+			const parts = entry.trim().split(/\s+as\s+/);
+			if (parts.length === 2) exportMap[parts[1].trim()] = parts[0].trim();
+		}
+		const inlineable = [];
+		const nonInlineable = [];
+		const pendingLocals = new Set(bindings.map((binding) => binding.local));
+		for (const b of bindings) {
+			pendingLocals.delete(b.local);
+			const proxyLocal = exportMap[b.imported];
+			if (!proxyLocal) {
+				claimedLocals.add(b.local);
+				nonInlineable.push(b);
+				continue;
+			}
+			const funcBody = extractFunctionDeclaration(proxyInfo.code, proxyLocal);
+			if (funcBody) {
+				inlineable.push({
+					local: b.local,
+					funcBody: funcBody.replace(functionDeclarationRegExp(proxyLocal), () => `function ${b.local}(`)
+				});
+				claimedLocals.add(b.local);
+			} else {
+				const unavailableLocals = new Set(claimedLocals);
+				pendingLocals.forEach((local) => unavailableLocals.add(local));
+				const resolvedBinding = resolveProxyAlias(b, proxyLocal, nextCode, fullImport, unavailableLocals);
+				claimedLocals.add(resolvedBinding.local);
+				nonInlineable.push(resolvedBinding);
+			}
+		}
+		const hasRenamedAlias = nonInlineable.some((b) => bindings.find((ob) => ob.imported === b.imported)?.local !== b.local);
+		if (inlineable.length === 0 && !hasRenamedAlias) continue;
+		let replacement = "";
+		if (nonInlineable.length > 0) replacement = `import{${nonInlineable.map((b) => b.imported === b.local ? b.imported : `${b.imported} as ${b.local}`).join(",")}}from"${importMatch[2]}";`;
+		replacement += inlineable.map((f) => f.funcBody).join("");
+		nextCode = nextCode.replace(fullImport, () => replacement);
+	}
+	return nextCode;
+}
+function rewriteSystemProxyConsumers(code, systemProxyInfo) {
+	if (!code.includes("System.register(")) return code;
+	let nextCode = code;
+	for (const [proxyFileName, proxyInfo] of Array.from(systemProxyInfo.entries())) {
+		const proxyBaseName = getProxyBaseName(proxyFileName);
+		const depMatch = new RegExp(`["']([^"']*${escapeRegExp$2(proxyBaseName)}[^"']*)["']`).exec(nextCode);
+		if (!depMatch) continue;
+		let setterIndex = 0;
+		const depListMatch = nextCode.match(/System\.register\(\[([\s\S]*?)\]/);
+		if (depListMatch) setterIndex = Array.from(depListMatch[1].matchAll(/["']([^"']+)["']/g)).map((m) => m[1]).findIndex((dep) => dep.includes(proxyBaseName));
+		if (setterIndex < 0) continue;
+		const settersStart = nextCode.indexOf("setters: [");
+		if (settersStart < 0) continue;
+		const setterMatch = Array.from(nextCode.slice(settersStart).matchAll(/\((module\d+)\)\s*=>\s*\{([\s\S]*?)\}/g))[setterIndex];
+		if (!setterMatch) continue;
+		const [fullSetter, moduleLocal, setterBody] = setterMatch;
+		const helpersToInline = [];
+		const nextSetterBody = setterBody.replace(new RegExp(`([A-Za-z_$][\\w$]*)\\s*=\\s*${moduleLocal}\\.([A-Za-z_$][\\w$]*);?`, "g"), (assignment, local, imported) => {
+			const mapped = proxyInfo.exportMap[imported];
+			if (!mapped) return assignment;
+			if (mapped.type === "helper") {
+				helpersToInline.push(mapped.code.replace(functionDeclarationRegExp(imported), () => `function ${local}(`));
+				return "";
+			}
+			return `${local} = ${moduleLocal}.${mapped.exportName};`;
+		});
+		if (nextSetterBody === setterBody && helpersToInline.length === 0) continue;
+		const nextSetter = fullSetter.replace(setterBody, () => nextSetterBody);
+		nextCode = nextCode.replace(fullSetter, () => nextSetter);
+		nextCode = nextCode.replace(depMatch[0], JSON.stringify(proxyInfo.loadShareDep));
+		if (helpersToInline.length > 0) nextCode = nextCode.replace("execute: (function() {", () => {
+			return `execute: (function() {${helpersToInline.join("")}`;
+		});
+	}
+	return nextCode;
+}
+function findRemoteEntryFile(filename, bundle) {
+	const strippedName = filename.replace(/[\[\]]/g, "_").replace(/\.[^/.]+$/, "");
+	let fallback;
+	for (const fileData of Object.values(bundle)) {
+		if (fileData.fileName === filename) return fileData.fileName;
+		if (fallback === void 0 && (strippedName === fileData.name || fileData.name === "remoteEntry")) fallback = fileData.fileName;
+	}
+	return fallback;
+}
+//#endregion
 //#region src/utils/codeRewriter.ts
 const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var CodeRewriter = class {
@@ -291,15 +502,66 @@ function createCodePositionMap(code) {
 }
 //#endregion
 //#region src/utils/htmlEntryUtils.ts
-function findModuleImportSources(code) {
+function isTypeOnlyClause(clause) {
+	const normalized = clause.trim();
+	if (/^type\b/.test(normalized)) return true;
+	const namedSpecifiers = normalized.match(/^\{([\s\S]*)\}$/)?.[1];
+	if (!namedSpecifiers) return false;
+	const specifiers = namedSpecifiers.split(",").map((specifier) => specifier.trim()).filter(Boolean);
+	return specifiers.length > 0 && specifiers.every((specifier) => /^type\s+\S/.test(specifier));
+}
+/**
+* Finds module imports while ignoring comments, strings, and regular expressions.
+* The descriptor keeps enough information for callers to distinguish runtime
+* static imports from type-only imports without introducing a parser dependency.
+*/
+function findModuleImportDescriptors(code) {
 	const codePositions = createCodePositionMap(code);
-	const sources = /* @__PURE__ */ new Set();
-	for (const pattern of [
-		/\b(?:import|export)\s+[^;]*?\bfrom\s*["']([^"']+)["']/g,
-		/\bimport\s*\(\s*["']([^"']+)["']/g,
-		/\bimport\s*["']([^"']+)["']/g
-	]) for (const match of code.matchAll(pattern)) if (codePositions[match.index]) sources.add(match[1]);
-	return Array.from(sources);
+	const descriptors = [];
+	const staticFromPattern = /\b(?:import|export)\s+([\s\S]*?)\s+from\s*(["'])([^"']+)\2/g;
+	const dynamicPattern = /\bimport\s*\(\s*(?:\/\*[\s\S]*?\*\/\s*)?(["'])([^"']+)\1\s*\)/g;
+	const requirePattern = /\brequire\s*\(\s*(["'])([^"']+)\1\s*\)/g;
+	const sideEffectPattern = /\bimport\s*(["'])([^"']+)\1/g;
+	for (const match of code.matchAll(staticFromPattern)) {
+		if (!codePositions[match.index]) continue;
+		descriptors.push({
+			kind: "static",
+			syntax: "import",
+			source: match[3],
+			typeOnly: isTypeOnlyClause(match[1])
+		});
+	}
+	for (const match of code.matchAll(dynamicPattern)) {
+		if (!codePositions[match.index]) continue;
+		descriptors.push({
+			kind: "dynamic",
+			syntax: "import",
+			source: match[2],
+			typeOnly: false
+		});
+	}
+	for (const match of code.matchAll(requirePattern)) {
+		if (!codePositions[match.index]) continue;
+		descriptors.push({
+			kind: "dynamic",
+			syntax: "require",
+			source: match[2],
+			typeOnly: false
+		});
+	}
+	for (const match of code.matchAll(sideEffectPattern)) {
+		if (!codePositions[match.index]) continue;
+		descriptors.push({
+			kind: "static",
+			syntax: "import",
+			source: match[2],
+			typeOnly: false
+		});
+	}
+	return descriptors;
+}
+function findModuleImportSources(code) {
+	return Array.from(new Set(findModuleImportDescriptors(code).filter(({ syntax, typeOnly }) => syntax === "import" && !typeOnly).map(({ source }) => source)));
 }
 function sanitizeDevEntryPath(devEntryPath) {
 	return devEntryPath.replace(/\\\\?/g, "/");
@@ -440,6 +702,7 @@ function normalizeShareItem(key, shareItem) {
 			eager: shareItem.eager || false,
 			requiredVersion: shareItem.requiredVersion !== void 0 ? shareItem.requiredVersion : isImportFalse || shareItem.version ? "*" : version ? `^${version}` : "*",
 			strictVersion: !!shareItem.strictVersion,
+			...shareItem.suppressMissingImportWarning ? { suppressMissingImportWarning: true } : {},
 			...treeShaking ? { treeShaking: { ...treeShaking } } : {}
 		}
 	};
@@ -584,11 +847,11 @@ const idCacheMap = {};
 const VITE_ID_PREFIX = "/@id/";
 const VITE_ENCODED_NULL_BYTE_PREFIX = `${VITE_ID_PREFIX}__x00__`;
 const MF_OWNER_INFIX = "__mf_owner__";
-function escapeRegExp$2(value) {
+function escapeRegExp$1(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function createViteEncodedIdPrefixRegExp(sourcePrefix = "") {
-	return new RegExp(`^(?:${escapeRegExp$2(VITE_ENCODED_NULL_BYTE_PREFIX)})?${sourcePrefix}`);
+	return new RegExp(`^(?:${escapeRegExp$1(VITE_ENCODED_NULL_BYTE_PREFIX)})?${sourcePrefix}`);
 }
 function toViteEncodedId(id) {
 	return `${VITE_ENCODED_NULL_BYTE_PREFIX}${id}`;
@@ -686,6 +949,17 @@ function getSsrCapabilities(viteMajor, command, hasRemotes) {
 }
 //#endregion
 //#region src/utils/serializeRuntimeOptions.ts
+const UNSAFE_JS_CHAR_MAP = {
+	"<": "\\u003C",
+	"\u2028": "\\u2028",
+	"\u2029": "\\u2029"
+};
+const UNSAFE_JS_CHAR_PATTERN = /[<\u2028\u2029]/g;
+function toSafeJsLiteral(value) {
+	const json = JSON.stringify(value);
+	if (json === void 0) return "undefined";
+	return json.replace(UNSAFE_JS_CHAR_PATTERN, (char) => UNSAFE_JS_CHAR_MAP[char]);
+}
 /**
 * Serializes a JavaScript object into a string of source code that can be evaluated.
 * This function is used to create runtime plugin options without relying solely on JSON.stringify,
@@ -703,16 +977,13 @@ function serializeRuntimeOptions(options) {
 	function valueToCode(val) {
 		if (val === null) return "null";
 		const type = typeof val;
-		if (type === "string") return JSON.stringify(val);
+		if (type === "string") return toSafeJsLiteral(val);
 		if (type === "number" || type === "boolean") return String(val);
 		if (type === "undefined") return "undefined";
-		if (type === "symbol") {
-			const desc = val.description ?? "";
-			return `Symbol(${JSON.stringify(desc)})`;
-		}
+		if (type === "symbol") return `Symbol(${toSafeJsLiteral(val.description ?? "")})`;
 		if (type === "function") return val.toString();
-		if (val instanceof Date) return `new Date(${JSON.stringify(val.toISOString())})`;
-		if (val instanceof RegExp) return `new RegExp(${JSON.stringify(val.source)}, ${JSON.stringify(val.flags)})`;
+		if (val instanceof Date) return `new Date(${toSafeJsLiteral(val.toISOString())})`;
+		if (val instanceof RegExp) return `new RegExp(${toSafeJsLiteral(val.source)}, ${toSafeJsLiteral(val.flags)})`;
 		if (type === "object") {
 			if (ancestors.has(val)) return `"__circular__"`;
 			ancestors.add(val);
@@ -721,16 +992,16 @@ function serializeRuntimeOptions(options) {
 				if (val instanceof Map) return `new Map([${Array.from(val.entries()).map(([k, v]) => `[${valueToCode(k)}, ${valueToCode(v)}]`).join(", ")}])`;
 				if (val instanceof Set) return `new Set([${Array.from(val.values()).map(valueToCode).join(", ")}])`;
 				const properties = [];
-				for (const key in val) if (Object.prototype.hasOwnProperty.call(val, key)) properties.push(`${JSON.stringify(key)}: ${valueToCode(val[key])}`);
+				for (const key in val) if (Object.prototype.hasOwnProperty.call(val, key)) properties.push(`${toSafeJsLiteral(key)}: ${valueToCode(val[key])}`);
 				return `{${properties.join(", ")}}`;
 			} finally {
 				ancestors.delete(val);
 			}
 		}
-		return JSON.stringify(String(val));
+		return toSafeJsLiteral(String(val));
 	}
 	const topLevelProps = [];
-	for (const key in options) if (Object.prototype.hasOwnProperty.call(options, key)) topLevelProps.push(`${JSON.stringify(key)}: ${valueToCode(options[key])}`);
+	for (const key in options) if (Object.prototype.hasOwnProperty.call(options, key)) topLevelProps.push(`${toSafeJsLiteral(key)}: ${valueToCode(options[key])}`);
 	return `{${topLevelProps.join(", ")}}`;
 }
 //#endregion
@@ -1084,12 +1355,56 @@ function generateExposes(options, remoteDependencyMap = {}, command = "build", r
   `;
 }
 //#endregion
+//#region src/utils/sharedExportConditions.ts
+const DEFAULT_CLIENT_EXPORT_CONDITIONS = [
+	"browser",
+	"import",
+	"module",
+	"default"
+];
+const DEFAULT_NODE_SSR_EXPORT_CONDITIONS = [
+	"node",
+	"import",
+	"module",
+	"default"
+];
+const DEFAULT_WEBWORKER_SSR_EXPORT_CONDITIONS = [
+	"worker",
+	"browser",
+	"import",
+	"module",
+	"default"
+];
+const VITE_DEV_PROD_CONDITION = "development|production";
+function appendConditions(conditions, fallbackConditions) {
+	return [.../* @__PURE__ */ new Set([...conditions, ...fallbackConditions])];
+}
+function resolveViteModeCondition(conditions, isProduction) {
+	const modeCondition = isProduction ? "production" : "development";
+	return [...new Set(conditions.map((condition) => condition === VITE_DEV_PROD_CONDITION ? modeCondition : condition))];
+}
+function getSharedExportConditions({ environmentConditions, isProduction, isSsr, rootConditions, ssrConditions, ssrTarget = "node" }) {
+	if (environmentConditions !== void 0) return resolveViteModeCondition(appendConditions(environmentConditions, ["import", "default"]), isProduction);
+	const defaultConditions = isSsr ? ssrTarget === "webworker" ? DEFAULT_WEBWORKER_SSR_EXPORT_CONDITIONS : DEFAULT_NODE_SSR_EXPORT_CONDITIONS : DEFAULT_CLIENT_EXPORT_CONDITIONS;
+	const configuredConditions = isSsr ? ssrConditions ?? rootConditions : rootConditions;
+	if (configuredConditions !== void 0) return resolveViteModeCondition(appendConditions(configuredConditions, defaultConditions), isProduction);
+	return [...defaultConditions];
+}
+function isReactServerConditions(conditions) {
+	return Boolean(conditions?.includes("react-server"));
+}
+//#endregion
 //#region src/virtualModules/virtualRuntimeInitStatus.ts
 const virtualRuntimeInitStatus = new VirtualModule("runtimeInit");
 const runtimeInitModules = /* @__PURE__ */ new WeakMap();
 const runtimeInitOwnerIds = /* @__PURE__ */ new WeakMap();
 let nextRuntimeInitOwnerId = 1;
 const MODULE_CACHE_GLOBAL_KEY = "__mf_module_cache__";
+const REACT_SERVER_MODULE_CACHE_GLOBAL_KEY = "__mf_module_cache_react_server__";
+const MODULE_CACHE_SHARE_SCOPE_KEY = "module-federation.vite-module-cache";
+function getModuleCacheGlobalKey(exportConditions) {
+	return isReactServerConditions(exportConditions) ? REACT_SERVER_MODULE_CACHE_GLOBAL_KEY : MODULE_CACHE_GLOBAL_KEY;
+}
 function getRuntimeInitOwnerId(options) {
 	let ownerId = runtimeInitOwnerIds.get(options);
 	if (!ownerId) {
@@ -1133,7 +1448,7 @@ function getSsrNoopResolveCode(enableSsrInit, hostInitImportId, initResolveExpre
 	if (!enableSsrInit) return "";
 	return `if (${SERVER_ENV_GUARD}) {
     var _noop = { loadRemote: function() { return Promise.resolve(undefined); }, loadShare: function() { return Promise.resolve(undefined); } };
-    ${hostInitImportId ? `import(${JSON.stringify(hostInitImportId)})
+    ${hostInitImportId ? `import(${toSafeJsLiteral(hostInitImportId)})
       .then(function(mod) { return mod.hostInitPromise; })
       .then(function(runtime) {
         ${initResolveExpression}(runtime);
@@ -1149,7 +1464,7 @@ function getSsrNoopResolveCode(enableSsrInit, hostInitImportId, initResolveExpre
           function() { return [runtimeMod, []]; }
         );
       }).then(function(pair) {
-        var runtime = pair[0].init({ name: '__mf_ssr_host__', remotes: ${JSON.stringify(ssrRemotes)}, shared: {}, plugins: pair[1] });
+        var runtime = pair[0].init({ name: '__mf_ssr_host__', remotes: ${toSafeJsLiteral(ssrRemotes)}, shared: {}, plugins: pair[1] });
         ${initResolveExpression}(runtime);
       }, function() {
         ${initResolveExpression}(_noop);
@@ -1159,7 +1474,7 @@ function getSsrNoopResolveCode(enableSsrInit, hostInitImportId, initResolveExpre
 }
 function getRuntimeInitStateBootstrapCode(options) {
 	return `
-const ${options.globalKeyVar} = ${JSON.stringify(getRuntimeInitGlobalKey(options.ownerImportId))};
+const ${options.globalKeyVar} = ${toSafeJsLiteral(getRuntimeInitGlobalKey(options.ownerImportId))};
 let ${options.stateVar} = globalThis[${options.globalKeyVar}];
 if (!${options.stateVar}) {
   ${getDeferredInitPromiseCode()}
@@ -1173,10 +1488,10 @@ if (!${options.stateVar}) {
 const ${options.exposedConst} = ${options.stateVar}.${options.exposedProperty};
 `;
 }
-function getRuntimeInitBootstrapCode(enableSsrInit = false, ownerImportId, ssrRemotes, hostInitImportId = ownerImportId) {
+function getRuntimeInitBootstrapCode(enableSsrInit = false, ownerImportId, ssrRemotes, hostInitImportId = ownerImportId, exportConditions) {
 	return `
-const globalKey = ${JSON.stringify(getRuntimeInitGlobalKey(ownerImportId))};
-const moduleCacheGlobalKey = ${JSON.stringify(MODULE_CACHE_GLOBAL_KEY)};
+const globalKey = ${toSafeJsLiteral(getRuntimeInitGlobalKey(ownerImportId))};
+const moduleCacheGlobalKey = ${toSafeJsLiteral(getModuleCacheGlobalKey(exportConditions))};
 globalThis[moduleCacheGlobalKey] ||= { share: {}, remote: {} };
 globalThis[moduleCacheGlobalKey].share ||= {};
 globalThis[moduleCacheGlobalKey].remote ||= {};
@@ -1194,14 +1509,14 @@ if (${SERVER_ENV_GUARD} && !globalThis[globalKey].ssrInitStarted) {
   globalThis[globalKey].ssrInitStarted = true;
   ${getSsrNoopResolveCode(enableSsrInit, hostInitImportId, "globalThis[globalKey].initResolve", ssrRemotes)}
 }` : ""}
-globalThis[globalKey].moduleCache ||= globalThis[moduleCacheGlobalKey];
+globalThis[globalKey].moduleCache = globalThis[moduleCacheGlobalKey];
 globalThis[globalKey].moduleCache.share ||= {};
 globalThis[globalKey].moduleCache.remote ||= {};
 `;
 }
-function getRuntimeModuleCacheBootstrapCode() {
+function getRuntimeModuleCacheBootstrapCode(exportConditions) {
 	return `
-const __mfCacheGlobalKey = ${JSON.stringify(MODULE_CACHE_GLOBAL_KEY)};
+const __mfCacheGlobalKey = ${toSafeJsLiteral(getModuleCacheGlobalKey(exportConditions))};
 globalThis[__mfCacheGlobalKey] ||= { share: {}, remote: {} };
 globalThis[__mfCacheGlobalKey].share ||= {};
 globalThis[__mfCacheGlobalKey].remote ||= {};
@@ -2109,10 +2424,12 @@ function getNamedExportsViaRegex(source, filePath, visited, scanState = { comple
 	const exportKeywordRegex = /\bexport\b/g;
 	while ((match = exportKeywordRegex.exec(source)) !== null) {
 		if (!codePositions[match.index]) continue;
-		if (!recognizedExportStarts.has(match.index)) {
-			scanState.complete = false;
-			break;
-		}
+		if (recognizedExportStarts.has(match.index)) continue;
+		let previousCodeIndex = match.index - 1;
+		while (previousCodeIndex >= 0 && (/\s/.test(source[previousCodeIndex]) || !codePositions[previousCodeIndex])) previousCodeIndex--;
+		if (source[previousCodeIndex] === ".") continue;
+		scanState.complete = false;
+		break;
 	}
 	return Array.from(names);
 }
@@ -2345,7 +2662,8 @@ const legacySharedVirtualModuleState = {
 	preBuildShareItemMap: {},
 	treeShakingProviderCacheMap: {},
 	materializedTreeShakingProviders: /* @__PURE__ */ new Set(),
-	loadShareCacheMap: {}
+	loadShareCacheMap: {},
+	warnedMissingImportFalse: /* @__PURE__ */ new Set()
 };
 const sharedVirtualModuleStates = /* @__PURE__ */ new WeakMap();
 let nextSharedVirtualModuleOwnerId = 1;
@@ -2364,6 +2682,7 @@ function getSharedVirtualModuleState(options) {
 			treeShakingProviderCacheMap: {},
 			materializedTreeShakingProviders: /* @__PURE__ */ new Set(),
 			loadShareCacheMap: {},
+			warnedMissingImportFalse: /* @__PURE__ */ new Set(),
 			ownerKey: `${options.internalName}${MF_OWNER_INFIX}${nextSharedVirtualModuleOwnerId++}`
 		};
 		sharedVirtualModuleStates.set(options, state);
@@ -2481,7 +2800,7 @@ function writePreBuildLibPath(pkg, shareItem, options, exportConditions) {
 		});
 		preBuildCacheMap[pkg].writeSync(`
     ${sharedCacheHelperCode}
-    const __mfCacheGlobalKey = "__mf_module_cache__";
+    const __mfCacheGlobalKey = ${JSON.stringify(getModuleCacheGlobalKey(exportConditions))};
     export const c = function(size) {
       const cache = globalThis[__mfCacheGlobalKey]?.share;
       const sharedReact = cache && __mfReadSharedCache(cache, ${reactCacheDescriptor});
@@ -2545,12 +2864,12 @@ function writePreBuildLibPath(pkg, shareItem, options, exportConditions) {
   `, true);
 }
 /** Re-render already materialized wrappers after import analysis discovers exports. */
-function refreshTreeShakingModules(options) {
+function refreshTreeShakingModules(options, command = "build", isRolldown = false, exportConditions) {
 	const { preBuildShareItemMap } = getSharedVirtualModuleState(options);
 	for (const [pkg, shareItem] of Object.entries(preBuildShareItemMap)) {
 		if (!shareItem?.shareConfig.treeShaking) continue;
-		writePreBuildLibPath(pkg, shareItem, options);
-		writeLoadShareModule(pkg, shareItem, "build", false, options);
+		writePreBuildLibPath(pkg, shareItem, options, exportConditions);
+		writeLoadShareModule(pkg, shareItem, command, isRolldown, options, exportConditions);
 	}
 }
 function getPreBuildLibImportId(pkg, options) {
@@ -2752,7 +3071,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const { loadShareCacheMap } = getSharedVirtualModuleState(options);
 	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = createScopedSharedVirtualModule(pkg, LOAD_SHARE_TAG, options);
-	let importLine = getRuntimeModuleCacheBootstrapCode();
+	let importLine = getRuntimeModuleCacheBootstrapCode(exportConditions);
 	const cacheDescriptor = getSharedCacheDescriptorLiteral(pkg, shareItem);
 	const cacheOwner = JSON.stringify(resolvedOptions.name);
 	const runtimeInitOwnerImportId = options ? getRuntimeInitStatusImportId(options) : void 0;
@@ -2763,7 +3082,11 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 		let exportLine;
 		if (namedExports.length > 0) exportLine = generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor, treeShakingConsumer);
 		else {
-			if (detectedNamedExports === void 0) mfWarn(`Shared dependency "${pkg}" has import: false but is not installed locally.\n  Named imports (e.g. import { ... } from '${pkg}') will not work in production builds.\n  Install it as a devDependency to enable named export detection.`);
+			const { warnedMissingImportFalse } = getSharedVirtualModuleState(resolvedOptions);
+			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.`);
+			}
 			exportLine = generateDeferredHostProvidedExports([], pkg, cacheDescriptor, treeShakingConsumer);
 		}
 		loadShareCacheMap[pkg].writeSync(`
@@ -2795,18 +3118,18 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	const servesRemoteSingletonFallback = command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true;
 	const isConsumedByPeerSingleton = isSharedSingletonConsumedByPeer(pkg, resolvedOptions);
 	const usesEntryInjectedRemoteFallback = hasCompleteExportCoverage && command !== "build" && !isWorkspaceSingleton && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true && resolvedOptions.hostInitInjectLocation === "entry" && isConsumedByPeerSingleton;
-	const usesEagerWorkspaceFallback = hasCompleteExportCoverage && isWorkspaceSingleton && (isConsumedByPeerSingleton || shareItem.shareConfig.eager === true);
+	const usesEagerWorkspaceFallback = hasCompleteExportCoverage && isWorkspaceSingleton && !servesRemoteSingletonFallback && (isConsumedByPeerSingleton || shareItem.shareConfig.eager === true);
 	const usesDeferredTreeShakingFallback = hasCompleteExportCoverage && Boolean(treeShakingConsumer);
 	const reactMixedModeGuard = pkg === "react" ? createReactMixedModeRuntimeGuard() : "";
 	let exportLine;
 	let initBlock = "";
 	if (usesDeferredTreeShakingFallback) {
 		importLine = `${getRuntimeInitPromiseBootstrapCode(false, runtimeInitOwnerImportId)}\n    ${importLine}`;
-		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && (isWorkspaceSingleton || isWorkspacePackage || servesRemoteSingletonFallback), liveNamedExports);
+		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && !servesRemoteSingletonFallback && (isWorkspaceSingleton || isWorkspacePackage), liveNamedExports);
 	} else if (usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback) exportLine = generateEagerWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, liveNamedExports);
 	else if (usesDeferredSingletonFallback) {
 		importLine = `${getRuntimeInitPromiseBootstrapCode(false, runtimeInitOwnerImportId)}\n    ${importLine}`;
-		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && (isWorkspaceSingleton || isWorkspacePackage || servesRemoteSingletonFallback), liveNamedExports);
+		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && !servesRemoteSingletonFallback && (isWorkspaceSingleton || isWorkspacePackage), liveNamedExports);
 	} else if (detectedNamedExports === void 0) {
 		exportLine = `const __mfDefaultExport = (() => {
       ${generateShareModuleUnwrapCode({
@@ -2875,7 +3198,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
       __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
 	}
-	const prebuildImportLine = usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback ? "" : usesDeferredSingletonFallback || usesDeferredTreeShakingFallback ? servesRemoteSingletonFallback || usesDeferredSingletonFallback && command !== "build" && (isWorkspaceSingleton || isWorkspacePackage) ? `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(lazyLocalFallbackSource)};` : "" : `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(detectedNamedExports === void 0 ? coherentLocalSource : skipServePrebuildWarmup ? devImportSource : sharedImportSource)};`;
+	const prebuildImportLine = usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback ? "" : usesDeferredSingletonFallback || usesDeferredTreeShakingFallback ? !servesRemoteSingletonFallback && usesDeferredSingletonFallback && command !== "build" && (isWorkspaceSingleton || isWorkspacePackage) ? `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(lazyLocalFallbackSource)};` : "" : `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(detectedNamedExports === void 0 ? coherentLocalSource : skipServePrebuildWarmup ? devImportSource : sharedImportSource)};`;
 	const devDynamicImportLine = isWorkspacePackage ? "" : usesDeferredSingletonFallback || usesDeferredTreeShakingFallback ? "" : command !== "build" && !skipServePrebuildWarmup ? `;() => import(${escapeGeneratedStringLiteral(devImportSource)}).catch(() => {});` : "";
 	const moduleBody = usesDeferredSingletonFallback || usesDeferredTreeShakingFallback ? `
     ${prebuildImportLine}
@@ -2982,15 +3305,15 @@ function generateLocalSharedImportMap(options) {
     ${orderedShares.map((pkg, index) => {
 		const shareItem = getNormalizeShareItem(pkg, resolvedOptions);
 		if (!shareItem?.shareConfig.eager || shareItem.shareConfig.import === false) return "";
-		return `import * as __mfEagerShare_${index} from ${JSON.stringify(getLocalSharedPackagePath(pkg, shareItem, options))};`;
+		return `import * as __mfEagerShare_${index} from ${toSafeJsLiteral(getLocalSharedPackagePath(pkg, shareItem, options))};`;
 	}).filter(Boolean).join("\n")}
     const importMap = {
       ${orderedShares.map((pkg, index) => {
 		const shareItem = getNormalizeShareItem(pkg, resolvedOptions);
 		return `
-        ${JSON.stringify(pkg)}: async () => {
-          ${shareItem?.shareConfig.import === false ? `throw new Error(\`[Module Federation] Shared module '\${${JSON.stringify(pkg)}}' must be provided by host\`);` : shareItem?.shareConfig.eager ? `let pkg = __mfEagerShare_${index};
-            return pkg;` : `let pkg = await import(${JSON.stringify(getLocalSharedPackagePath(pkg, shareItem, options))});
+        ${toSafeJsLiteral(pkg)}: async () => {
+          ${shareItem?.shareConfig.import === false ? `throw new Error(\`[Module Federation] Shared module '\${${toSafeJsLiteral(pkg)}}' must be provided by host\`);` : shareItem?.shareConfig.eager ? `let pkg = __mfEagerShare_${index};
+            return pkg;` : `let pkg = await import(${toSafeJsLiteral(getLocalSharedPackagePath(pkg, shareItem, options))});
             return pkg;`}
         }
       `;
@@ -3010,23 +3333,23 @@ function generateLocalSharedImportMap(options) {
 		const treeShakingProviderImportId = treeShakingConfig && !disableRuntimeInference && hasTreeShakingSharedProvider(key, shareItem, options) ? getTreeShakingSharedProviderImportId(key, options) : void 0;
 		const treeShakingStatus = treeShakingUsage?.kind === "full" || disableRuntimeInference || treeShakingConfig?.mode === "runtime-infer" && !treeShakingProviderImportId && shareItem.shareConfig.import !== false ? 0 : 1;
 		return `
-          ${JSON.stringify(key)}: {
-            name: ${JSON.stringify(key)},
-            version: ${JSON.stringify(shareItem.version)},
-            scope: [${JSON.stringify(shareItem.scope)}],
+          ${toSafeJsLiteral(key)}: {
+            name: ${toSafeJsLiteral(key)},
+            version: ${toSafeJsLiteral(shareItem.version)},
+            scope: [${toSafeJsLiteral(shareItem.scope)}],
             loaded: false,
             materialize: ${sharesToMaterialize.has(key)},
             eager: ${Boolean(shareItem.shareConfig.eager)},
-            from: ${JSON.stringify(resolvedOptions.name)},
+            from: ${toSafeJsLiteral(resolvedOptions.name)},
             canLiveRebind: ${canLiveRebind},
             async get () {
               if (${shareItem.shareConfig.import === false}) {
-                throw new Error(\`[Module Federation] Shared module '\${${JSON.stringify(key)}}' must be provided by host\`);
+                throw new Error(\`[Module Federation] Shared module '\${${toSafeJsLiteral(key)}}' must be provided by host\`);
               }
-              usedShared[${JSON.stringify(key)}].loaded = true
-              const {${JSON.stringify(key)}: pkgDynamicImport} = importMap
+              usedShared[${toSafeJsLiteral(key)}].loaded = true
+              const {${toSafeJsLiteral(key)}: pkgDynamicImport} = importMap
               const res = await pkgDynamicImport()
-              const exportModule = ${JSON.stringify(useDirectReactImport)} && ${JSON.stringify(key)} === "react"
+              const exportModule = ${toSafeJsLiteral(useDirectReactImport)} && ${toSafeJsLiteral(key)} === "react"
                 ? (res?.default ?? res)
                 : {...res}
               // All npm packages pre-built by vite will be converted to esm
@@ -3042,18 +3365,18 @@ function generateLocalSharedImportMap(options) {
             },
             shareConfig: {
               singleton: ${shareItem.shareConfig.singleton},
-              requiredVersion: ${JSON.stringify(shareItem.shareConfig.requiredVersion)},
+              requiredVersion: ${toSafeJsLiteral(shareItem.shareConfig.requiredVersion)},
               strictVersion: ${shareItem.shareConfig.strictVersion},
               eager: ${Boolean(shareItem.shareConfig.eager)},
               ${shareItem.shareConfig.import === false ? "import: false," : ""}
             },
             ${treeShakingConfig ? `treeShaking: {
-              mode: ${JSON.stringify(treeShakingConfig.mode)},
-              usedExports: ${JSON.stringify(treeShakingUsedExports)},
-              providedExports: ${JSON.stringify(treeShakingProviderExports)},
+              mode: ${toSafeJsLiteral(treeShakingConfig.mode)},
+              usedExports: ${toSafeJsLiteral(treeShakingUsedExports)},
+              providedExports: ${toSafeJsLiteral(treeShakingProviderExports)},
               status: ${treeShakingStatus},
               ${treeShakingProviderImportId ? `async get() {
-                const container = await import(${JSON.stringify(treeShakingProviderImportId)});
+                const container = await import(${toSafeJsLiteral(treeShakingProviderImportId)});
                 if (typeof container.init === "function") await container.init();
                 return container.get();
               },` : ""}
@@ -3067,12 +3390,12 @@ function generateLocalSharedImportMap(options) {
 		if (!remote) return null;
 		return `
                 {
-                  alias: ${JSON.stringify(key)},
-                  entryGlobalName: ${JSON.stringify(remote.entryGlobalName)},
-                  name: ${JSON.stringify(options ? getRuntimeRemoteAlias(key, options) : remote.name)},
-                  type: ${JSON.stringify(remote.type)},
-                  entry: ${JSON.stringify(remote.entry)},
-                  shareScope: ${JSON.stringify(remote.shareScope ?? "default")},
+                  alias: ${toSafeJsLiteral(key)},
+                  entryGlobalName: ${toSafeJsLiteral(remote.entryGlobalName)},
+                  name: ${toSafeJsLiteral(options ? getRuntimeRemoteAlias(key, options) : remote.name)},
+                  type: ${toSafeJsLiteral(remote.type)},
+                  entry: ${toSafeJsLiteral(remote.entry)},
+                  shareScope: ${toSafeJsLiteral(remote.shareScope ?? "default")},
                 }
           `;
 	}).filter((x) => x !== null).join(",")}
@@ -3122,7 +3445,6 @@ function getMaterializedShares(options) {
 			}
 		}
 	}
-	if (hasPackageDependency("vinext")) shares.delete("react");
 	return orderSharedDependenciesFirst([...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);
@@ -3214,8 +3536,8 @@ function getShareItemForPreload(pkg, options = getNormalizeModuleFederationOptio
 function generateSharedCacheSeedItem(pkg, shareItem, importPath, options = getNormalizeModuleFederationOptions()) {
 	const cacheDescriptor = getSharedCacheDescriptor(pkg, shareItem);
 	const cacheOwner = options.name;
-	return `if (__mfReadSharedCache(__mfModuleCache.share, ${JSON.stringify(cacheDescriptor)}) === undefined) {
-        const mod = await import(${JSON.stringify(importPath)});
+	return `if (__mfReadSharedCache(__mfModuleCache.share, ${toSafeJsLiteral(cacheDescriptor)}) === undefined) {
+        const mod = await import(${toSafeJsLiteral(importPath)});
         ${normalizeRuntimeShareCode}
         const normalizedModule = __mfNormalizeRuntimeShare(mod);
         const exportModule = normalizedModule === mod ? {...mod} : normalizedModule;
@@ -3223,7 +3545,7 @@ function generateSharedCacheSeedItem(pkg, shareItem, importPath, options = getNo
           value: true,
           enumerable: false
         });
-        __mfWriteSharedCache(__mfModuleCache.share, ${JSON.stringify(cacheDescriptor)}, exportModule, ${JSON.stringify(cacheOwner)});
+        __mfWriteSharedCache(__mfModuleCache.share, ${toSafeJsLiteral(cacheDescriptor)}, exportModule, ${toSafeJsLiteral(cacheOwner)});
       }`;
 }
 const normalizeRuntimeShareCode = `const __mfNormalizeRuntimeShare = (mod) => {
@@ -3385,9 +3707,13 @@ const externalSharedProviderSelectionHelperCode = `const __mfSelectExternalShare
 function generateRuntimeSharedCacheSeedCode(shareStrategy, options) {
 	const seedBatches = getShareBatches(options, false);
 	return `
-    const __mfSeedOrder = ${JSON.stringify(seedBatches.flat())};
-    const __mfSeedBatches = ${JSON.stringify(seedBatches)};
-    const __mfSeedKeys = __mfSeedOrder.filter((pkg) => usedShared[pkg] && usedShared[pkg].materialize !== false);
+    const __mfSeedOrder = ${toSafeJsLiteral(seedBatches.flat())};
+    const __mfSeedBatches = ${toSafeJsLiteral(seedBatches)};
+    // A share is normally skipped here until the dev scanner has observed a real
+    // import and set materialize. An import:false share has no local fallback
+    // though, so on a cold request (materialize not set yet) it must still be
+    // attempted here, or it is never seeded and its consumer reads it undefined.
+    const __mfSeedKeys = __mfSeedOrder.filter((pkg) => usedShared[pkg] && (usedShared[pkg].materialize !== false || usedShared[pkg].shareConfig?.import === false));
     __mfModuleCache.providerInit ||= new Map();
     const __mfInitializeProviderOnce = (key, initialize) => {
       const existing = __mfModuleCache.providerInit.get(key);
@@ -3486,7 +3812,7 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy, options) {
         initialShared[pkg],
         pkg,
         share,
-        ${JSON.stringify(shareStrategy)}
+        ${toSafeJsLiteral(shareStrategy)}
       ));
     };
     const __mfFirstRuntimeSeedBarrierIndex = __mfSeedKeys.findIndex(
@@ -3689,11 +4015,11 @@ function generateTreeShakingSnapshotPluginCode(enabled) {
     },
   });`;
 }
-function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(options), command = "build") {
+function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(options), command = "build", exportConditions) {
 	const needsSharedProviderSelectionHelper = Object.keys(options.shared ?? {}).length > 0;
 	const hasTreeShakingShared = Object.values(options.shared ?? {}).some((share) => !!share?.shareConfig.treeShaking);
 	const hasMultipleShareScopes = Array.isArray(options.shareScope);
-	const materializedShareBatches = JSON.stringify(getShareBatches(options, false));
+	const materializedShareBatches = toSafeJsLiteral(getShareBatches(options, false));
 	const runtimeImports = [
 		"init as runtimeInit",
 		"loadRemote",
@@ -3747,12 +4073,12 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   import {${runtimeImports}} from "@module-federation/runtime";
   ${runtimeHelperImports.length ? `import {${runtimeHelperImports.join(", ")}} from "@module-federation/runtime/helpers";` : ""}
   ${pluginImportNames.filter((item) => !isSsrOnlyPlugin(item[1])).map((item) => item[1]).join("\n")}
-  ${command === "build" ? getRuntimeInitResolveBootstrapCode(false, getRuntimeInitStatusImportId(options)) : getRuntimeInitBootstrapCode(false, getRuntimeInitStatusImportId(options)) + "\n  const { initResolve } = globalThis[globalKey];"}
-  ${getRuntimeModuleCacheBootstrapCode()}
+  ${command === "build" ? getRuntimeInitResolveBootstrapCode(false, getRuntimeInitStatusImportId(options)) : getRuntimeInitBootstrapCode(false, getRuntimeInitStatusImportId(options), void 0, void 0, exportConditions) + "\n  const { initResolve } = globalThis[globalKey];"}
+  ${getRuntimeModuleCacheBootstrapCode(exportConditions)}
   const initTokens = {}
-  const shareScopeNames = Array.isArray(${JSON.stringify(options.shareScope)}) ? ${JSON.stringify(options.shareScope)} : [${JSON.stringify(options.shareScope)}]
-  const shareScopeName = ${JSON.stringify(hasMultipleShareScopes ? options.shareScope[0] : options.shareScope)}
-  const mfName = ${JSON.stringify(options.name)}
+  const shareScopeNames = Array.isArray(${toSafeJsLiteral(options.shareScope)}) ? ${toSafeJsLiteral(options.shareScope)} : [${toSafeJsLiteral(options.shareScope)}]
+  const shareScopeName = ${toSafeJsLiteral(hasMultipleShareScopes ? options.shareScope[0] : options.shareScope)}
+  const mfName = ${toSafeJsLiteral(options.name)}
   const __mfMaterializedShareBatches = ${materializedShareBatches}
   let localSharedImportMapPromise
   let exposesMapPromise
@@ -3882,7 +4208,12 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
     function isWebpackProvider(provider) {
       if (typeof provider?.get !== 'function') return false;
       const source = Function.prototype.toString.call(provider.get);
-      return source.includes('__webpack_require__');
+      // Production minification renames __webpack_require__, but preserves
+      // Webpack's lazy chunk-loading .e(...).then(...) shape.
+      return (
+        source.includes('__webpack_require__') ||
+        /\\.\\s*e\\s*\\([^)]*\\)\\s*\\.then\\s*\\(/.test(source)
+      );
     }
     const __mfUsesWebpackShareScope = Object.values(initialShared).some((versions) =>
       Object.values(versions || {}).some(isWebpackProvider)
@@ -3934,7 +4265,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       ? await Promise.all([${pluginImportNames.filter((item) => isSsrOnlyPlugin(item[1])).map((item) => {
 		const specifier = getSsrOnlyPluginSpecifier(item[1]);
 		const opts = item[2];
-		return `import(${JSON.stringify(specifier)}).then(m => (m.default ?? m)(${opts}))`;
+		return `import(${toSafeJsLiteral(specifier)}).then(m => (m.default ?? m)(${opts}))`;
 	}).join(", ")}])
       : [];
     const __mfRuntimeShareLoadIdKey = "__mf_vite_runtime_share_load_id__";
@@ -3945,7 +4276,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       name: mfName,
       remotes: ${options.shareStrategy === "loaded-first" ? "[]" : "usedRemotes"},
       shared: usedShared,
-      plugins: [__mfSharePinLifecyclePlugin(), ${hasTreeShakingShared ? "__mfTreeShakingSnapshotPlugin()," : ""} ...__browserPlugins, ...__ssrPlugins],
+      plugins: [__mfSharePinLifecyclePlugin(), __mfRealNameSnapshotPlugin(), ${hasTreeShakingShared ? "__mfTreeShakingSnapshotPlugin()," : ""} ...__browserPlugins, ...__ssrPlugins],
       ${options.shareStrategy ? `shareStrategy: '${options.shareStrategy}'` : ""}
     });
     ${hasMultipleShareScopes ? `for (const shareScopeName of shareScopeNamesToInitialize) {
@@ -3977,6 +4308,33 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
         }
       };
     }
+    function __mfRealNameSnapshotPlugin() {
+      return {
+        name: "vite-real-name-snapshot-plugin",
+        afterLoadSnapshot(args) {
+          // Remotes are registered under an owner-scoped runtime name, so the
+          // global snapshot only ever holds that name. Containers built by other
+          // bundlers ask for the same remote by its real container name, miss, and
+          // fall back to that container's own entry, whose remoteEntry is empty
+          // (RUNTIME-011). Mirroring the resolved snapshot under the real name
+          // keeps the primary lookup off that fallback.
+          const snapshot = args && args.remoteSnapshot;
+          const globalName = snapshot && snapshot.globalName;
+          const version = snapshot && snapshot.version;
+          if (!globalName || !version || !snapshot.remoteEntry) return args;
+          const moduleInfo = globalThis.__FEDERATION__ && globalThis.__FEDERATION__.moduleInfo;
+          const realNameKey = globalName + ":" + version;
+          // Stores the same object, not a copy, so a later mutation (e.g. runtime-core
+          // normalizing fields) stays consistent across both keys. Never overwrites an
+          // existing entry: a different owner may have already resolved this real name
+          // to its own snapshot, and this mirror must not shadow that one.
+          if (moduleInfo && !moduleInfo[realNameKey]) {
+            moduleInfo[realNameKey] = snapshot;
+          }
+          return args;
+        }
+      };
+    }
     const runtimeResolveShareHook = initRes.sharedHandler.hooks.lifecycle.resolveShare;
     const __mfRuntimeProviderOrigins = new WeakMap();
     runtimeResolveShareHook.on((args) => {
@@ -4005,7 +4363,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       if (!versionMap || versionMap[version] !== currentProvider) return undefined;
       const pinnedProvider = Object.assign({}, provider, {
         version: provider.version ?? version,
-        scope: provider.scope ?? currentProvider?.scope ?? ${JSON.stringify(hasMultipleShareScopes ? options.shareScope : [options.shareScope])},
+        scope: provider.scope ?? currentProvider?.scope ?? ${toSafeJsLiteral(hasMultipleShareScopes ? options.shareScope : [options.shareScope])},
         strategy: 'loaded-first'
       });
       const providerFrom = provider.from;
@@ -4277,7 +4635,6 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       expectedSelection
     ) => {
       try {
-        if (__mfGetPendingExternalSharedProvider(pkg, usedShare)) return;
         const usedCacheDescriptor = __mfGetSharedCacheDescriptor(pkg, usedShare.shareConfig?.singleton, usedShare.version, usedShare.scope);
         const cachedShare = __mfReadSharedCache(__mfModuleCache.share, usedCacheDescriptor);
         const cachedShareOwner = __mfReadSharedCacheOwner(__mfModuleCache.share, usedCacheDescriptor);
@@ -4325,12 +4682,6 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
           !scopeRootProvider &&
           !__mfMatchesSharedProvider(liveProvider, provider)
         ) return;
-        if (
-          !selectedLocalProvider &&
-          isWebpackProvider(provider) &&
-          !provider.lib &&
-          !provider.loaded
-        ) return;
         const loadedShare = await __mfLoadPinnedRuntimeShare(
           pkg,
           usedShare.shareConfig,
@@ -4605,13 +4956,14 @@ function getHostAutoInitState(options) {
 	}
 	return state;
 }
-function generateHostAutoInitCode(remoteEntryImport, _command = "build", options) {
+function generateHostAutoInitCode(remoteEntryImport, _command = "build", options, exportConditions) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const shouldPreloadShares = resolvedOptions.shareStrategy !== "loaded-first";
-	const hostInitShareOrder = JSON.stringify(getOrderedUsedShares(options));
-	const cacheOwner = JSON.stringify(resolvedOptions.name);
+	const hostInitShareBatches = toSafeJsLiteral(getShareBatches(options, false));
+	const cacheOwner = toSafeJsLiteral(resolvedOptions.name);
+	const preferLocalVinextReact = hasPackageDependency("vinext") && (!exportConditions?.includes("browser") || exportConditions.includes("worker"));
 	return `
-    ${getRuntimeModuleCacheBootstrapCode()}
+    ${getRuntimeModuleCacheBootstrapCode(exportConditions)}
     let hostInitPromise;
     async function initHost() {
       if (!hostInitPromise) {
@@ -4623,31 +4975,44 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
           const {usedShared} = await import("${getLocalSharedImportMapPath(options)}");
           ${normalizeRuntimeShareCode}
           ${shouldPreloadShares ? `
-          const __mfHostInitShareOrder = ${hostInitShareOrder};
-          for (const pkg of __mfHostInitShareOrder) {
-            const share = usedShared[pkg];
-            if (!share || share.materialize === false) continue;
-            // remoteEntry.init resolves tree-enabled shares into the
-            // coverage-aware cache. Never republish that selected partial under
-            // a generic full-module key here.
-            if (share.treeShaking) continue;
-            const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
-            if (__mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined) {
-              continue;
-            }
-            await runtime.loadShare(pkg, {
-              customShareInfo: { shareConfig: share.shareConfig }
-            }).then((factory) => {
-              const mod = typeof factory === "function" ? factory() : factory;
-              return Promise.resolve(mod).then((resolved) => {
+          const __mfHostInitShareBatches = ${hostInitShareBatches};
+          for (const __mfHostInitShareBatch of __mfHostInitShareBatches) {
+            await Promise.all(__mfHostInitShareBatch.map(async (pkg) => {
+              const share = usedShared[pkg];
+              if (!share || share.materialize === false) return;
+              // remoteEntry.init resolves tree-enabled shares into the
+              // coverage-aware cache. Never republish that selected partial under
+              // a generic full-module key here.
+              if (share.treeShaking) return;
+              const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
+              if (
+                __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined &&
+                __mfReadSharedCacheOwner(__mfModuleCache.share, cacheDescriptor) ${_command === "serve" ? "!== undefined" : `=== ${cacheOwner}`}
+              ) return;
+              await runtime.loadShare(pkg, {
+                customShareInfo: { shareConfig: share.shareConfig }
+              }).then(async (factory) => {
+                const mod = typeof factory === "function" ? factory() : factory;
+                let resolved = __mfNormalizeRuntimeShare(await Promise.resolve(mod));
+                ${preferLocalVinextReact ? `if (
+                  (pkg === "react" || pkg === "react-dom") &&
+                  typeof share.get === "function" &&
+                  share.shareConfig?.import !== false
+                ) {
+                  try {
+                    const localFactory = await share.get();
+                    const localModule = typeof localFactory === "function" ? localFactory() : localFactory;
+                    resolved = __mfNormalizeRuntimeShare(await Promise.resolve(localModule));
+                  } catch {}
+                }` : ""}
                 __mfWriteSharedCache(
                   __mfModuleCache.share,
                   cacheDescriptor,
-                  __mfNormalizeRuntimeShare(resolved),
+                  resolved,
                   ${cacheOwner}
                 );
               });
-            });
+            }));
           }
           ` : ""}
           return runtime;
@@ -4659,24 +5024,29 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
     export { initHost, hostInitPromise };
     `;
 }
-function writeHostAutoInit(remoteEntryId = REMOTE_ENTRY_ID, command = "build", options) {
+function writeHostAutoInit(remoteEntryId = REMOTE_ENTRY_ID, command = "build", options, exportConditions) {
 	const state = getHostAutoInitState(options);
 	state.remoteEntryId = remoteEntryId;
 	state.command = command;
-	state.module.writeSync(generateHostAutoInitCode(JSON.stringify(remoteEntryId), command, options), true);
+	if (exportConditions !== void 0) state.exportConditions = exportConditions;
+	state.module.writeSync(generateHostAutoInitCode(toSafeJsLiteral(remoteEntryId), command, options, state.exportConditions), true);
 }
-function refreshHostAutoInit(options) {
+function refreshHostAutoInit(options, exportConditions) {
 	try {
 		const state = getHostAutoInitState(options);
-		writeHostAutoInit(state.remoteEntryId, state.command, options);
+		writeHostAutoInit(state.remoteEntryId, state.command, options, exportConditions);
 	} catch {}
 }
 function getHostAutoInitPath(options) {
 	return getHostAutoInitState(options).module.getImportId();
 }
+function isOwnedHostAutoInitId(id, options) {
+	return VirtualModule.findById(id) === getHostAutoInitState(options).module;
+}
 //#endregion
 //#region src/virtualModules/virtualRemotes.ts
 const cacheRemoteMap = /* @__PURE__ */ new WeakMap();
+const remoteModuleMetadata = /* @__PURE__ */ new WeakMap();
 const remoteOptionsIds = /* @__PURE__ */ new WeakMap();
 let nextRemoteOptionsId = 1;
 function getRemoteOptionsId(options) {
@@ -4698,14 +5068,29 @@ function getRemoteVirtualModule(remote, command, enableSsrInit = false, consumer
 	if (!instanceCache.has(cacheKey)) {
 		const virtual = new VirtualModule(`${consumer === "unified" ? remote : `${remote}__mf_consumer__${consumer}`}${MF_OWNER_INFIX}${getRemoteOptionsId(options)}`, LOAD_REMOTE_TAG, ".js", options.internalName);
 		virtual.writeSync(generateRemotes(remote, command, enableSsrInit, consumer, options));
+		remoteModuleMetadata.set(virtual, {
+			remote,
+			command,
+			enableSsrInit,
+			consumer,
+			options
+		});
 		instanceCache.set(cacheKey, virtual);
 	}
 	return instanceCache.get(cacheKey);
 }
+function refreshRemoteModuleForEnvironment(id, options, exportConditions) {
+	const virtual = VirtualModule.findById(id);
+	const metadata = virtual && remoteModuleMetadata.get(virtual);
+	if (!virtual || !metadata || metadata.options !== options) return false;
+	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 EMPTY_STATIC_REMOTES = /* @__PURE__ */ new Set();
 function getScopedUsedRemotesMap(options) {
 	let scoped = usedRemotesByOptions.get(options);
 	if (!scoped) {
@@ -4742,12 +5127,28 @@ function markStaticRemote(remote, options) {
 	}
 	remotes.add(remote);
 }
+function getStaticRemotes(options) {
+	return staticRemotesByOptions.get(options) ?? EMPTY_STATIC_REMOTES;
+}
 function isDynamicOnlyRemote(remote, options) {
 	return (dynamicRemotesByOptions.get(options)?.has(remote) ?? false) && !(staticRemotesByOptions.get(options)?.has(remote) ?? false);
 }
 function getRemoteAliasFromId(id, remotes) {
 	return Object.keys(remotes).filter((name) => id === name || id.startsWith(name + "/")).sort((a, b) => b.length - a.length)[0];
 }
+function getRemoteRegistration(id, remotes, options) {
+	const alias = getRemoteAliasFromId(id, remotes);
+	if (!alias) return void 0;
+	const remote = remotes[alias];
+	return {
+		entryGlobalName: remote.entryGlobalName,
+		name: options ? getRuntimeRemoteAlias(alias, options) : remote.name,
+		alias,
+		type: remote.type,
+		entry: remote.entry,
+		shareScope: remote.shareScope ?? "default"
+	};
+}
 function getRuntimeRemoteId(id, remotes, options) {
 	const alias = getRemoteAliasFromId(id, remotes);
 	if (!alias) return id;
@@ -4917,23 +5318,14 @@ ${deferRemoteLoad ? getLazyRemotePendingExport() : getEagerRemotePendingExport()
 ${command === "serve" && consumer === "server" ? getServerThenExport() : ""}
 export { __mfDefaultExport as default };`;
 }
-function generateRemotes(id, command, enableSsrInit = false, consumer = "unified", options) {
+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 remoteAlias = getRemoteAliasFromId(id, resolvedOptions.remotes);
-	const remote = remoteAlias ? resolvedOptions.remotes[remoteAlias] : void 0;
-	const runtimeRemoteAlias = remoteAlias ? getRuntimeRemoteAlias(remoteAlias, options) : void 0;
 	const runtimeRemoteId = getRuntimeRemoteId(id, resolvedOptions.remotes, options);
-	const registerRemoteCode = isLoadedFirst && remote ? `runtime.registerRemotes([${JSON.stringify({
-		entryGlobalName: remote.entryGlobalName,
-		name: options ? runtimeRemoteAlias : remote.name,
-		alias: remoteAlias,
-		type: remote.type,
-		entry: remote.entry,
-		shareScope: remote.shareScope ?? "default"
-	})}]);` : "";
+	const remoteRegistration = getRemoteRegistration(id, resolvedOptions.remotes, options);
+	const registerRemoteCode = isLoadedFirst && remoteRegistration ? `runtime.registerRemotes([${JSON.stringify(remoteRegistration)}]);` : "";
 	const hostAutoInitPath = getHostAutoInitPath(options);
 	const ssrRemotes = Object.entries(resolvedOptions.remotes).map(([name, item]) => ({
 		name: getRuntimeRemoteAlias(name, options),
@@ -4943,9 +5335,9 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
 	const browserHostInitCode = `import(${JSON.stringify(hostAutoInitPath)})
         .then((mod) => mod.hostInitPromise)
         .then(initResolve, initReject);`;
-	const devRuntimeBootstrap = `${getRuntimeInitBootstrapCode(enableSsrInit, getRuntimeInitStatusImportId(options), ssrRemotes, hostAutoInitPath)}
+	const devRuntimeBootstrap = `${getRuntimeInitBootstrapCode(enableSsrInit, getRuntimeInitStatusImportId(options), ssrRemotes, hostAutoInitPath, exportConditions)}
     const { initPromise, initResolve, initReject, moduleCache: __mfModuleCache } = globalThis[globalKey];`;
-	const importLine = command === "build" ? `${getRuntimeModuleCacheBootstrapCode()}
+	const importLine = command === "build" ? `${getRuntimeModuleCacheBootstrapCode(exportConditions)}
     import { hostInitPromise as __mfHostInitPromise } from ${JSON.stringify(hostAutoInitPath)};` : `${devRuntimeBootstrap}
     ${command === "serve" && consumer !== "server" ? browserHostInitCode : ""}`;
 	const remoteLoadRuntimePromise = command === "build" ? "__mfHostInitPromise" : "initPromise";
@@ -4966,6 +5358,12 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
         __mfModuleCache.remote[pendingKey] = ${remoteLoadRuntimePromise}
           .then((runtime) => {
             ${registerRemoteCode}
+            const moduleCacheKey = Symbol.for(${JSON.stringify(MODULE_CACHE_SHARE_SCOPE_KEY)});
+            const shareScopes = runtime.shareScopeMap || {};
+            for (const scope of Object.values(shareScopes)) {
+              if (scope && typeof scope === "object") scope[moduleCacheKey] = __mfModuleCache;
+            }
+            shareScopes[moduleCacheKey] = __mfModuleCache;
             return runtime.loadRemote(${JSON.stringify(runtimeRemoteId)});
           })
           .then((mod) => Promise.resolve(mod?.__mf_remote_dependency_pending).then(() => mod))
@@ -5006,28 +5404,57 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
 }
 //#endregion
 //#region src/plugins/pluginAddEntry.ts
+const isPreloadableVirtualMfChunk = (name) => name.includes("virtual_mf") && !name.includes("__prebuild__");
 const HOST_INIT_PRELOAD_CHUNKS = [
 	(name) => name === "hostInit",
 	(name) => name === "remoteEntry",
-	(name) => name.startsWith("_virtual_mf") && !name.includes("__prebuild__"),
+	(name) => name === "virtualExposes",
+	isPreloadableVirtualMfChunk,
 	(name) => name === "index"
 ];
+const isRemoteWarmupExcluded = (name) => name.includes("__prebuild__") || name.includes("__loadShare__");
+const REMOTE_ENTRY_WARMUP_CHUNKS = [
+	(name) => name === "hostInit",
+	(name) => name === "virtualExposes",
+	(name) => isPreloadableVirtualMfChunk(name) && !isRemoteWarmupExcluded(name)
+];
+function getChunksByFileName(bundle) {
+	return new Map(Object.values(bundle).filter((chunk) => chunk.type === "chunk").map((chunk) => [chunk.fileName, chunk]));
+}
+function collectPreloadChunkFiles(chunksByFileName, seeds, excludeFromClosure = (name) => name.includes("__prebuild__")) {
+	const seenFiles = /* @__PURE__ */ new Set();
+	const files = [];
+	const queue = [...seeds];
+	while (queue.length > 0) {
+		const chunk = queue.shift();
+		if (seenFiles.has(chunk.fileName)) continue;
+		seenFiles.add(chunk.fileName);
+		for (const imported of chunk.imports ?? []) {
+			const importedChunk = chunksByFileName.get(imported);
+			if (importedChunk && !excludeFromClosure(importedChunk.name)) queue.push(importedChunk);
+		}
+		files.push(chunk.fileName);
+	}
+	return files;
+}
 function escapeHtmlAttr(value) {
 	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
 }
 function getExistingHrefSet(html) {
 	return new Set(Array.from(html.matchAll(/\bhref\s*=\s*["']([^"']+)["']/gi), (match) => match[1]));
 }
-function injectHostInitPreloads(html, bundle, resolvePath) {
+function injectHostInitPreloads(html, bundle, resolvePath, externalHrefs = []) {
 	const existingHrefs = getExistingHrefSet(html);
-	const seenFiles = /* @__PURE__ */ new Set();
 	const hrefs = [];
-	for (const chunk of Object.values(bundle)) {
-		if (chunk.type !== "chunk") continue;
-		if (!HOST_INIT_PRELOAD_CHUNKS.some((match) => match(chunk.name))) continue;
-		if (seenFiles.has(chunk.fileName)) continue;
-		seenFiles.add(chunk.fileName);
-		const href = resolvePath(chunk.fileName);
+	for (const href of externalHrefs) {
+		if (existingHrefs.has(href)) continue;
+		existingHrefs.add(href);
+		hrefs.push(href);
+	}
+	const chunksByFileName = getChunksByFileName(bundle);
+	const seeds = Array.from(chunksByFileName.values()).filter((chunk) => HOST_INIT_PRELOAD_CHUNKS.some((match) => match(chunk.name)));
+	for (const fileName of collectPreloadChunkFiles(chunksByFileName, seeds)) {
+		const href = resolvePath(fileName);
 		if (existingHrefs.has(href)) continue;
 		existingHrefs.add(href);
 		hrefs.push(href);
@@ -5036,6 +5463,40 @@ function injectHostInitPreloads(html, bundle, resolvePath) {
 	const tags = hrefs.map((href) => `<link rel="modulepreload" crossorigin href="${escapeHtmlAttr(href)}">`).join("");
 	return html.includes("</head>") ? html.replace("</head>", `${tags}</head>`) : `${tags}${html}`;
 }
+function appendRemoteEntryWarmup(bundle, entryFileName) {
+	const chunksByFileName = getChunksByFileName(bundle);
+	const entryChunk = chunksByFileName.get(entryFileName);
+	if (!entryChunk || entryChunk.code.includes("__mfWarmupPath")) return;
+	const reachable = /* @__PURE__ */ new Set();
+	const walk = [entryChunk];
+	while (walk.length > 0) {
+		const chunk = walk.pop();
+		if (reachable.has(chunk.fileName)) continue;
+		reachable.add(chunk.fileName);
+		for (const imported of [...chunk.imports ?? [], ...chunk.dynamicImports ?? []]) {
+			const importedChunk = chunksByFileName.get(imported);
+			if (importedChunk) walk.push(importedChunk);
+		}
+	}
+	const seeds = Array.from(reachable).map((file) => chunksByFileName.get(file)).filter((chunk) => chunk.fileName !== entryFileName && REMOTE_ENTRY_WARMUP_CHUNKS.some((match) => match(chunk.name)));
+	const lastSlash = entryFileName.lastIndexOf("/");
+	const entryDir = lastSlash !== -1 ? entryFileName.slice(0, lastSlash + 1) : "";
+	const files = collectPreloadChunkFiles(chunksByFileName, seeds, isRemoteWarmupExcluded).filter((file) => file !== entryFileName).map((file) => rebaseImport(file, entryDir));
+	if (files.length === 0) return;
+	entryChunk.code += `
+if (typeof document !== 'undefined' && document.head) {
+  try {
+    for (const __mfWarmupPath of ${JSON.stringify(files)}) {
+      const __mfWarmupLink = document.createElement('link');
+      __mfWarmupLink.rel = 'modulepreload';
+      __mfWarmupLink.crossOrigin = '';
+      __mfWarmupLink.href = new URL(__mfWarmupPath, import.meta.url).href;
+      document.head.appendChild(__mfWarmupLink);
+    }
+  } catch (__mfWarmupError) {}
+}
+`;
+}
 function getFirstHtmlEntryFile(entryFiles) {
 	return entryFiles.find((file) => file.endsWith(".html"));
 }
@@ -5156,6 +5617,16 @@ 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";
+		if (normalizedOptions.shareStrategy === "loaded-first" && !isLoadedFirstClientBuild) return [];
+		const remoteSources = isLoadedFirstClientBuild ? Array.from(getStaticRemotes(normalizedOptions)) : Object.entries(getUsedRemotesMap(federationOptions)).flatMap(([, remotes]) => Array.from(remotes)).filter((remote) => !federationOptions || !isDynamicOnlyRemote(remote, federationOptions));
+		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) ? [registration.entry] : [];
+		})));
+	}
 	function getBootstrapSource(initSrc, entrySrc, useSystemImportFallback = false, options) {
 		const importHelper = useSystemImportFallback ? `const __mfImport = (src) =>
   globalThis.System && typeof globalThis.System.import === 'function'
@@ -5167,11 +5638,35 @@ const __mfCurrentScript = document.currentScript;
 		const entryImportDeclaration = isEncodedVirtualEntry ? `const __mfEntryUrl = ${JSON.stringify(entrySrc)};
 ` : "";
 		const entryImportExpression = isEncodedVirtualEntry ? "import(/* @vite-ignore */ __mfEntryUrl)" : importExpression(entrySrc);
-		const remotePreloads = !options?.skipRemotePreload && (federationOptions ?? getNormalizeModuleFederationOptions())?.shareStrategy !== "loaded-first" ? Object.entries(getUsedRemotesMap(federationOptions)).flatMap(([, remotes]) => Array.from(remotes)).filter((remote) => !federationOptions || !isDynamicOnlyRemote(remote, federationOptions)).sort().map((remote) => `__mfPreloadRemote(${JSON.stringify(getRuntimeRemoteId(remote, (federationOptions ?? getNormalizeModuleFederationOptions()).remotes, federationOptions))}, ${JSON.stringify(remote)})`).join(",") : "";
+		const normalizedOptions = federationOptions ?? getNormalizeModuleFederationOptions();
+		const isLoadedFirstClientBuild = (_command === "build" || viteConfig?.command === "build") && waitsForInit && !viteConfig?.build?.ssr && normalizedOptions.shareStrategy === "loaded-first";
+		const shouldPreloadRemotes = !options?.skipRemotePreload && (normalizedOptions.shareStrategy !== "loaded-first" || isLoadedFirstClientBuild);
+		const remoteSources = isLoadedFirstClientBuild ? Array.from(getStaticRemotes(normalizedOptions)) : Object.entries(getUsedRemotesMap(federationOptions)).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)}` : ""})`;
+		}).join(",") : "";
+		const remoteEntryPrefetchUrls = shouldPreloadRemotes ? getRemoteEntryPreloadUrls() : [];
+		const remoteEntryPrefetchBlock = remoteEntryPrefetchUrls.length > 0 ? `const __mfRemoteEntryPrefetchUrls = ${JSON.stringify(remoteEntryPrefetchUrls)};
+for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
+  import(/* @vite-ignore */ __mfRemoteEntryPrefetchUrl).catch(() => {});
+}
+` : "";
+		const sharedPreloadSources = _command === "serve" && waitsForInit && Object.keys(normalizedOptions.exposes || {}).length > 0 && Object.keys(normalizedOptions.remotes || {}).length === 0 && federationOptions ? Array.from(getUsedShares(federationOptions)).filter((pkg) => !pkg.endsWith("/")).filter((pkg) => {
+			const shareItem = federationOptions.shared[pkg] || Object.entries(federationOptions.shared).find(([key]) => key.endsWith("/") && pkg.startsWith(key))?.[1];
+			const isExplicitShare = Object.prototype.hasOwnProperty.call(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) => toViteEncodedId(getLoadShareModulePath(pkg, false, federationOptions))) : [];
+		const sharedPreloadBlock = sharedPreloadSources.length > 0 ? `
+  const __mfSharedPreloadUrls = ${JSON.stringify(sharedPreloadSources)};
+  await Promise.all(__mfSharedPreloadUrls.map((src) => import(/* @vite-ignore */ src).catch((err) => console.warn("[module-federation] shared preload failed:", src, err))));` : "";
 		const remoteCachePrefix = getRuntimeRemoteCachePrefix(federationOptions);
 		const preloadBlock = remotePreloads ? `
   const runtime = await initHost();
-  const __mfPreloadRemote = (runtimeRemote, remote) => {
+  const __mfPreloadRemote = (runtimeRemote, remote${isLoadedFirstClientBuild ? ", registration" : ""}) => {
+    ${isLoadedFirstClientBuild ? `if (registration && typeof runtime.registerRemotes === "function") {
+      runtime.registerRemotes([registration]);
+    }` : ""}
     const remoteCacheKey = ${JSON.stringify(remoteCachePrefix)} + remote;
     const pendingKey = "__mf_pending__" + remoteCacheKey;
     if (!__mfModuleCache.remote[pendingKey]) {
@@ -5189,22 +5684,28 @@ const __mfCurrentScript = document.currentScript;
     return __mfModuleCache.remote[pendingKey];
   };
   const __mfRemotePreloads = [${remotePreloads}];
-  await Promise.allSettled(__mfRemotePreloads);` : `await initHost();`;
+  await ${isLoadedFirstClientBuild ? "Promise.all" : "Promise.allSettled"}(__mfRemotePreloads);` : `await initHost();`;
+		const pendingShareLoadsAwait = `
+  if (__mfModuleCache.pendingShareLoads) {
+    await Promise.all(__mfModuleCache.pendingShareLoads);
+  }
+  const __mfReactServerModuleCache = globalThis[${JSON.stringify(getModuleCacheGlobalKey(["react-server"]))}];
+  if (__mfReactServerModuleCache?.pendingShareLoads) {
+    await Promise.all(__mfReactServerModuleCache.pendingShareLoads);
+  }`;
 		const importCode = `
 (async () => {
   const __mfHostInit = await ${importExpression(initSrc)};
   await __mfHostInit.__tla;
   const { initHost } = __mfHostInit;
-  ${preloadBlock}
-  if (__mfModuleCache.pendingShareLoads) {
-    await Promise.all(__mfModuleCache.pendingShareLoads);
-  }
+  ${preloadBlock}${sharedPreloadBlock}${pendingShareLoadsAwait}
 })().then(() => ${entryImportExpression});
 `;
 		return [
 			getRuntimeModuleCacheBootstrapCode(),
 			importHelper,
 			entryImportDeclaration,
+			remoteEntryPrefetchBlock,
 			importCode
 		].join("\n");
 	}
@@ -5236,6 +5737,17 @@ const __mfCurrentScript = document.currentScript;
 		const normalized = decodeViteId(id).replace(/^\0+/, "");
 		return normalized.includes("virtual:mf:") || /__(?:loadShare|prebuild|loadRemote)__/.test(normalized);
 	}
+	function isWorkspaceSourceId(id) {
+		const normalized = normalizeModuleId(decodeViteId(id));
+		if (normalized.startsWith("\0") || normalized.startsWith("virtual:")) return false;
+		const filePath = stripQueryAndHash$1(normalized);
+		if (filePath.startsWith("/@fs/")) return true;
+		if (!path$1.isAbsolute(filePath)) return false;
+		const root = normalizePathForImport(path$1.resolve(viteConfig.root));
+		const absolutePath = normalizePathForImport(path$1.resolve(filePath));
+		const relativePath = normalizePathForImport(path$1.relative(root, absolutePath));
+		return (relativePath === ".." || relativePath.startsWith("../") || path$1.isAbsolute(relativePath)) && fs$2.existsSync(absolutePath);
+	}
 	function addEntryFile(file) {
 		const normalized = normalizeModuleId(file);
 		if (!entryFiles.includes(normalized)) entryFiles.push(normalized);
@@ -5302,7 +5814,10 @@ const __mfCurrentScript = document.currentScript;
 				}
 				const devFileName = resolveDevHashEntryFileName$1(fileName);
 				if (devFileName !== fileName && req.url?.startsWith((viteConfig.base + devFileName).replace(/^\/?/, "/"))) req.url = req.url.replace(devFileName, fileName);
-				if (req.url && req.url.startsWith((viteConfig.base + fileName).replace(/^\/?/, "/"))) req.url = devEntryPath;
+				if (req.url && req.url.startsWith((viteConfig.base + fileName).replace(/^\/?/, "/"))) {
+					req.url = devEntryPath;
+					req.headers["sec-fetch-dest"] = "script";
+				}
 				next();
 			});
 		},
@@ -5383,6 +5898,10 @@ const __mfCurrentScript = document.currentScript;
 		},
 		generateBundle(_options, bundle) {
 			if (skipSvelteKitSsrBuild()) return;
+			if (entryName === "remoteEntry" && emitFileId && fileName && !viteConfig?.build?.ssr && _options?.format === "es" && viteConfig?.build?.modulePreload !== false) {
+				const remoteEntryFile = findRemoteEntryFile(fileName, bundle);
+				if (remoteEntryFile) appendRemoteEntryWarmup(bundle, remoteEntryFile);
+			}
 			if (!injectHtml()) return;
 			if (!emitFileId) return;
 			const htmlFileNames = Object.keys(bundle).filter((fileName) => fileName.endsWith(".html"));
@@ -5444,12 +5963,12 @@ const __mfCurrentScript = document.currentScript;
 						htmlContent = htmlContent.replace("<head>", `<head>${scriptContent}`);
 					}
 				}
-				if (waitsForInit && viteConfig.build.modulePreload !== false) htmlContent = injectHostInitPreloads(htmlContent, bundle, (builtFileName) => resolvePath(builtFileName, fileName));
+				if (waitsForInit && viteConfig.build.modulePreload !== false) htmlContent = injectHostInitPreloads(htmlContent, bundle, (builtFileName) => resolvePath(builtFileName, fileName), getRemoteEntryPreloadUrls());
 				htmlAsset.source = htmlContent;
 			}
 		},
 		closeBundle() {
-			if (_command === "serve" || skipSvelteKitSsrBuild()) return;
+			if (_command === "serve" || !hasPackageDependency("@sveltejs/kit") || skipSvelteKitSsrBuild()) return;
 			let attempts = 0;
 			const retry = () => {
 				attempts += 1;
@@ -5489,7 +6008,7 @@ const __mfCurrentScript = document.currentScript;
 				return mapCodeToCodeWithSourcemap(code.replace("vueApp.mount(vueAppRootContainer);", `${injection}vueApp.mount(vueAppRootContainer);`));
 			}
 			const isReactRouterEntry = isReactRouterClientEntry(id);
-			const isHydrationEntryFallback = inject === "entry" && entryFiles.length === 0 && (!htmlFilePath || !fs$2.existsSync(htmlFilePath)) && !clientInjected && !isFederationInternalVirtualId(id) && !id.includes("node_modules") && (!code.includes("HydratedRouter") || isReactRouterEntry) && (id.startsWith("\0") || /\.(js|ts|mjs|vue|jsx|tsx)(\?|$)/.test(id)) && (/hydrateRoot|createRoot|ReactDOM\.render/.test(code) || /\.mount\s*\(\s*['"#]/.test(code) || /\.mount\s*\(/.test(code) && /createSSRApp|createApp/.test(code));
+			const isHydrationEntryFallback = inject === "entry" && entryFiles.length === 0 && (!htmlFilePath || !fs$2.existsSync(htmlFilePath)) && !clientInjected && !isFederationInternalVirtualId(id) && !id.includes("node_modules") && (!code.includes("HydratedRouter") || isReactRouterEntry) && (id.startsWith("\0") || /\.(js|ts|mjs|vue|jsx|tsx)(\?|$)/.test(id)) && (/hydrateRoot|createRoot|ReactDOM\.render/.test(code) || /\.mount\s*\(\s*['"#]/.test(code) || /\.mount\s*\(/.test(code) && /createSSRApp|createApp/.test(code)) && !isWorkspaceSourceId(id);
 			const isNuxtEntryAsyncModule = /(?:^|\/)nuxt\/dist\/app\/entry\.async\.js(?:\?|$)/.test(id) && code.includes("entry();");
 			const isNuxtClientEntryFallback = _command === "serve" && inject === "entry" && (!htmlFilePath || !fs$2.existsSync(htmlFilePath)) && !clientInjected && !hasEntryBootstrapParam(id) && !id.includes("node_modules/.vite") && isNuxtEntryAsyncModule && !entryFiles.some((file) => projectId === file);
 			if (!(_command === "serve" && isNuxtEntryAsyncModule) && (injectedTransformIds.has(projectId) || injectEntry() && entryFiles.some((file) => projectId === file) || _command === "serve" && inject === "html" && !isVinext && !clientInjected && !skipHtmlDevFallback && !id.startsWith("\0") && !id.includes("node_modules") && /\.(js|ts|mjs|vue|jsx|tsx)(\?|$)/.test(id) || isHydrationEntryFallback || inject === "entry" && waitsForInit && isReactRouterEntry || isNuxtClientEntryFallback)) {
@@ -6243,200 +6762,6 @@ function initVirtualModules(command, remoteEntryId, enableSsrInit = false, optio
 	})) : void 0);
 }
 //#endregion
-//#region src/utils/bundleHelpers.ts
-function isOutputChunk$1(chunk) {
-	return chunk.type === "chunk";
-}
-function escapeRegExp$1(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function getProxyBaseName(fileName) {
-	return fileName.replace(/^.*\//, "").replace(/\.js$/, "").replace(/-[A-Za-z0-9_-]+$/, "");
-}
-function extractFunctionDeclaration(code, functionName) {
-	const funcRe = new RegExp(`function\\s+${functionName}\\s*\\([^)]*\\)\\s*\\{`);
-	const funcStart = code.search(funcRe);
-	if (funcStart < 0) return;
-	let depth = 0;
-	for (let i = code.indexOf("{", funcStart); i < code.length; i++) if (code[i] === "{") depth++;
-	else if (code[i] === "}") {
-		depth--;
-		if (depth === 0) return code.slice(funcStart, i + 1);
-	}
-}
-/**
-* Resolve the local alias for a non-inlineable proxy binding.
-* If Rollup's deconflict renamed the alias but didn't update references
-* in the code body, fall back to proxyLocal so they stay in sync.
-*/
-function resolveProxyAlias(binding, proxyLocal, code, fullImport, claimedLocals = /* @__PURE__ */ new Set()) {
-	const codeWithoutImport = code.replace(fullImport, "");
-	const escapedLocal = binding.local.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-	const localUsedInCode = new RegExp(`\\b${escapedLocal}\\b`).test(codeWithoutImport);
-	const claimedImportLocals = /* @__PURE__ */ new Set();
-	const importRe = /import\s*\{([^}]+)\}\s*from\s*["'][^"']+["']\s*;?/g;
-	let match;
-	while ((match = importRe.exec(codeWithoutImport)) !== null) for (const spec of match[1].split(",")) {
-		const parts = spec.trim().split(/\s+as\s+/);
-		claimedImportLocals.add((parts[1] || parts[0]).trim());
-	}
-	const local = !localUsedInCode && !claimedLocals.has(proxyLocal) && !claimedImportLocals.has(proxyLocal) ? proxyLocal : binding.local;
-	return {
-		imported: binding.imported,
-		local
-	};
-}
-function collectLoadShareProxyChunks(bundle, loadShareTag) {
-	const proxyChunks = /* @__PURE__ */ new Map();
-	for (const [fileName, chunk] of Object.entries(bundle)) {
-		if (!isOutputChunk$1(chunk)) continue;
-		if (fileName.includes(loadShareTag) && fileName.includes("commonjs-proxy")) proxyChunks.set(fileName, {
-			code: chunk.code,
-			fileName
-		});
-	}
-	return proxyChunks;
-}
-function collectSystemProxyInfos(proxyChunks, loadShareTag) {
-	const systemProxyInfo = /* @__PURE__ */ new Map();
-	for (const [proxyFileName, proxyInfo] of Array.from(proxyChunks.entries())) {
-		const depsMatch = proxyInfo.code.match(/System\.register\(\[([\s\S]*?)\]/);
-		if (!depsMatch) continue;
-		const loadShareDep = Array.from(depsMatch[1].matchAll(/["']([^"']+)["']/g)).map((m) => m[1]).find((dep) => dep.includes(loadShareTag) && !dep.includes("commonjs-proxy"));
-		if (!loadShareDep) continue;
-		const loadShareBindings = {};
-		for (const m of proxyInfo.code.matchAll(/([A-Za-z_$][\w$]*)\s*=\s*module\d+\.([A-Za-z_$][\w$]*)/g)) loadShareBindings[m[1]] = m[2];
-		const exportMap = {};
-		const objectExportMatch = proxyInfo.code.match(/exports\(\s*\{([\s\S]*?)\}\s*\)/);
-		if (objectExportMatch) for (const m of objectExportMatch[1].matchAll(/([A-Za-z_$][\w$]*)\s*:\s*([A-Za-z_$][\w$]*)/g)) {
-			const [, exported, local] = m;
-			const funcBody = extractFunctionDeclaration(proxyInfo.code, local);
-			if (funcBody) exportMap[exported] = {
-				type: "helper",
-				code: funcBody
-			};
-		}
-		for (const m of proxyInfo.code.matchAll(/exports\(\s*["']([^"']+)["']\s*,([\s\S]*?)\);/g)) {
-			const exported = m[1];
-			const expression = m[2];
-			for (const [local, exportName] of Object.entries(loadShareBindings).reverse()) if (new RegExp(`\\b${local}\\b`).test(expression)) {
-				exportMap[exported] = {
-					type: "reexport",
-					exportName
-				};
-				break;
-			}
-		}
-		if (Object.keys(exportMap).length > 0) systemProxyInfo.set(proxyFileName, {
-			loadShareDep,
-			exportMap
-		});
-	}
-	return systemProxyInfo;
-}
-function rewriteEsmProxyConsumers(code, proxyChunks) {
-	let nextCode = code;
-	const claimedLocals = /* @__PURE__ */ new Set();
-	for (const [proxyFileName, proxyInfo] of Array.from(proxyChunks.entries())) {
-		const proxyBaseName = getProxyBaseName(proxyFileName);
-		const importMatch = new RegExp(`import\\s*\\{([^}]+)\\}\\s*from\\s*["']([^"']*${escapeRegExp$1(proxyBaseName)}[^"']*)["']\\s*;?`).exec(nextCode);
-		if (!importMatch) continue;
-		const fullImport = importMatch[0];
-		const bindings = importMatch[1].split(",").map((s) => {
-			const parts = s.trim().split(/\s+as\s+/);
-			return {
-				imported: parts[0].trim(),
-				local: (parts[1] || parts[0]).trim()
-			};
-		});
-		const exportMapMatch = proxyInfo.code.match(/export\s*\{([^}]+)\}/);
-		if (!exportMapMatch) continue;
-		const exportMap = {};
-		for (const entry of exportMapMatch[1].split(",")) {
-			const parts = entry.trim().split(/\s+as\s+/);
-			if (parts.length === 2) exportMap[parts[1].trim()] = parts[0].trim();
-		}
-		const inlineable = [];
-		const nonInlineable = [];
-		const pendingLocals = new Set(bindings.map((binding) => binding.local));
-		for (const b of bindings) {
-			pendingLocals.delete(b.local);
-			const proxyLocal = exportMap[b.imported];
-			if (!proxyLocal) {
-				claimedLocals.add(b.local);
-				nonInlineable.push(b);
-				continue;
-			}
-			const funcBody = extractFunctionDeclaration(proxyInfo.code, proxyLocal);
-			if (funcBody) {
-				inlineable.push({
-					local: b.local,
-					funcBody: funcBody.replace(new RegExp(`function\\s+${proxyLocal}\\s*\\(`), `function ${b.local}(`)
-				});
-				claimedLocals.add(b.local);
-			} else {
-				const unavailableLocals = new Set(claimedLocals);
-				pendingLocals.forEach((local) => unavailableLocals.add(local));
-				const resolvedBinding = resolveProxyAlias(b, proxyLocal, nextCode, fullImport, unavailableLocals);
-				claimedLocals.add(resolvedBinding.local);
-				nonInlineable.push(resolvedBinding);
-			}
-		}
-		const hasRenamedAlias = nonInlineable.some((b) => bindings.find((ob) => ob.imported === b.imported)?.local !== b.local);
-		if (inlineable.length === 0 && !hasRenamedAlias) continue;
-		let replacement = "";
-		if (nonInlineable.length > 0) replacement = `import{${nonInlineable.map((b) => b.imported === b.local ? b.imported : `${b.imported} as ${b.local}`).join(",")}}from"${importMatch[2]}";`;
-		replacement += inlineable.map((f) => f.funcBody).join("");
-		nextCode = nextCode.replace(fullImport, () => replacement);
-	}
-	return nextCode;
-}
-function rewriteSystemProxyConsumers(code, systemProxyInfo) {
-	if (!code.includes("System.register(")) return code;
-	let nextCode = code;
-	for (const [proxyFileName, proxyInfo] of Array.from(systemProxyInfo.entries())) {
-		const proxyBaseName = getProxyBaseName(proxyFileName);
-		const depMatch = new RegExp(`["']([^"']*${escapeRegExp$1(proxyBaseName)}[^"']*)["']`).exec(nextCode);
-		if (!depMatch) continue;
-		let setterIndex = 0;
-		const depListMatch = nextCode.match(/System\.register\(\[([\s\S]*?)\]/);
-		if (depListMatch) setterIndex = Array.from(depListMatch[1].matchAll(/["']([^"']+)["']/g)).map((m) => m[1]).findIndex((dep) => dep.includes(proxyBaseName));
-		if (setterIndex < 0) continue;
-		const settersStart = nextCode.indexOf("setters: [");
-		if (settersStart < 0) continue;
-		const setterMatch = Array.from(nextCode.slice(settersStart).matchAll(/\((module\d+)\)\s*=>\s*\{([\s\S]*?)\}/g))[setterIndex];
-		if (!setterMatch) continue;
-		const [fullSetter, moduleLocal, setterBody] = setterMatch;
-		const helpersToInline = [];
-		const nextSetterBody = setterBody.replace(new RegExp(`([A-Za-z_$][\\w$]*)\\s*=\\s*${moduleLocal}\\.([A-Za-z_$][\\w$]*);?`, "g"), (assignment, local, imported) => {
-			const mapped = proxyInfo.exportMap[imported];
-			if (!mapped) return assignment;
-			if (mapped.type === "helper") {
-				helpersToInline.push(mapped.code.replace(new RegExp(`function\\s+${imported}\\s*\\(`), `function ${local}(`));
-				return "";
-			}
-			return `${local} = ${moduleLocal}.${mapped.exportName};`;
-		});
-		if (nextSetterBody === setterBody && helpersToInline.length === 0) continue;
-		const nextSetter = fullSetter.replace(setterBody, () => nextSetterBody);
-		nextCode = nextCode.replace(fullSetter, () => nextSetter);
-		nextCode = nextCode.replace(depMatch[0], JSON.stringify(proxyInfo.loadShareDep));
-		if (helpersToInline.length > 0) nextCode = nextCode.replace("execute: (function() {", () => {
-			return `execute: (function() {${helpersToInline.join("")}`;
-		});
-	}
-	return nextCode;
-}
-function findRemoteEntryFile(filename, bundle) {
-	const strippedName = filename.replace(/[\[\]]/g, "_").replace(/\.[^/.]+$/, "");
-	let fallback;
-	for (const fileData of Object.values(bundle)) {
-		if (fileData.fileName === filename) return fileData.fileName;
-		if (fallback === void 0 && (strippedName === fileData.name || fileData.name === "remoteEntry")) fallback = fileData.fileName;
-	}
-	return fallback;
-}
-//#endregion
 //#region src/utils/cssModuleHelpers.ts
 const ASSET_TYPES = ["js", "css"];
 const LOAD_TIMINGS = ["sync", "async"];
@@ -6500,28 +6825,33 @@ const chunkContainsCssModules = (modules) => {
 	for (const modulePath of Object.keys(modules)) if (isCSSFile(modulePath)) return true;
 	return false;
 };
+const collectStaticChunks = (bundle, roots) => {
+	const chunks = [];
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [...roots];
+	for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
+		const fileName = queue[queueIndex];
+		if (visited.has(fileName)) continue;
+		visited.add(fileName);
+		const chunk = bundle[fileName];
+		if (!chunk || chunk.type !== "chunk") continue;
+		chunks.push(chunk);
+		queue.push(...chunk.imports ?? []);
+	}
+	return chunks;
+};
 /**
 * Analyzes assets associated with a chunk without mutating the output map.
 * The static-import traversal is cycle-safe and ignores missing bundle entries.
 */
 const analyzeChunkAssets = (bundle, fileName, chunk) => {
 	const dynamicAssets = [];
-	const visited = /* @__PURE__ */ new Set();
-	const queue = [fileName];
-	for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
-		const currentFileName = queue[queueIndex];
-		if (visited.has(currentFileName)) continue;
-		visited.add(currentFileName);
-		const currentChunk = bundle[currentFileName];
-		if (!currentChunk || currentChunk.type !== "chunk") continue;
-		for (const dynamicImport of currentChunk.dynamicImports ?? []) {
-			if (!bundle[dynamicImport]) continue;
-			dynamicAssets.push({
-				fileName: dynamicImport,
-				type: isCSSFile(dynamicImport) ? "css" : "js"
-			});
-		}
-		for (const staticImport of currentChunk.imports ?? []) queue.push(staticImport);
+	for (const currentChunk of collectStaticChunks(bundle, [fileName])) for (const dynamicImport of currentChunk.dynamicImports ?? []) {
+		if (!bundle[dynamicImport]) continue;
+		dynamicAssets.push({
+			fileName: dynamicImport,
+			type: isCSSFile(dynamicImport) ? "css" : "js"
+		});
 	}
 	return {
 		importedCss: Array.from(chunk.viteMetadata?.importedCss ?? []),
@@ -6673,6 +7003,7 @@ function generateRemoteEntrySSR(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)});
   let exposesMapPromise;
 
   function createShareInitError(errors) {
@@ -6750,7 +7081,8 @@ function generateRemoteEntrySSR(options) {
       throw createShareInitError(shareInitErrors);
     }
     if (cacheEntries.length > 0) {
-      const moduleCache = (globalThis.__mf_module_cache__ ||= { share: {}, remote: {} });
+      const moduleCache = shared?.[moduleCacheKey] ||
+        (globalThis.__mf_module_cache__ ||= { share: {}, remote: {} });
       const cache = (moduleCache.share ||= {});
       for (const { scopeName, pkg, module } of cacheEntries) {
         cache[scopeName + ':' + pkg] ??= module;
@@ -6836,6 +7168,54 @@ function isTreeShakingProviderChunk(file) {
 	if (file.facadeModuleId?.includes("__treeShakingProvider__")) return true;
 	return Object.keys(file.modules || {}).some((id) => id.includes("__treeShakingProvider__") || id.includes("__mf_tree_shaking_graph__"));
 }
+function isContainerBootstrapChunk(chunk, moduleIds) {
+	return [chunk.facadeModuleId, ...chunk.moduleIds ?? []].some((id) => typeof id === "string" && moduleIds.has(normalizeVirtualModuleId(id)));
+}
+function collectImportedCss(chunks) {
+	const css = /* @__PURE__ */ new Set();
+	for (const chunk of chunks) for (const cssFile of chunk.viteMetadata?.importedCss ?? []) css.add(cssFile);
+	return Array.from(css);
+}
+function expandExposeAssets(filesMap, exposeModules, bundle, remoteEntryFileName, options) {
+	if (exposeModules.length === 0) return;
+	const containerChunks = remoteEntryFileName ? collectStaticChunks(bundle, [remoteEntryFileName]) : [];
+	const bootstrapChunks = containerChunks.slice(1);
+	const seen = new Set(containerChunks.map((chunk) => chunk.fileName));
+	if (containerChunks.length > 0) {
+		const bootstrapModuleIds = /* @__PURE__ */ new Set([getLocalSharedImportMapPath(options), getVirtualExposesId(options)]);
+		for (const containerChunk of containerChunks) for (const imported of containerChunk.dynamicImports ?? []) {
+			const importedChunk = bundle[imported];
+			if (!importedChunk || importedChunk.type !== "chunk" || !isContainerBootstrapChunk(importedChunk, bootstrapModuleIds)) continue;
+			for (const chunk of collectStaticChunks(bundle, [imported])) {
+				if (seen.has(chunk.fileName)) continue;
+				seen.add(chunk.fileName);
+				bootstrapChunks.push(chunk);
+			}
+		}
+	}
+	const bootstrapAssets = bootstrapChunks.map((chunk) => chunk.fileName);
+	const bootstrapCss = collectImportedCss(bootstrapChunks);
+	for (const exposeModule of exposeModules) {
+		const assets = filesMap[exposeModule];
+		if (!assets) continue;
+		const syncChunks = collectStaticChunks(bundle, assets.js.sync);
+		const sync = Array.from(/* @__PURE__ */ new Set([...bootstrapAssets, ...syncChunks.map((chunk) => chunk.fileName)]));
+		const syncSet = new Set(sync);
+		const asyncChunks = collectStaticChunks(bundle, assets.js.async);
+		const async = asyncChunks.map((chunk) => chunk.fileName).filter((fileName) => !syncSet.has(fileName));
+		assets.js.sync = sync;
+		assets.js.async = async;
+		const syncCss = Array.from(/* @__PURE__ */ new Set([
+			...assets.css.sync,
+			...bootstrapCss,
+			...collectImportedCss(syncChunks)
+		]));
+		const syncCssSet = new Set(syncCss);
+		const asyncCss = Array.from(/* @__PURE__ */ new Set([...assets.css.async, ...collectImportedCss(asyncChunks)])).filter((fileName) => !syncCssSet.has(fileName));
+		assets.css.sync = syncCss;
+		assets.css.async = asyncCss;
+	}
+}
 function getTreeShakingBuildInfo(options) {
 	if (!(Object.values(options.shared || {}).some((share) => !!share.shareConfig.treeShaking) || !!options.treeShakingSharedPlugins?.length || !!options.treeShakingSharedExcludePlugins?.length)) return {};
 	return {
@@ -6998,6 +7378,7 @@ const Manifest = (providedOptions) => {
 					root,
 					stripKnownJsExtensions: true
 				});
+				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));
 				if (mfOptions.bundleAllCSS) addCssAssetsToAllExports(filesMap, allCssAssets);
@@ -7356,6 +7737,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		const cleanId = id.split("?")[0];
 		return cleanId.includes(getHostAutoInitPath(options)) || cleanId.includes(getHostAutoInitPath());
 	};
+	const getEnvironmentConditions = (context) => context.environment?.config?.resolve?.conditions;
 	function isRemoteImport(source) {
 		return Object.keys(options.remotes).some((name) => source === name || source.startsWith(name + "/"));
 	}
@@ -7455,7 +7837,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 			}
 		},
 		async load(id) {
-			if (id === remoteEntryId) return getParsePromise().then((_) => generateRemoteEntry(options, virtualExposesId, _command));
+			if (id === remoteEntryId) return getParsePromise().then((_) => generateRemoteEntry(options, virtualExposesId, _command, getEnvironmentConditions(this)));
 			if (id === virtualExposesId) {
 				await refreshExposeRemoteDependencies(this);
 				return generateExposes(options, exposeRemoteDependencies, _command, reactIslandExposes);
@@ -7465,7 +7847,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		async transform(code, id) {
 			return mapCodeToCodeWithSourcemap(await (async () => {
 				if (!filterId(id)) return;
-				if (id.includes(remoteEntryId)) return getParsePromise().then((_) => generateRemoteEntry(options, virtualExposesId, _command));
+				if (id.includes(remoteEntryId)) return getParsePromise().then((_) => generateRemoteEntry(options, virtualExposesId, _command, getEnvironmentConditions(this)));
 				if (id === virtualExposesId) {
 					await refreshExposeRemoteDependencies(this);
 					return generateExposes(options, exposeRemoteDependencies, _command, reactIslandExposes);
@@ -7483,7 +7865,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 						return `
           const origin = typeof window !== 'undefined' && (${!options.ignoreOrigin}) ? window.origin : ${JSON.stringify(fallbackOrigin)};
           const remoteEntryImport = typeof window !== 'undefined' ? ${isAbsolutePublicPath ? remoteEntryUrl : `origin + ${remoteEntryUrl}`} : ${JSON.stringify(ssrRemoteEntry)};
-          ${generateHostAutoInitCode("remoteEntryImport", "serve", options)}
+          ${generateHostAutoInitCode("remoteEntryImport", "serve", options, getEnvironmentConditions(this))}
         `;
 					}
 					return code;
@@ -7767,6 +8149,7 @@ function excludeSharedSubDependencies(shared) {
 				delete shared[depKey];
 				sharedKeys.delete(depKey);
 				sharedKeyByBase.delete(dep);
+				sharedKeyMatcherCache.delete(shared);
 			}
 		}
 	}
@@ -7782,6 +8165,8 @@ function proxySharedModule(options) {
 	const materializedLoadShareSources = /* @__PURE__ */ new Set();
 	const emittedTreeShakingProviders = /* @__PURE__ */ new Set();
 	const hasAnalyzableShares = Object.values(shared).some((share) => shouldAnalyzeSharedExports(share));
+	const getEnvironmentConditions = (context) => context.environment?.config?.resolve?.conditions;
+	const refreshTreeShakingForEnvironment = (context) => refreshTreeShakingModules(federationOptions, _command, getIsRolldown(context), 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.`);
@@ -7827,7 +8212,7 @@ function proxySharedModule(options) {
 			},
 			load(id) {
 				if (id === getResolvedLocalSharedImportMapId(federationOptions)) return getParsePromise().then((_) => {
-					refreshTreeShakingModules(federationOptions);
+					refreshTreeShakingForEnvironment(this);
 					const providerPackages = /* @__PURE__ */ new Set([...Object.keys(shared).filter((pkg) => !pkg.endsWith("/")), ...getUsedShares(federationOptions)]);
 					for (const pkg of providerPackages) {
 						const sharedKey = findSharedKeyForSource(pkg, shared);
@@ -7879,7 +8264,7 @@ function proxySharedModule(options) {
 				if (_command !== "build") return;
 				resetTreeShakingExports(federationOptions);
 				emittedTreeShakingProviders.clear();
-				refreshTreeShakingModules(federationOptions);
+				refreshTreeShakingForEnvironment(this);
 			},
 			shouldTransformCachedModule() {
 				return _command === "build" && hasAnalyzableShares;
@@ -7887,7 +8272,7 @@ function proxySharedModule(options) {
 			transform(code, id) {
 				if (_command !== "build" || !hasAnalyzableShares) return;
 				collectTreeShakingImports(code, id, shared, findSharedKeyForSource, (sharedKey, exports, request) => recordTreeShakingExports(sharedKey, exports, request, federationOptions), (sharedKey, request) => markTreeShakingPackageUnsafe(sharedKey, request, federationOptions));
-				refreshTreeShakingModules(federationOptions);
+				refreshTreeShakingForEnvironment(this);
 			}
 		},
 		{
@@ -7989,15 +8374,6 @@ const JS_EXTENSIONS_RE = /\.(?:[mc]?[jt]sx?|vue|svelte)(?:\?|$)/;
 function isAstNode(value) {
 	return !!value && typeof value === "object" && typeof value.type === "string";
 }
-function findStaticRemoteSources(code, isRemoteImport) {
-	const codePositions = createCodePositionMap(code);
-	const sources = /* @__PURE__ */ new Set();
-	for (const pattern of [/\b(?:import|export)\s+[^;]*?\bfrom\s*["']([^"']+)["']/g, /\bimport\s*["']([^"']+)["']/g]) for (const match of code.matchAll(pattern)) {
-		const source = match[1];
-		if (codePositions[match.index] && isRemoteImport(source)) sources.add(source);
-	}
-	return sources;
-}
 function walkAST(root, visitor) {
 	const seen = /* @__PURE__ */ new WeakSet();
 	function visit(node) {
@@ -8256,7 +8632,7 @@ function pluginRemoteNamedExports(options) {
 			if (!JS_EXTENSIONS_RE.test(id)) return;
 			if (!remoteNames.some((name) => code.includes(name))) return;
 			const matchesRemoteImport = (source) => isRemoteImport(source, id);
-			for (const source of findStaticRemoteSources(code, matchesRemoteImport)) markStaticRemote(source, options);
+			for (const { kind, source, typeOnly } of findModuleImportDescriptors(code)) if (kind === "static" && !typeOnly && matchesRemoteImport(source)) markStaticRemote(source, options);
 			let imports;
 			try {
 				imports = await collectFromAST(this.parse(code), code, matchesRemoteImport);
@@ -8764,7 +9140,7 @@ const FEDERATION_CONTROL_CHUNK_HINTS = [
 	"localSharedImportMap"
 ];
 function stripEmptyPreloadCalls(code) {
-	const helperImportRegex = /import\s*\{\s*_\s*as\s*(\w+)\s*\}\s*from\s*["'][^"']+["']\s*;?/g;
+	const helperImportRegex = /import\s*\{\s*_\s*as\s*([A-Za-z_$][\w$]*)\s*\}\s*from\s*["'][^"']+["']\s*;?/g;
 	const helperAliases = [];
 	let helperImportMatch;
 	while ((helperImportMatch = helperImportRegex.exec(code)) !== null) helperAliases.push(helperImportMatch[1]);
@@ -8800,7 +9176,7 @@ function stripEmptyPreloadCalls(code) {
 	}
 	nextCode = nextCode.replace(/import\s*["'][^"']*__loadShare__[^"']*["']\s*;?/g, "");
 	nextCode = nextCode.replace(helperImportRegex, (statement, local) => {
-		return new RegExp(`\\b${local}\\b`).test(nextCode.replace(statement, "")) ? statement : "";
+		return isIdentifierReferenced(local, nextCode.replace(statement, "")) ? statement : "";
 	});
 	return nextCode;
 }
@@ -8826,42 +9202,6 @@ function isTestEnv() {
 	return process.env.NODE_ENV === "test" || process.env.VITEST != null || process.env.JEST_WORKER_ID != null;
 }
 //#endregion
-//#region src/utils/sharedExportConditions.ts
-const DEFAULT_CLIENT_EXPORT_CONDITIONS = [
-	"browser",
-	"import",
-	"module",
-	"default"
-];
-const DEFAULT_NODE_SSR_EXPORT_CONDITIONS = [
-	"node",
-	"import",
-	"module",
-	"default"
-];
-const DEFAULT_WEBWORKER_SSR_EXPORT_CONDITIONS = [
-	"worker",
-	"browser",
-	"import",
-	"module",
-	"default"
-];
-const VITE_DEV_PROD_CONDITION = "development|production";
-function appendConditions(conditions, fallbackConditions) {
-	return [.../* @__PURE__ */ new Set([...conditions, ...fallbackConditions])];
-}
-function resolveViteModeCondition(conditions, isProduction) {
-	const modeCondition = isProduction ? "production" : "development";
-	return [...new Set(conditions.map((condition) => condition === VITE_DEV_PROD_CONDITION ? modeCondition : condition))];
-}
-function getSharedExportConditions({ environmentConditions, isProduction, isSsr, rootConditions, ssrConditions, ssrTarget = "node" }) {
-	if (environmentConditions !== void 0) return resolveViteModeCondition(appendConditions(environmentConditions, ["import", "default"]), isProduction);
-	const defaultConditions = isSsr ? ssrTarget === "webworker" ? DEFAULT_WEBWORKER_SSR_EXPORT_CONDITIONS : DEFAULT_NODE_SSR_EXPORT_CONDITIONS : DEFAULT_CLIENT_EXPORT_CONDITIONS;
-	const configuredConditions = isSsr ? ssrConditions ?? rootConditions : rootConditions;
-	if (configuredConditions !== void 0) return resolveViteModeCondition(appendConditions(configuredConditions, defaultConditions), isProduction);
-	return [...defaultConditions];
-}
-//#endregion
 //#region src/utils/normalizeOptimizeDeps.ts
 var normalizeOptimizeDeps_default = {
 	name: "normalizeOptimizeDeps",
@@ -9109,9 +9449,10 @@ function isFile(candidate) {
 		return false;
 	}
 }
-function registerEntryImports(options, projectRoot) {
-	const staticImport = /\b(?:import|export)\s+(?:type\s+)?(?:[^'";]*?\s+from\s*)?(['"])([^'"]+)\1/g;
-	const dynamicImport = /\b(?:import|require)\s*\(\s*(['"])([^'"]+)\1/g;
+function isReactRouterBuildClientRouteInput(entry) {
+	return /[?&]__react-router-build-client-route(?:[=&]|$)/.test(entry);
+}
+function registerEntryImports(options, projectRoot, recordShared = true, entryFiles = []) {
 	const sourceExtensions = [
 		".mjs",
 		".js",
@@ -9141,10 +9482,15 @@ function registerEntryImports(options, projectRoot) {
 			preloadRemotes
 		});
 	};
-	const htmlEntry = path$1.join(root, "index.html");
-	if (existsSync(htmlEntry)) {
+	const htmlEntries = entryFiles.filter((file) => file.endsWith(".html"));
+	const htmlEntryPaths = htmlEntries.length ? htmlEntries : entryFiles.length === 0 ? [path$1.join(root, "index.html")] : [];
+	for (const htmlEntry of htmlEntryPaths) if (existsSync(htmlEntry)) {
 		const html = readFileSync(htmlEntry, "utf8");
-		for (const match of html.matchAll(/<script\b[^>]*\bsrc=(['"])([^'"]+)\1[^>]*>/gi)) enqueue(match[2], htmlEntry, true);
+		for (const match of html.matchAll(/<script\b(?=[^>]*\btype=["']module["'])(?=[^>]*\bsrc=(['"])([^'"]+)\1)[^>]*>/gi)) enqueue(match[2], htmlEntry, true);
+	}
+	for (const entry of entryFiles.filter((file) => !file.endsWith(".html"))) {
+		const relativeEntry = path$1.relative(root, entry);
+		enqueue(relativeEntry.startsWith(".") ? relativeEntry : `./${relativeEntry}`, path$1.join(root, "index.html"), true);
 	}
 	for (const expose of Object.values(options.exposes ?? {})) enqueue(expose.import);
 	while (pending.length) {
@@ -9152,17 +9498,15 @@ function registerEntryImports(options, projectRoot) {
 		if (visited.get(file) || visited.has(file) && !preloadRemotes) continue;
 		visited.set(file, preloadRemotes);
 		const code = readFileSync(file, "utf8");
-		for (const pattern of [staticImport, dynamicImport]) {
-			const isStatic = pattern === staticImport;
-			pattern.lastIndex = 0;
-			for (const match of code.matchAll(pattern)) {
-				const request = match[2];
-				const remoteKey = preloadRemotes && isStatic && request ? Object.keys(options.remotes).find((name) => request === name || request.startsWith(`${name}/`)) : void 0;
-				const sharedKey = request && findSharedKey(request, options.shared);
-				if (remoteKey) addUsedRemote(remoteKey, request, options);
-				else if (sharedKey) addUsedShares(request, options);
-				else if (request) enqueue(request, file, preloadRemotes && isStatic);
-			}
+		for (const { source: request, kind, typeOnly } of findModuleImportDescriptors(code)) {
+			const isStatic = kind === "static" && !typeOnly;
+			const remoteKey = preloadRemotes && isStatic && request ? Object.keys(options.remotes).find((name) => request === name || request.startsWith(`${name}/`)) : void 0;
+			const sharedKey = !typeOnly && request && findSharedKey(request, options.shared);
+			if (remoteKey) {
+				addUsedRemote(remoteKey, request, options);
+				markStaticRemote(request, options);
+			} else if (sharedKey && recordShared) addUsedShares(request, options);
+			else if (request && !typeOnly) enqueue(request, file, preloadRemotes && isStatic);
 		}
 	}
 }
@@ -9180,6 +9524,8 @@ function createEarlyVirtualModulesPlugin(options) {
 		config(config, { command: _command }) {
 			if (_command === "serve") ignoreFederationGeneratedFiles(config, options);
 			const root = config.root || process.cwd();
+			const buildInput = getBuildInput(config);
+			const resolvedConfiguredEntryFiles = (typeof buildInput === "string" ? [buildInput] : Array.isArray(buildInput) ? buildInput : buildInput && typeof buildInput === "object" ? Object.values(buildInput) : []).map((entry) => String(entry)).filter((entry) => !isReactRouterBuildClientRouteInput(entry)).map((entry) => entry.split(/[?#]/)[0]).map((entry) => path$1.isAbsolute(entry) ? entry : path$1.resolve(root, entry));
 			resetConcreteSharedImportSourceCache();
 			setPackageDetectionCwd(root);
 			const isVinext = hasPackageDependency("vinext");
@@ -9194,7 +9540,7 @@ function createEarlyVirtualModulesPlugin(options) {
 					config.optimizeDeps.exclude.push(...Object.keys(remotes || {}));
 				}
 			}
-			if (_command === "serve" && (Object.keys(shared ?? {}).length > 0 || Object.keys(remotes ?? {}).length > 0)) registerEntryImports(options, root);
+			if (!config.build?.ssr && (Object.keys(shared ?? {}).length > 0 || Object.keys(remotes ?? {}).length > 0)) registerEntryImports(options, root, _command === "serve", resolvedConfiguredEntryFiles);
 			if (shared && Object.keys(shared).length > 0) {
 				if (_command === "serve") {
 					excludeSharedSubDependencies(shared);
@@ -9457,6 +9803,7 @@ function federation(mfUserOptions) {
 			ssrTarget
 		});
 	};
+	const refreshLoadRemoteModuleForEnvironment = (id, context, loadOptions) => refreshRemoteModuleForEnvironment(id, options, getLoadHookExportConditions(context, loadOptions));
 	const refreshPreBuildModuleForEnvironment = (id, context, loadOptions) => {
 		const pkg = getCachedPreBuildPkg(id);
 		if (!pkg) return "not-applicable";
@@ -9520,8 +9867,13 @@ function federation(mfUserOptions) {
 				return virtualModule.getResolvedId();
 			},
 			load(id, loadOptions) {
-				if (command !== "build" && id.includes("__loadShare__") && refreshLoadShareModuleForEnvironment(id, this, loadOptions) === "not-owned") return;
+				if (id.includes("__loadRemote__") && !refreshLoadRemoteModuleForEnvironment(id, this, loadOptions)) return;
+				if (command !== "build" && id.includes("__loadShare__")) {
+					id = findCurrentLoadShareForStaleOwnerId(id, options.shared, findSharedKey, options)?.getResolvedId() ?? id;
+					if (refreshLoadShareModuleForEnvironment(id, this, loadOptions) === "not-owned") return;
+				}
 				if (id.includes("__prebuild__") && refreshPreBuildModuleForEnvironment(id, this, loadOptions) === "not-owned") return;
+				if (id.includes("__H_A_I__") && isOwnedHostAutoInitId(id, options)) refreshHostAutoInit(options, getLoadHookExportConditions(this, loadOptions));
 				const virtualModule = VirtualModule.findById(id);
 				if (!virtualModule) return;
 				if (command === "build" && (id.includes("__loadShare__") || id.includes("__loadRemote__"))) return;
@@ -9742,6 +10094,7 @@ function federation(mfUserOptions) {
 			load(id, loadOptions) {
 				const loadVirtualModule = (importFalseExportUsage) => {
 					if (!id.includes("__loadShare__") && !id.includes("__loadRemote__")) return;
+					if (id.includes("__loadRemote__") && !refreshLoadRemoteModuleForEnvironment(id, this, loadOptions)) return;
 					if (id.includes("__loadShare__") && refreshLoadShareModuleForEnvironment(id, this, loadOptions, importFalseExportUsage) === "not-owned") return;
 					const virtualModule = VirtualModule.findById(id);
 					if (!virtualModule?.code) return null;