@module-federation/vite 1.20.7 → 1.20.9

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
@@ -1177,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);
@@ -1193,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);
@@ -1203,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()}
@@ -1219,8 +1490,8 @@ const ${options.exposedConst} = ${options.stateVar}.${options.exposedProperty};
 }
 function getRuntimeInitBootstrapCode(enableSsrInit = false, ownerImportId, ssrRemotes, hostInitImportId = ownerImportId, exportConditions) {
 	return `
-const globalKey = ${JSON.stringify(getRuntimeInitGlobalKey(ownerImportId))};
-const moduleCacheGlobalKey = ${JSON.stringify(getModuleCacheGlobalKey(exportConditions))};
+const globalKey = ${toSafeJsLiteral(getRuntimeInitGlobalKey(ownerImportId))};
+const moduleCacheGlobalKey = ${toSafeJsLiteral(getModuleCacheGlobalKey(exportConditions))};
 globalThis[moduleCacheGlobalKey] ||= { share: {}, remote: {} };
 globalThis[moduleCacheGlobalKey].share ||= {};
 globalThis[moduleCacheGlobalKey].remote ||= {};
@@ -1245,7 +1516,7 @@ globalThis[globalKey].moduleCache.remote ||= {};
 }
 function getRuntimeModuleCacheBootstrapCode(exportConditions) {
 	return `
-const __mfCacheGlobalKey = ${JSON.stringify(getModuleCacheGlobalKey(exportConditions))};
+const __mfCacheGlobalKey = ${toSafeJsLiteral(getModuleCacheGlobalKey(exportConditions))};
 globalThis[__mfCacheGlobalKey] ||= { share: {}, remote: {} };
 globalThis[__mfCacheGlobalKey].share ||= {};
 globalThis[__mfCacheGlobalKey].remote ||= {};
@@ -2391,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;
@@ -2410,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);
@@ -2809,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(`
@@ -3028,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;`}
         }
       `;
@@ -3056,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
@@ -3088,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();
               },` : ""}
@@ -3113,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(",")}
@@ -3259,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;
@@ -3268,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) => {
@@ -3430,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);
@@ -3531,7 +3812,7 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy, options) {
         initialShared[pkg],
         pkg,
         share,
-        ${JSON.stringify(shareStrategy)}
+        ${toSafeJsLiteral(shareStrategy)}
       ));
     };
     const __mfFirstRuntimeSeedBarrierIndex = __mfSeedKeys.findIndex(
@@ -3738,7 +4019,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
 	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",
@@ -3795,9 +4076,9 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   ${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
@@ -3927,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)
@@ -3979,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__";
@@ -3990,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) {
@@ -4022,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) => {
@@ -4050,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;
@@ -4322,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);
@@ -4370,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,
@@ -4653,8 +4959,8 @@ function getHostAutoInitState(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(exportConditions)}
@@ -4669,44 +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 &&
-              __mfReadSharedCacheOwner(__mfModuleCache.share, cacheDescriptor) !== undefined
-            ) {
-              continue;
-            }
-            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,
-                resolved,
-                ${cacheOwner}
-              );
-            });
+          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,
+                  resolved,
+                  ${cacheOwner}
+                );
+              });
+            }));
           }
           ` : ""}
           return runtime;
@@ -4723,7 +5029,7 @@ function writeHostAutoInit(remoteEntryId = REMOTE_ENTRY_ID, command = "build", o
 	state.remoteEntryId = remoteEntryId;
 	state.command = command;
 	if (exportConditions !== void 0) state.exportConditions = exportConditions;
-	state.module.writeSync(generateHostAutoInitCode(JSON.stringify(remoteEntryId), command, options, state.exportConditions), true);
+	state.module.writeSync(generateHostAutoInitCode(toSafeJsLiteral(remoteEntryId), command, options, state.exportConditions), true);
 }
 function refreshHostAutoInit(options, exportConditions) {
 	try {
@@ -4784,6 +5090,7 @@ 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) {
@@ -4820,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;
@@ -5000,18 +5323,9 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
 	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),
@@ -5064,7 +5378,7 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
     }`;
 	const realRemoteInit = `__mfRemotePending = __mfStartRemoteLoad().then(__mfAssignRemoteModule);`;
 	const deferredClientInit = `exportModule = __mfCreateDeferredRemoteProxy();`;
