@module-federation/vite 1.15.1 → 1.15.2

package/lib/index.mjs

@@ -1,28 +1,151 @@
 import { createRequire } from "node:module";
-import defu from "defu";
 import * as fs$1 from "fs";
-import fs, { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFile, writeFileSync } from "fs";
+import fs, { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFile, writeFileSync } from "fs";
 import { createRequire as createRequire$1 } from "module";
 import * as path$1 from "pathe";
 import path, { basename, dirname, join, parse, resolve } from "pathe";
-import MagicString from "magic-string";
 import { normalizeOptions } from "@module-federation/sdk";
 import { consumeTypesAPI, generateTypesAPI, isTSProject, normalizeConsumeTypesOptions, normalizeDtsOptions, normalizeGenerateTypesOptions } from "@module-federation/dts-plugin";
 import { rpc } from "@module-federation/dts-plugin/core";
-import { createFilter } from "@rollup/pluginutils";
 import { fileURLToPath } from "url";
 import { init, parse as parse$1 } from "es-module-lexer";
 //#region \0rolldown/runtime.js
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 //#endregion
+//#region src/utils/codeRewriter.ts
+const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var CodeRewriter = class {
+	replacements = [];
+	constructor(original) {
+		this.original = original;
+	}
+	overwrite(start, end, content) {
+		if (start < 0 || end < start || end > this.original.length) throw new Error(`Invalid overwrite range: ${start}-${end}`);
+		this.replacements.push({
+			start,
+			end,
+			content
+		});
+	}
+	toString() {
+		return applyReplacements(this.original, this.getSortedReplacements()).code;
+	}
+	generateMap(source = "") {
+		const { code, replacements } = applyReplacements(this.original, this.getSortedReplacements());
+		return {
+			version: 3,
+			sources: [source],
+			sourcesContent: [this.original],
+			names: [],
+			mappings: generateLineMappings(code, this.original, replacements)
+		};
+	}
+	getSortedReplacements() {
+		return [...this.replacements].sort((a, b) => a.start - b.start || a.end - b.end);
+	}
+};
+function createSourceMap(code, source = "") {
+	return {
+		version: 3,
+		sources: [source],
+		sourcesContent: [code],
+		names: [],
+		mappings: generateLineMappings(code, code, [])
+	};
+}
+function applyReplacements(original, replacements) {
+	let code = "";
+	let cursor = 0;
+	let delta = 0;
+	const applied = [];
+	for (const replacement of replacements) {
+		if (replacement.start < cursor) throw new Error("Overlapping overwrite ranges are not supported");
+		code += original.slice(cursor, replacement.start);
+		const generatedStart = replacement.start + delta;
+		code += replacement.content;
+		const generatedEnd = generatedStart + replacement.content.length;
+		applied.push({
+			...replacement,
+			generatedStart,
+			generatedEnd
+		});
+		cursor = replacement.end;
+		delta += replacement.content.length - (replacement.end - replacement.start);
+	}
+	code += original.slice(cursor);
+	return {
+		code,
+		replacements: applied
+	};
+}
+function generateLineMappings(generated, original, replacements) {
+	const generatedLineStarts = getLineStarts(generated);
+	const originalLineStarts = getLineStarts(original);
+	let previousOriginalLine = 0;
+	let previousOriginalColumn = 0;
+	let mappings = "";
+	generatedLineStarts.forEach((generatedOffset, lineIndex) => {
+		if (lineIndex > 0) mappings += ";";
+		const originalOffset = generatedOffsetToOriginalOffset(generatedOffset, replacements);
+		const originalLine = findLine(originalLineStarts, originalOffset);
+		const originalColumn = originalOffset - originalLineStarts[originalLine];
+		mappings += encodeSegment([
+			0,
+			0,
+			originalLine - previousOriginalLine,
+			originalColumn - previousOriginalColumn
+		]);
+		previousOriginalLine = originalLine;
+		previousOriginalColumn = originalColumn;
+	});
+	return mappings;
+}
+function generatedOffsetToOriginalOffset(offset, replacements) {
+	let delta = 0;
+	for (const replacement of replacements) {
+		if (offset < replacement.generatedStart) break;
+		if (offset < replacement.generatedEnd) return replacement.start;
+		delta += replacement.content.length - (replacement.end - replacement.start);
+	}
+	return offset - delta;
+}
+function getLineStarts(code) {
+	const starts = [0];
+	for (let i = 0; i < code.length; i++) if (code.charCodeAt(i) === 10) starts.push(i + 1);
+	return starts;
+}
+function findLine(lineStarts, offset) {
+	let low = 0;
+	let high = lineStarts.length - 1;
+	while (low <= high) {
+		const mid = low + high >> 1;
+		if (lineStarts[mid] <= offset) low = mid + 1;
+		else high = mid - 1;
+	}
+	return Math.max(0, high);
+}
+function encodeSegment(values) {
+	return values.map(encodeVlq).join("");
+}
+function encodeVlq(value) {
+	let vlq = value < 0 ? (-value << 1) + 1 : value << 1;
+	let encoded = "";
+	do {
+		let digit = vlq & 31;
+		vlq >>>= 5;
+		if (vlq > 0) digit |= 32;
+		encoded += BASE64_CHARS[digit];
+	} while (vlq > 0);
+	return encoded;
+}
+//#endregion
 //#region src/utils/mapCodeToCodeWithSourcemap.ts
 async function mapCodeToCodeWithSourcemap(code) {
 	const resolvedCode = await code;
 	if (resolvedCode === void 0) return;
-	const s = new MagicString(resolvedCode);
 	return {
-		code: s.toString(),
-		map: s.generateMap({ hires: true })
+		code: resolvedCode,
+		map: createSourceMap(resolvedCode)
 	};
 }
 //#endregion