-	const eagerLoadClientRemote = shouldEagerLoadClientRemoteInDev(command, enableSsrInit);
+	const eagerLoadClientRemote = id === remoteRegistration?.alias || shouldEagerLoadClientRemoteInDev(command, enableSsrInit);
 	const eagerClientInit = eagerLoadClientRemote ? getEagerDeferredClientInit() : deferredClientInit;
 	const loadedFirstClientInit = eagerLoadClientRemote ? getEagerDeferredClientInit() : deferredClientInit;
 	const environmentSplitInit = (clientInit, serverInit) => consumer === "client" ? clientInit : consumer === "server" ? serverInit : `if (${SERVER_ENV_GUARD}) {
@@ -5090,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);
@@ -5120,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"));
 }
@@ -5138,20 +5515,25 @@ function resolveDevHashEntryFileName$1(fileName) {
 function getBuildInput(config) {
 	return config.build?.rollupOptions?.input ?? config.build?.rolldownOptions?.input;
 }
-function patchHashEntryFileName(output, entryName, fileName) {
-	const originalEntryFileNames = output.entryFileNames;
-	output.entryFileNames = (chunkInfo, ...args) => {
-		if (chunkInfo?.name === entryName) return fileName;
-		if (typeof originalEntryFileNames === "function") return originalEntryFileNames(chunkInfo, ...args);
-		return originalEntryFileNames || "assets/[name]-[hash].js";
-	};
+function patchHashEntryFileName(output, entryName, fileName, defaultFileNames) {
+	for (const option of ["entryFileNames", "chunkFileNames"]) {
+		const originalFileNames = output[option];
+		output[option] = (chunkInfo, ...args) => {
+			if (chunkInfo?.name === entryName) return fileName;
+			if (typeof originalFileNames === "function") return originalFileNames(chunkInfo, ...args);
+			return originalFileNames || defaultFileNames;
+		};
+	}
 }
 function patchHashEntryFileNames(config, entryName, fileName) {
 	if (!fileName?.includes?.("[hash")) return;
+	fileName = fileName.replace(/(\[hash(?::\d+)?\])$/, "$1.js");
 	config.build ??= {};
 	config.build.rollupOptions ??= {};
 	config.build.rolldownOptions ??= {};
-	const patchOutput = (output) => patchHashEntryFileName(output, entryName, fileName);
+	const assetsDir = config.build.assetsDir ?? "assets";
+	const defaultFileNames = `${assetsDir ? `${assetsDir}/` : ""}[name]-[hash].js`;
+	const patchOutput = (output) => patchHashEntryFileName(output, entryName, fileName, defaultFileNames);
 	const patchBundlerOutput = (bundlerOptions) => {
 		const output = bundlerOptions.output;
 		if (Array.isArray(output)) {
@@ -5162,6 +5544,7 @@ function patchHashEntryFileNames(config, entryName, fileName) {
 	};
 	patchBundlerOutput(config.build.rollupOptions);
 	patchBundlerOutput(config.build.rolldownOptions);
+	Object.values(config.environments ?? {}).forEach((environment) => patchHashEntryFileNames(environment, entryName, fileName));
 }
 const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClientInjected, skipTransformFor = [], federationOptions }) => {
 	const DEV_HTML_PROXY_PREFIX = "virtual:mf-html-entry-proxy?";
@@ -5240,6 +5623,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'
@@ -5251,11 +5644,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]) {
@@ -5273,7 +5690,7 @@ 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);
@@ -5287,13 +5704,14 @@ const __mfCurrentScript = document.currentScript;
   const __mfHostInit = await ${importExpression(initSrc)};
   await __mfHostInit.__tla;
   const { initHost } = __mfHostInit;
-  ${preloadBlock}${pendingShareLoadsAwait}
+  ${preloadBlock}${sharedPreloadBlock}${pendingShareLoadsAwait}
 })().then(() => ${entryImportExpression});
 `;
 		return [
 			getRuntimeModuleCacheBootstrapCode(),
 			importHelper,
 			entryImportDeclaration,
+			remoteEntryPrefetchBlock,
 			importCode
 		].join("\n");
 	}
@@ -5325,6 +5743,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);
@@ -5391,7 +5820,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();
 			});
 		},
@@ -5472,6 +5904,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"));
@@ -5533,12 +5969,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;
@@ -5578,7 +6014,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)) {
@@ -5669,6 +6105,7 @@ const REACT_REFRESH_PROXY_MODULE = [
 	`const __rt = await import(__target);`,
 	`export const injectIntoGlobalHook = __rt.injectIntoGlobalHook;`,
 	`export const register = __rt.register;`,
+	`export const getRefreshReg = __rt.getRefreshReg;`,
 	`export const createSignatureFunctionForTransform = __rt.createSignatureFunctionForTransform;`,
 	`export const registerExportsForReactRefresh = __rt.registerExportsForReactRefresh;`,
 	`export const validateRefreshBoundaryAndEnqueueUpdate = __rt.validateRefreshBoundaryAndEnqueueUpdate;`,
@@ -6332,200 +6769,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"];
@@ -6589,28 +6832,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 ?? []),
@@ -6927,6 +7175,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 {
@@ -7089,6 +7385,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);
@@ -7452,12 +7749,18 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		return Object.keys(options.remotes).some((name) => source === name || source.startsWith(name + "/"));
 	}
 	function collectImportSources(code) {
-		const sources = /* @__PURE__ */ new Set();
+		const sources = /* @__PURE__ */ new Map();
 		for (const match of code.matchAll(/(?:^|[;\n\r])\s*import\s+(?:[\s\S]*?\s+from\s+)?["']([^"']+)["']|import\(\s*["']([^"']+)["']\s*\)/g)) {
 			const source = match[1] || match[2];
-			if (source) sources.add(source);
+			if (source) {
+				const dynamic = !match[1];
+				sources.set(source, (sources.get(source) ?? true) && dynamic);
+			}
 		}
-		return Array.from(sources).sort();
+		return Array.from(sources, ([source, dynamic]) => ({
+			source,
+			dynamic
+		})).sort((a, b) => a.source.localeCompare(b.source));
 	}
 	function shouldScanResolvedImport(id) {
 		if (!id || id.includes("\0")) return false;
@@ -7474,9 +7777,9 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 			return [];
 		}
 		const dependencies = /* @__PURE__ */ new Set();
-		for (const source of collectImportSources(code)) {
+		for (const { source, dynamic } of collectImportSources(code)) {
 			if (isRemoteImport(source)) {
-				dependencies.add(source);
+				if (!dynamic) dependencies.add(source);
 				continue;
 			}
 			const resolved = await ctx.resolve(source, id);
@@ -7859,6 +8162,7 @@ function excludeSharedSubDependencies(shared) {
 				delete shared[depKey];
 				sharedKeys.delete(depKey);
 				sharedKeyByBase.delete(dep);
+				sharedKeyMatcherCache.delete(shared);
 			}
 		}
 	}
@@ -8083,15 +8387,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) {
@@ -8148,8 +8443,10 @@ function applyRewrites(code, imports, id) {
 				importParts.push(`__mf_remote_pending as ${pendingId}`);
 				let rewrite = `import { ${importParts.join(", ")} } from ${src};`;
 				if (imp.named.length > 0) {
-					const destructParts = imp.named.map((s) => `${s.imported}: ${s.local}`);
-					rewrite += `\nconst { ${destructParts.join(", ")} } = ${nsId};`;
+					const declarations = imp.named.map((s) => `let ${s.local};`).join("\n");
+					const initializers = imp.named.map((s) => `if (${JSON.stringify(s.imported)} in ${nsId}) {\n${s.local} = ${nsId}[${JSON.stringify(s.imported)}];\n}`).join("\n");
+					const assignments = imp.named.map((s) => `${s.local} = ${nsId}[${JSON.stringify(s.imported)}];`).join("\n");
+					rewrite += `\n${declarations}\n${initializers}\n${pendingId}.then(() => {\n${assignments}\n});`;
 				}
 				ms.overwrite(imp.start, imp.end, rewrite);
 			}
@@ -8169,10 +8466,11 @@ function applyRewrites(code, imports, id) {
 				};
 			});
 			const importLine = `import { __moduleExports as ${nsId}, __mf_remote_pending as ${pendingId} } from ${src};`;
-			const varLines = vars.map((v) => `let ${v.tmp} = ${nsId}[${JSON.stringify(v.local)}];`).join("\n");
+			const varLines = vars.map((v) => `let ${v.tmp};`).join("\n");
+			const initializers = vars.map((v) => `if (${JSON.stringify(v.local)} in ${nsId}) {\n${v.tmp} = ${nsId}[${JSON.stringify(v.local)}];\n}`).join("\n");
 			const syncLine = `${pendingId}.then(() => {\n${vars.map((v) => `${v.tmp} = ${nsId}[${JSON.stringify(v.local)}];`).join("\n")}\n});`;
 			const exportLine = `export { ${vars.map((v) => `${v.tmp} as ${v.exported}`).join(", ")} };`;