@@ -623,107 +746,6 @@ var VirtualModule = class {
 	}
 };
 //#endregion
-//#region src/virtualModules/virtualRuntimeInitStatus.ts
-const virtualRuntimeInitStatus = new VirtualModule("runtimeInit");
-const MODULE_CACHE_GLOBAL_KEY = "__mf_module_cache__";
-function getRuntimeInitGlobalKey() {
-	return `__mf_init__${virtualRuntimeInitStatus.getImportId()}__`;
-}
-function getDeferredInitPromiseCode() {
-	return `let initResolve, initReject;
-  const initPromise = new Promise((re, rj) => {
-    initResolve = re;
-    initReject = rj;
-  });`;
-}
-function getSsrNoopResolveCode() {
-	return `if (typeof window === 'undefined') {
-    initResolve({
-      loadRemote: function() { return Promise.resolve(undefined); },
-      loadShare: function() { return Promise.resolve(undefined); },
-    });
-  }`;
-}
-function getRuntimeInitStateBootstrapCode(options) {
-	return `
-const ${options.globalKeyVar} = ${JSON.stringify(getRuntimeInitGlobalKey())};
-let ${options.stateVar} = globalThis[${options.globalKeyVar}];
-if (!${options.stateVar}) {
-  ${getDeferredInitPromiseCode()}
-  ${options.stateVar} = globalThis[${options.globalKeyVar}] = {
-    initPromise,
-    initResolve,
-    initReject,
-  };
-  ${getSsrNoopResolveCode()}
-}
-const ${options.exposedConst} = ${options.stateVar}.${options.exposedProperty};
-`;
-}
-function getRuntimeInitBootstrapCode() {
-	return `
-const globalKey = ${JSON.stringify(getRuntimeInitGlobalKey())};
-const moduleCacheGlobalKey = ${JSON.stringify(MODULE_CACHE_GLOBAL_KEY)};
-globalThis[moduleCacheGlobalKey] ||= { share: {}, remote: {} };
-globalThis[moduleCacheGlobalKey].share ||= {};
-globalThis[moduleCacheGlobalKey].remote ||= {};
-if (!globalThis[globalKey]) {
-  ${getDeferredInitPromiseCode()}
-  globalThis[globalKey] = {
-    initPromise,
-    initResolve,
-    initReject,
-    moduleCache: globalThis[moduleCacheGlobalKey],
-  };
-  ${getSsrNoopResolveCode()}
-}
-globalThis[globalKey].moduleCache ||= globalThis[moduleCacheGlobalKey];
-globalThis[globalKey].moduleCache.share ||= {};
-globalThis[globalKey].moduleCache.remote ||= {};
-`;
-}
-function getRuntimeModuleCacheBootstrapCode() {
-	return `
-const __mfCacheGlobalKey = ${JSON.stringify(MODULE_CACHE_GLOBAL_KEY)};
-globalThis[__mfCacheGlobalKey] ||= { share: {}, remote: {} };
-globalThis[__mfCacheGlobalKey].share ||= {};
-globalThis[__mfCacheGlobalKey].remote ||= {};
-const __mfModuleCache = globalThis[__mfCacheGlobalKey];
-`;
-}
-function getRuntimeInitResolveBootstrapCode() {
-	return getRuntimeInitStateBootstrapCode({
-		globalKeyVar: "__mfResolveGlobalKey",
-		stateVar: "__mfResolveState",
-		exposedConst: "initResolve",
-		exposedProperty: "initResolve"
-	});
-}
-function writeRuntimeInitStatus(command) {
-	const exportStatement = command === "build" ? `const { initPromise, initResolve, initReject, moduleCache } = globalThis[globalKey];
-export { initPromise, initResolve, initReject, moduleCache };` : `module.exports = globalThis[globalKey];`;
-	virtualRuntimeInitStatus.writeSync(`
-${getRuntimeInitBootstrapCode()}
-${exportStatement}
-`);
-}
-//#endregion
-//#region src/utils/localSharedImportMap_temp.ts
-/**
-* https://github.com/module-federation/vite/issues/68
-*/
-function getLocalSharedImportMapPath_temp() {
-	const { name } = getNormalizeModuleFederationOptions();
-	return path.resolve(".__mf__temp", packageNameEncode(name), "localSharedImportMap");
-}
-function writeLocalSharedImportMap_temp(content) {
-	createFile(getLocalSharedImportMapPath_temp() + ".js", "\n// Windows temporarily needs this file, https://github.com/module-federation/vite/issues/68\n" + content);
-}
-function createFile(filePath, content) {
-	mkdirSync(path.dirname(filePath), { recursive: true });
-	writeFileSync(filePath, content);
-}
-//#endregion
 //#region src/utils/serializeRuntimeOptions.ts
 /**
 * Serializes a JavaScript object into a string of source code that can be evaluated.
@@ -854,6 +876,91 @@ function generateExposes(options) {
   `;
 }
 //#endregion
+//#region src/virtualModules/virtualRuntimeInitStatus.ts
+const virtualRuntimeInitStatus = new VirtualModule("runtimeInit");
+const MODULE_CACHE_GLOBAL_KEY = "__mf_module_cache__";
+function getRuntimeInitGlobalKey() {
+	return `__mf_init__${virtualRuntimeInitStatus.getImportId()}__`;
+}
+function getDeferredInitPromiseCode() {
+	return `let initResolve, initReject;
+  const initPromise = new Promise((re, rj) => {
+    initResolve = re;
+    initReject = rj;
+  });`;
+}
+function getSsrNoopResolveCode() {
+	return `if (typeof window === 'undefined') {
+    initResolve({
+      loadRemote: function() { return Promise.resolve(undefined); },
+      loadShare: function() { return Promise.resolve(undefined); },
+    });
+  }`;
+}
+function getRuntimeInitStateBootstrapCode(options) {
+	return `
+const ${options.globalKeyVar} = ${JSON.stringify(getRuntimeInitGlobalKey())};
+let ${options.stateVar} = globalThis[${options.globalKeyVar}];
+if (!${options.stateVar}) {
+  ${getDeferredInitPromiseCode()}
+  ${options.stateVar} = globalThis[${options.globalKeyVar}] = {
+    initPromise,
+    initResolve,
+    initReject,
+  };
+  ${getSsrNoopResolveCode()}
+}
+const ${options.exposedConst} = ${options.stateVar}.${options.exposedProperty};
+`;
+}
+function getRuntimeInitBootstrapCode() {
+	return `
+const globalKey = ${JSON.stringify(getRuntimeInitGlobalKey())};
+const moduleCacheGlobalKey = ${JSON.stringify(MODULE_CACHE_GLOBAL_KEY)};
+globalThis[moduleCacheGlobalKey] ||= { share: {}, remote: {} };
+globalThis[moduleCacheGlobalKey].share ||= {};
+globalThis[moduleCacheGlobalKey].remote ||= {};
+if (!globalThis[globalKey]) {
+  ${getDeferredInitPromiseCode()}
+  globalThis[globalKey] = {
+    initPromise,
+    initResolve,
+    initReject,
+    moduleCache: globalThis[moduleCacheGlobalKey],
+  };
+  ${getSsrNoopResolveCode()}
+}
+globalThis[globalKey].moduleCache ||= globalThis[moduleCacheGlobalKey];
+globalThis[globalKey].moduleCache.share ||= {};
+globalThis[globalKey].moduleCache.remote ||= {};
+`;
+}
+function getRuntimeModuleCacheBootstrapCode() {
+	return `
+const __mfCacheGlobalKey = ${JSON.stringify(MODULE_CACHE_GLOBAL_KEY)};
+globalThis[__mfCacheGlobalKey] ||= { share: {}, remote: {} };
+globalThis[__mfCacheGlobalKey].share ||= {};
+globalThis[__mfCacheGlobalKey].remote ||= {};
+const __mfModuleCache = globalThis[__mfCacheGlobalKey];
+`;
+}
+function getRuntimeInitResolveBootstrapCode() {
+	return getRuntimeInitStateBootstrapCode({
+		globalKeyVar: "__mfResolveGlobalKey",
+		stateVar: "__mfResolveState",
+		exposedConst: "initResolve",
+		exposedProperty: "initResolve"
+	});
+}
+function writeRuntimeInitStatus(command) {
+	const exportStatement = command === "build" ? `const { initPromise, initResolve, initReject, moduleCache } = globalThis[globalKey];
+export { initPromise, initResolve, initReject, moduleCache };` : `module.exports = globalThis[globalKey];`;
+	virtualRuntimeInitStatus.writeSync(`
+${getRuntimeInitBootstrapCode()}
+${exportStatement}
+`);
+}
+//#endregion
 //#region src/virtualModules/virtualShared_preBuild.ts
 /**
 * Even the resolveId hook cannot interfere with vite pre-build,
@@ -996,7 +1103,16 @@ function getLocalProviderImportPath(pkg) {
 		const resolved = createRequire$1(new URL(`file://${path.join(getPackageDetectionCwd(), "package.json")}`)).resolve(pkg);
 		return isWorkspaceFilePath(resolved) ? resolved : void 0;
 	} catch {
-		return;
+		const resolved = getInstalledPackageEntry(pkg, {
+			conditions: [
+				"browser",
+				"import",
+				"module",
+				"default"
+			],
+			resolveSubpathWithRequire: false
+		});
+		return isWorkspaceFilePath(resolved) ? resolved : void 0;
 	}
 }
 function getProjectResolvedImportPath(pkg) {
@@ -1011,7 +1127,12 @@ function getProjectResolvedImportPath(pkg) {
 	}
 }
 function isWorkspaceFilePath(resolved) {
-	return !!resolved && !resolved.includes("/node_modules/") && !resolved.includes("\\node_modules\\");
+	if (!resolved) return false;
+	let realResolved = resolved;
+	try {
+		realResolved = realpathSync.native(resolved);
+	} catch {}
+	return !realResolved.includes("/node_modules/") && !realResolved.includes("\\node_modules\\");
 }
 function isWorkspacePackageEntry(pkg, resolved) {
 	if (!resolved || !path.isAbsolute(resolved) || !isWorkspaceFilePath(resolved)) return false;
@@ -1124,11 +1245,12 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
 	const isWorkspacePackage = isWorkspacePackageEntry(pkg, localProviderPath) || isWorkspacePackageEntry(pkg, concreteSharedImportSource);
 	const lazyLocalFallbackSource = concreteSharedImportSource || localProviderPath || sharedImportSource;
 	const skipServePrebuildWarmup = command !== "build" && (pkg === "lit" || pkg.startsWith("lit/"));
+	const usesLazyLocalFallback = isWorkspacePackage && shareItem.shareConfig.singleton === true;
 	const namedExports = getPackageNamedExports(pkg);
 	let exportLine;
 	if (namedExports.length > 0) exportLine = `export default exportModule.default ?? exportModule;\n    ${`const { ${namedExports.map((name, i) => `${name}: __mf_${i}`).join(", ")} } = exportModule;`}\n    ${`export { ${namedExports.map((name, i) => `__mf_${i} as ${name}`).join(", ")} };`}`;
+	else if (usesLazyLocalFallback) exportLine = `export default exportModule.default ?? exportModule`;
 	else exportLine = `export default exportModule.default ?? exportModule\n    export * from ${escapeGeneratedStringLiteral(sharedImportSource)}`;
-	const usesLazyLocalFallback = isWorkspacePackage && shareItem.shareConfig.singleton === true;
 	const prebuildImportLine = usesLazyLocalFallback || isWorkspacePackage && command !== "build" ? "" : `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(skipServePrebuildWarmup ? devImportSource : sharedImportSource)};`;
 	const devDynamicImportLine = isWorkspacePackage ? "" : command !== "build" && !skipServePrebuildWarmup ? `;() => import(${escapeGeneratedStringLiteral(devImportSource)}).catch(() => {});` : "";
 	loadShareCacheMap[pkg].writeSync(`
@@ -1153,15 +1275,24 @@ function getUsedShares() {
 function addUsedShares(pkg) {
 	usedShares.add(pkg);
 }
+const LOCAL_SHARED_IMPORT_MAP_ID = "virtual:mf-localSharedImportMap";
 function getLocalSharedImportMapPath() {
-	return getLocalSharedImportMapPath_temp();
+	const { internalName, name } = getNormalizeModuleFederationOptions();
+	return `${LOCAL_SHARED_IMPORT_MAP_ID}:${packageNameEncode(internalName || name)}`;
+}
+function getResolvedLocalSharedImportMapId() {
+	return `\0${getLocalSharedImportMapPath()}`;
+}
+let invalidateLocalSharedImportMap;
+function setLocalSharedImportMapInvalidator(invalidator) {
+	invalidateLocalSharedImportMap = invalidator;
 }
 let prevLocalSharedImportMapContent;
 function writeLocalSharedImportMap() {
 	const nextContent = generateLocalSharedImportMap();
 	if (prevLocalSharedImportMapContent !== nextContent) {
 		prevLocalSharedImportMapContent = nextContent;
-		writeLocalSharedImportMap_temp(nextContent);
+		invalidateLocalSharedImportMap?.();
 	}
 }
 function shouldUseDirectReactImport() {
@@ -1361,14 +1492,40 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   let runtimeInstance
   let localSharedImportMapPromise
   let exposesMapPromise
+  const shouldRetrySharedInitError = ${command !== "build"} && ((error) => {
+    const message = String((error && error.message) || error || '');
+    return message.includes('Importing a module script failed') ||
+      message.includes('Failed to fetch') ||
+      message.includes('Load failed') ||
+      message.includes('Outdated Optimize Dep');
+  });
+  const waitSharedInitRetry = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  async function retrySharedInit(fn) {
+    for (let attempt = 0; ; attempt++) {
+      try {
+        return await fn();
+      } catch (e) {
+        const canRetry = typeof shouldRetrySharedInitError === 'function' && shouldRetrySharedInitError(e);
+        if (!canRetry || attempt >= 19) throw e;
+        await waitSharedInitRetry(250);
+      }
+    }
+  }
 
   async function getLocalSharedImportMap() {
-    localSharedImportMapPromise ??= import("${getLocalSharedImportMapPath()}")
+    if (!localSharedImportMapPromise) {
+      localSharedImportMapPromise = retrySharedInit(() => import("${getLocalSharedImportMapPath()}"))
+        .catch((e) => { localSharedImportMapPromise = undefined; throw e; });
+    }
     return localSharedImportMapPromise
   }
 
   async function getExposesMap() {
-    exposesMapPromise ??= import("${virtualExposesId}").then((mod) => mod.default ?? mod)
+    if (!exposesMapPromise) {
+      exposesMapPromise = retrySharedInit(() => import("${virtualExposesId}"))
+        .then((mod) => mod.default ?? mod)
+        .catch((e) => { exposesMapPromise = undefined; throw e; });
+    }
     return exposesMapPromise
   }
 
@@ -1397,11 +1554,13 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
     initRes.initShareScopeMap('${options.shareScope}', shared);
     initResolve(initRes)
     try {
-      await Promise.all(await initRes.initializeSharing('${options.shareScope}', {
-        strategy: '${options.shareStrategy}',
-        from: "build",
-        initScope
-      }));
+      await retrySharedInit(async () => {
+        await Promise.all(await initRes.initializeSharing('${options.shareScope}', {
+          strategy: '${options.shareStrategy}',
+          from: "build",
+          initScope
+        }));
+      });
     } catch (e) {
       console.error('[Module Federation]', e)
     }
@@ -1683,17 +1842,26 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 		}
 		return patched;
 	}
-	function getBootstrapSource(initSrc, entrySrc) {
-		const remotePreloads = Object.values(getUsedRemotesMap()).flatMap((remotes) => Array.from(remotes)).filter((remote) => remote.includes("/")).sort().map((remote) => `runtime.loadRemote(${JSON.stringify(remote)})`).join(",");
+	function getBootstrapSource(initSrc, entrySrc, useSystemImportFallback = false) {
+		const remotePreloads = Object.entries(getUsedRemotesMap()).flatMap(([remoteKey, remotes]) => Array.from(remotes).filter((remote) => remote !== remoteKey)).sort().map((remote) => `runtime.loadRemote(${JSON.stringify(remote)})`).join(",");
+		const importHelper = useSystemImportFallback ? `const __mfImport = (src) =>
+  globalThis.System && typeof globalThis.System.import === 'function'
+    ? globalThis.System.import(src)
+    : import(src);
+` : "";
+		const importExpression = (src) => useSystemImportFallback ? `__mfImport(${JSON.stringify(src)})` : `import(${JSON.stringify(src)})`;
 		return `${getRuntimeModuleCacheBootstrapCode()}
-(async () => {
-  const { initHost } = await import(${JSON.stringify(initSrc)});
+${importHelper}(async () => {
+  const { initHost } = await ${importExpression(initSrc)};
   const runtime = await initHost();
   const __mfRemotePreloads = [${remotePreloads}];
   await Promise.all(__mfRemotePreloads);
-})().then(() => import(${JSON.stringify(entrySrc)}));
+})().then(() => ${importExpression(entrySrc)});
 `;
 	}
+	function getSystemBootstrapSource(initSrc, entrySrc) {
+		return getBootstrapSource(initSrc, entrySrc, true);
+	}
 	function injectHtml() {
 		return inject === "html" && (htmlFilePath || hasPackageDependency("@sveltejs/kit"));
 	}
@@ -1833,7 +2001,7 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 					const bootstrapRef = this.emitFile({
 						type: "asset",
 						fileName: bootstrapFileName,
-						source: getBootstrapSource(initPath, entrySrc)
+						source: getSystemBootstrapSource(initPath, entrySrc)
 					});
 					const bootstrapPath = viteConfig.base + this.getFileName(bootstrapRef);
 					return scriptTag.replace(entrySrc, bootstrapPath);
@@ -1978,7 +2146,7 @@ function getHmrWsPath(base, hmrPath) {
 	return `${normalizedBase.endsWith("/") ? normalizedBase.slice(0, -1) : normalizedBase}/${normalizedPath.startsWith("/") ? normalizedPath.slice(1) : normalizedPath}`;
 }
 function shouldIgnoreFile(file, options) {
-	return file.includes("/node_modules/") || file.includes("\\node_modules\\") || file.includes(`/${options.virtualModuleDir}/`) || file.includes(`\\${options.virtualModuleDir}\\`) || file.includes("/.vite/") || file.includes("\\.vite\\") || file.includes("/.__mf__temp/") || file.includes("\\.__mf__temp\\") || file.includes("/.mf/") || file.includes("\\.mf\\") || file.includes("/mf-manifest.json") || file.includes("\\mf-manifest.json") || file.includes("/mf-stats.json") || file.includes("\\mf-stats.json");
+	return file.includes("/node_modules/") || file.includes("\\node_modules\\") || file.includes(`/${options.virtualModuleDir}/`) || file.includes(`\\${options.virtualModuleDir}\\`) || file.includes("/.vite/") || file.includes("\\.vite\\") || file.includes("/.mf/") || file.includes("\\.mf\\") || file.includes("/mf-manifest.json") || file.includes("\\mf-manifest.json") || file.includes("/mf-stats.json") || file.includes("\\mf-stats.json");
 }
 function getRemoteHmrWsUrl(server) {
 	const hmr = server.config.server.hmr;
@@ -2019,7 +2187,22 @@ function getStringPreview(value, max = 180) {
 	return rawValue.slice(0, max);
 }
 function isRemoteHmrEnabled(dev) {
-	return typeof dev === "object" && dev !== null && dev.remoteHmr === true;
+	return typeof dev === "object" && dev !== null && !!dev.remoteHmr;
+}
+/**
+* Detects whether the Vite plugin pipeline includes a framework with
+* cross-federation HMR support (a shared runtime proxy that works
+* across module federation boundaries).
+*
+* Currently only React is supported via the shared /@react-refresh proxy.
+*/
+function hasCrossFederationHmr(plugins) {
+	const supportedPlugins = ["vite:react-refresh", "vite:react-swc:refresh"];
+	return plugins.some((p) => supportedPlugins.includes(p.name));
+}
+function resolveHmrStrategy(dev, plugins) {
+	if (typeof dev === "object" && dev !== null && dev.remoteHmr === "full-reload") return "full-reload";
+	return hasCrossFederationHmr(plugins) ? "native" : "full-reload";
 }
 function pluginDevRemoteHmr(options) {
 	return {
@@ -2029,6 +2212,7 @@ function pluginDevRemoteHmr(options) {
 			if (!isRemoteHmrEnabled(options.dev)) return;
 			const isRemote = Object.keys(options.exposes).length > 0;
 			const isHost = Object.keys(options.remotes).length > 0;
+			const strategy = resolveHmrStrategy(options.dev, server.config.plugins);
 			if (isRemote) {
 				const endpointPath = getRemoteHmrPath(server.config.base);
 				const wsUrl = getRemoteHmrWsUrl(server);
@@ -2052,6 +2236,7 @@ function pluginDevRemoteHmr(options) {
 					}));
 				});
 				const broadcast = (file) => {
+					if (strategy === "native") return;
 					if (shouldIgnoreFile(file, options)) return;
 					server.ws.send({
 						type: "custom",
@@ -2116,6 +2301,7 @@ function pluginDevRemoteHmr(options) {
 						}
 						const ws = new WebSocket(metadata.wsUrl, "vite-hmr");
 						ws.onmessage = (rawEvent) => {
+							if (strategy === "native") return;
 							const message = parseRemoteHmrMessage(rawEvent.data);
 							if (!message || message.event !== REMOTE_HMR_EVENT) return;
 							server.ws.send({ type: "full-reload" });
@@ -2140,6 +2326,7 @@ function pluginDevRemoteHmr(options) {
 				};
 				for (const [remoteName, remote] of Object.entries(options.remotes)) connectRemote(remoteName, remote);
 				const triggerHostReload = (file) => {
+					if (strategy === "native") return;
 					if (shouldIgnoreFile(file, options)) return;
 					server.ws.send({ type: "full-reload" });
 				};
@@ -2462,6 +2649,26 @@ function initVirtualModules(command, remoteEntryId) {
 }
 //#endregion
 //#region src/utils/bundleHelpers.ts
+function isOutputChunk$1(chunk) {
+	return chunk.type === "chunk";
+}
+function escapeRegExp(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
@@ -2484,6 +2691,147 @@ function resolveProxyAlias(binding, proxyLocal, code, fullImport, claimedLocals
 		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)) 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(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(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) {
 	for (const [_, fileData] of Object.entries(bundle)) if (filename.replace(/[\[\]]/g, "_").replace(/\.[^/.]+$/, "") === fileData.name || fileData.name === "remoteEntry") return fileData.fileName;
 }
@@ -2653,6 +3001,9 @@ function normalizeNodeModulePath(source) {
 function isNodeModulePath(source) {
 	return source.includes("/node_modules/") || source.includes("\\node_modules\\");
 }
+function filterId(id) {
+	return typeof id === "string" && !id.includes("\0");
+}
 function getMatchingNodeModuleSubpath(source, candidates) {
 	const normalized = normalizeNodeModulePath(source);
 	return [...candidates].sort((a, b) => b.length - a.length).find((candidate) => normalized.includes(`/node_modules/${candidate}/`) || normalized.includes(`/node_modules/${candidate}.`));
@@ -2837,10 +3188,11 @@ const Manifest = () => {
 			alias: remoteKey,
 			entry: "*"
 		})));
-		const shared = Array.from(getUsedShares()).map((shareKey) => {
+		const shared = Array.from(getUsedShares()).flatMap((shareKey) => {
 			const shareItem = getNormalizeShareItem(shareKey);
+			if (!shareItem) return [];
 			const assets = preloadMap[shareKey] || createEmptyAssetMap();
-			return {
+			return [{
 				id: `${name}:${shareKey}`,
 				name: shareKey,
 				version: shareItem.version,
@@ -2856,7 +3208,7 @@ const Manifest = () => {
 						sync: assets.css.sync
 					}
 				}
-			};
+			}];
 		});
 		const exposes = Object.entries(options.exposes).map(([key, value]) => {
 			const formatKey = key.replace("./", "");
@@ -3008,7 +3360,6 @@ function pluginModuleParseEnd_default(excludeFn, options) {
 }
 //#endregion
 //#region src/plugins/pluginProxyRemoteEntry.ts
-const filter$1 = createFilter();
 function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposesId }) {
 	let viteConfig, _command, root;
 	return {
@@ -3048,14 +3399,14 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		},
 		transform(code, id) {
 			return mapCodeToCodeWithSourcemap((() => {
-				if (!filter$1(id)) return;
+				if (!filterId(id)) return;
 				if (id.includes(remoteEntryId)) return parsePromise.then((_) => generateRemoteEntry(options, virtualExposesId, _command));
 				if (id === virtualExposesId) return generateExposes(options);
 				if (id.includes(getHostAutoInitPath())) {
 					if (_command === "serve") {
 						const host = typeof viteConfig.server?.host === "string" && viteConfig.server.host !== "0.0.0.0" ? viteConfig.server.host : "localhost";
 						const publicPath = JSON.stringify(resolvePublicPath(options, viteConfig.base) + options.filename);
-						const fallbackOrigin = `http://${host}:${viteConfig.server?.port}`;
+						const fallbackOrigin = `//${host}:${viteConfig.server?.port}`;
 						const ssrRemoteEntry = "data:text/javascript," + encodeURIComponent("export async function init(){return {loadRemote:async()=>({}),loadShare:async()=>({})}}");
 						return `
           const origin = typeof window !== 'undefined' && (${!options.ignoreOrigin}) ? window.origin : ${JSON.stringify(fallbackOrigin)};
@@ -3106,10 +3457,25 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 }
 //#endregion
 //#region src/plugins/pluginProxyRemotes.ts
-const filter = createFilter();
 function isNodeModulesImporter(importer) {
 	return importer?.includes("/node_modules/") || importer?.includes("\\node_modules\\");
 }
+function appendAlias(config, alias) {
+	config.resolve ??= {};
+	const existingAlias = config.resolve.alias;
+	if (!existingAlias) {
+		config.resolve.alias = [alias];
+		return;
+	}
+	if (Array.isArray(existingAlias)) {
+		existingAlias.push(alias);
+		return;
+	}
+	config.resolve.alias = [...Object.entries(existingAlias).map(([find, replacement]) => ({
+		find,
+		replacement
+	})), alias];
+}
 function pluginProxyRemotes_default(options) {
 	let command;
 	let root = process.cwd();
@@ -3126,19 +3492,20 @@ function pluginProxyRemotes_default(options) {
 	}
 	return {
 		name: "proxyRemotes",
+		enforce: "pre",
 		config(config, { command: _command }) {
 			command = _command;
 			root = config.root || process.cwd();
 			Object.keys(remotes).forEach((key) => {
 				const remote = remotes[key];
-				config.resolve.alias.push({
+				appendAlias(config, {
 					find: new RegExp(`^(${remote.name}(\/.*|$))`),
 					replacement: "$1"
 				});
 			});
 		},
 		resolveId(source, importer) {
-			if (!filter(source)) return;
+			if (!filterId(source)) return;
 			for (const remote of Object.values(remotes)) {
 				if (source !== remote.name && !source.startsWith(`${remote.name}/`)) continue;
 				return resolveRemoteId(source, importer, remote.name);
@@ -3239,7 +3606,7 @@ function excludeSharedSubDependencies(shared) {
 		for (const dep of deps) {
 			const depKey = sharedKeyByBase.get(dep);
 			if (depKey && depKey !== parentKey) {
-				if (shared[depKey]?.shareConfig.import === false) continue;
+				if (shared[depKey]?.shareConfig.singleton === true || shared[depKey]?.shareConfig.import === false) continue;
 				mfWarn(`"${dep}" is a dependency of shared package "${parentKey}" and is also shared separately. This may cause initialization order issues in dev mode. Consider sharing only "${parentKey}".\n  Auto-excluding "${dep}" from shared modules for dev mode.`);
 				delete shared[depKey];
 				sharedKeys.delete(depKey);
@@ -3255,15 +3622,27 @@ function proxySharedModule(options) {
 	let useDirectReactImport = false;
 	let useRolldown = false;
 	const savePrebuild = new PromiseStore();
+	let devServer;
 	return [
 		{
 			name: "generateLocalSharedImportMap",
 			enforce: "post",
+			configureServer(server) {
+				devServer = server;
+				setLocalSharedImportMapInvalidator(() => {
+					const module = server.moduleGraph.getModuleById(getResolvedLocalSharedImportMapId());
+					if (module) server.moduleGraph.invalidateModule(module);
+				});
+			},
+			resolveId(source) {
+				if (source === getLocalSharedImportMapPath()) return getResolvedLocalSharedImportMapId();
+			},
 			load(id) {
-				if (id.includes(getLocalSharedImportMapPath())) return parsePromise.then((_) => generateLocalSharedImportMap());
+				if (id === getResolvedLocalSharedImportMapId()) return parsePromise.then((_) => generateLocalSharedImportMap());
 			},
-			transform(_, id) {
-				if (id.includes(getLocalSharedImportMapPath())) return mapCodeToCodeWithSourcemap(parsePromise.then((_) => generateLocalSharedImportMap()));
+			closeBundle() {
+				if (devServer) return;
+				setLocalSharedImportMapInvalidator(void 0);
 			}
 		},
 		{
@@ -3394,7 +3773,7 @@ function wrapDynamicImport(original) {
 }
 function applyRewrites(code, imports, id) {
 	if (imports.length === 0) return;
-	const ms = new MagicString(code);
+	const ms = new CodeRewriter(code);
 	let changed = false;
 	let counter = 0;
 	for (const imp of imports) switch (imp.kind) {
@@ -3442,7 +3821,7 @@ function applyRewrites(code, imports, id) {
 	if (!changed) return;
 	return {
 		code: ms.toString(),
-		map: ms.generateMap({ hires: true })
+		map: ms.generateMap(id)
 	};
 }
 async function collectFromAST(ast, code, isRemoteImport) {
@@ -3884,6 +4263,9 @@ function ignoreFederationGeneratedFiles(config, options) {
 function isSharedResolverInternalImporter(importer) {
 	return !!importer && (importer.includes("__loadShare__") || importer.includes("__prebuild__"));
 }
+function isCommonJsImporter(importer) {
+	return !!importer && (importer.endsWith(".cjs") || importer.includes("/cjs/"));
+}
 function isOutputChunk(chunk) {
 	return chunk.type === "chunk";
 }
@@ -3967,9 +4349,10 @@ function createEarlyVirtualModulesPlugin(options) {
 						optimizeDeps.rolldownOptions.plugins ??= [];
 						optimizeDeps.rolldownOptions.plugins.push({
 							name: "module-federation:optimize-shared-resolver",
-							resolveId(source, importer) {
+							resolveId(source, importer, options) {
+								if (options?.kind?.startsWith("require")) return;
 								if (isSharedResolverInternalImporter(importer)) return;
-								if (source !== "react/jsx-runtime" && source !== "react/jsx-dev-runtime") return;
+								if (isCommonJsImporter(importer)) return;
 								const key = findSharedKey(source, shared);
 								if (!key) return;
 								if (source.endsWith(".css")) return;
@@ -4280,87 +4663,17 @@ function federation(mfUserOptions) {
 					if (!isFederationControlChunk(fileName, filename)) continue;
 					chunk.code = sanitizeFederationControlChunk(chunk.code, fileName, filename);
 				}
-				const proxyChunks = /* @__PURE__ */ new Map();
-				for (const [fileName, chunk] of Object.entries(bundle)) {
-					if (!isOutputChunk(chunk)) continue;
-					if (fileName.includes("__loadShare__") && fileName.includes("commonjs-proxy")) proxyChunks.set(fileName, {
-						code: chunk.code,
-						fileName
-					});
-				}
-				if (proxyChunks.size > 0) for (const [fileName, chunk] of Object.entries(bundle)) {
-					if (!isOutputChunk(chunk)) continue;
-					if (fileName.includes("__loadShare__")) continue;
-					let code = chunk.code;
-					let modified = false;
-					const claimedLocals = /* @__PURE__ */ new Set();
-					for (const [proxyFileName, proxyInfo] of Array.from(proxyChunks.entries())) {
-						const proxyBaseName = proxyFileName.replace(/^.*\//, "").replace(/\.js$/, "").replace(/-[A-Za-z0-9_-]+$/, "");
-						const importMatch = new RegExp(`import\\s*\\{([^}]+)\\}\\s*from\\s*["']([^"']*${proxyBaseName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[^"']*)["']\\s*;?`).exec(code);
-						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 proxyCode = proxyInfo.code;
-						const exportMapMatch = proxyCode.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 funcRe = new RegExp(`function\\s+${proxyLocal}\\s*\\([^)]*\\)\\s*\\{`);
-							if (funcRe.test(proxyCode)) {
-								const funcStart = proxyCode.search(funcRe);
-								let depth = 0;
-								let funcEnd = funcStart;
-								for (let i = proxyCode.indexOf("{", funcStart); i < proxyCode.length; i++) if (proxyCode[i] === "{") depth++;
-								else if (proxyCode[i] === "}") {
-									depth--;
-									if (depth === 0) {
-										funcEnd = i + 1;
-										break;
-									}
-								}
-								const renamedFunc = proxyCode.slice(funcStart, funcEnd).replace(new RegExp(`function\\s+${proxyLocal}\\s*\\(`), `function ${b.local}(`);
-								inlineable.push({
-									local: b.local,
-									funcBody: renamedFunc
-								});
-								claimedLocals.add(b.local);
-							} else {
-								const unavailableLocals = new Set(claimedLocals);
-								pendingLocals.forEach((local) => unavailableLocals.add(local));
-								const resolvedBinding = resolveProxyAlias(b, proxyLocal, code, 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("");
-						code = code.replace(fullImport, () => replacement);
-						modified = true;
+				const proxyChunks = collectLoadShareProxyChunks(bundle, LOAD_SHARE_TAG);
+				if (proxyChunks.size > 0) {
+					const systemProxyInfo = collectSystemProxyInfos(proxyChunks, LOAD_SHARE_TAG);
+					for (const [fileName, chunk] of Object.entries(bundle)) {
+						if (!isOutputChunk(chunk)) continue;
+						if (proxyChunks.has(fileName)) continue;
+						let code = chunk.code;
+						if (!fileName.includes("__loadShare__")) code = rewriteEsmProxyConsumers(code, proxyChunks);
+						code = rewriteSystemProxyConsumers(code, systemProxyInfo);
+						if (code !== chunk.code) chunk.code = code;
 					}
-					if (modified) chunk.code = code;
 				}
 			}
 		},
@@ -4398,12 +4711,14 @@ function federation(mfUserOptions) {
 					find: "@module-federation/runtime",
 					replacement: implementation
 				});
-				config.build = defu(config.build || {}, { commonjsOptions: { strictRequires: "auto" } });
+				config.build ||= {};
+				config.build.commonjsOptions ||= {};
+				config.build.commonjsOptions.strictRequires ??= "auto";
 				const virtualDir = options.virtualModuleDir;
 				config.optimizeDeps ||= {};
 				config.optimizeDeps.include ||= [];
 				config.optimizeDeps.include.push("@module-federation/runtime");
-				config.optimizeDeps.include.push(virtualDir);
+				if (!isRolldown) config.optimizeDeps.include.push(virtualDir);
 				config.ssr ||= {};
 				config.ssr.noExternal ||= [];
 				if (Array.isArray(config.ssr.noExternal)) config.ssr.noExternal.push(virtualDir);
@@ -4411,11 +4726,12 @@ function federation(mfUserOptions) {
 					const pluginPath = typeof p === "string" ? p : p[0];
 					if (pluginPath && !pluginPath.startsWith(".") && !pluginPath.startsWith("/") && !pluginPath.startsWith("\0") && !pluginPath.startsWith("virtual:")) config.optimizeDeps.include.push(pluginPath);
 				});
-				if (isRolldown) config.build = defu(config.build || {}, { target: "esnext" });
-				else {
+				if (isRolldown) {
+					config.build ??= {};
+					config.build.target ??= "esnext";
+				} else {
 					config.optimizeDeps.needsInterop ||= [];
 					config.optimizeDeps.needsInterop.push(virtualDir);
-					config.optimizeDeps.needsInterop.push(getLocalSharedImportMapPath());
 				}
 				const isAstro = hasPackageDependency("astro");
 				const resolvedTarget = options.target ?? (config.build?.ssr ? "node" : "web");