-			ms.overwrite(imp.start, imp.end, `${importLine}\n${varLines}\n${syncLine}\n${exportLine}`);
+			ms.overwrite(imp.start, imp.end, `${importLine}\n${varLines}\n${initializers}\n${syncLine}\n${exportLine}`);
 			changed = true;
 			break;
 		}
@@ -8350,7 +8648,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);
@@ -8858,7 +9156,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]);
@@ -8894,7 +9192,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;
 }
@@ -9140,6 +9438,14 @@ function includeLinkedSharedEntries(optimizeDeps, shared, projectRoot, exposes,
 	]);
 	for (const [packageName, share] of Object.entries(shared ?? {})) {
 		if (share?.shareConfig?.import === false) continue;
+		const configuredImport = share?.shareConfig?.import;
+		if (typeof configuredImport === "string") {
+			const entry = path$1.isAbsolute(configuredImport) ? configuredImport : path$1.resolve(projectRoot, configuredImport);
+			if (existsSync(entry) && !entry.replaceAll("\\", "/").includes("/node_modules/")) {
+				additions.add(entry);
+				continue;
+			}
+		}
 		const installed = getInstalledPackageJson(packageName, { cwd: projectRoot });
 		if (!installed || installed.dir.replaceAll("\\", "/").includes("/node_modules/")) continue;
 		const entry = getInstalledPackageEntry(packageName, { cwd: projectRoot });
@@ -9167,9 +9473,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",
@@ -9199,10 +9506,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) {
@@ -9210,17 +9522,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);
 		}
 	}
 }
@@ -9238,6 +9548,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");
@@ -9252,7 +9564,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);
@@ -9316,9 +9628,20 @@ function createEarlyVirtualModulesPlugin(options) {
 									if (args.kind === "entry-point") return;
 									if (!args.importer || args.namespace === "mf-shared") return;
 									if (isSharedResolverInternalImporter(args.importer)) return;
-									if (!findSharedKey(args.path, shared) || isAssetLikeImport(args.path)) return;
+									const key = findSharedKey(args.path, shared);
+									if (!key || isAssetLikeImport(args.path)) return;
 									if (getPackageNameFromNodeModulePath(args.importer) === getPackageName(args.path) && !isReactDomSelfReference(args.path, args.importer)) return;
 									addUsedShares(args.path, options);
+									if (args.kind === "import-statement" || args.kind === "dynamic-import") {
+										const shareItem = shared[key];
+										const loadSharePath = getLoadShareModulePath(args.path, isRolldown, options);
+										writeLoadShareModule(args.path, shareItem, _command, isRolldown, options);
+										if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(args.path, shareItem, options);
+										return {
+											path: loadSharePath,
+											external: true
+										};
+									}
 									return {
 										path: args.path,
 										namespace: "mf-shared"
@@ -9375,7 +9698,7 @@ export default __mfShared.default ?? __mfShared;`
 						optimizeDeps.exclude ??= [];
 						const shouldBypassOptimizeDep = isLitShare(key) || !canResolveSharedSubpath(key, root);
 						if (optimizeDeps.include.includes(key)) optimizeDeps.exclude = optimizeDeps.exclude.filter((dep) => dep !== key);
-						else if (shouldBypassOptimizeDep) optimizeDeps.exclude.push(key);
+						else if (shouldBypassOptimizeDep || optimizeDeps.exclude.includes(key)) optimizeDeps.exclude.push(key);
 						else optimizeDeps.include.push(key);
 						for (const subpath of getCommonSharedSubpaths(key)) {
 							const canResolveSubpath = canResolveSharedSubpath(subpath, root);
@@ -9580,7 +9903,10 @@ function federation(mfUserOptions) {
 			},
 			load(id, loadOptions) {
 				if (id.includes("__loadRemote__") && !refreshLoadRemoteModuleForEnvironment(id, this, loadOptions)) return;
-				if (command !== "build" && id.includes("__loadShare__") && refreshLoadShareModuleForEnvironment(id, this, loadOptions) === "not-owned") 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);