@module-federation/vite 1.15.1 → 1.15.3

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, readFileSync, readdirSync, realpathSync, statSync, 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 path, { basename } from "pathe";
 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";
+import { init, parse } 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
@@ -401,7 +524,7 @@ function normalizeShareItem(key, shareItem) {
 		shareConfig: {
 			import: shareItem.import,
 			singleton: shareItem.singleton || false,
-			requiredVersion: shareItem.requiredVersion || (version ? `^${version}` : "*"),
+			requiredVersion: shareItem.requiredVersion || (isImportFalse ? "*" : version ? `^${version}` : "*"),
 			strictVersion: !!shareItem.strictVersion
 		}
 	};
@@ -518,35 +641,6 @@ function normalizeModuleFederationOptions(options) {
 }
 //#endregion
 //#region src/utils/VirtualModule.ts
-/**
-* Initialize virtual module infrastructure BEFORE VirtualModule class is used.
-* This must be called in the config hook to ensure the directory exists
-* before Vite's optimization phase.
-*/
-function initVirtualModuleInfrastructure(root, virtualModuleDir = "__mf__virtual") {
-	const virtualPackagePath = join(join(root, "node_modules"), virtualModuleDir);
-	mkdirSync(virtualPackagePath, { recursive: true });
-	writeFileSync(join(virtualPackagePath, "empty.js"), "");
-	writeFileSync(join(virtualPackagePath, "package.json"), JSON.stringify({
-		name: virtualModuleDir,
-		main: "empty.js"
-	}));
-}
-let rootDir;
-function findNodeModulesDir(root = process.cwd()) {
-	let currentDir = root;
-	while (currentDir !== parse(currentDir).root) {
-		const nodeModulesPath = join(currentDir, "node_modules");
-		if (existsSync(nodeModulesPath)) return nodeModulesPath;
-		currentDir = dirname(currentDir);
-	}
-	return "";
-}
-let cachedNodeModulesDir;
-function getNodeModulesDir() {
-	if (!cachedNodeModulesDir) cachedNodeModulesDir = findNodeModulesDir(rootDir);
-	return cachedNodeModulesDir;
-}
 function getSuffix(name) {
 	const base = basename(name);
 	const dotIndex = base.lastIndexOf(".");
@@ -555,9 +649,6 @@ function getSuffix(name) {
 }
 const patternMap = {};
 const cacheMap = {};
-/**
-* Physically generate files as virtual modules under node_modules/__mf__virtual/*
-*/
 function assertModuleFound(tag, str = "") {
 	const module = VirtualModule.findModule(tag, str);
 	if (!module) throw createModuleFederationError(`Module Federation shared module '${str}' not found. Please ensure it's installed as a dependency in your package.json.`);
@@ -568,33 +659,16 @@ var VirtualModule = class {
 	tag;
 	suffix;
 	inited = false;
-	/**
-	* Set the root path for finding node_modules
-	* @param root - Root path
-	*/
-	static setRoot(root) {
-		rootDir = root;
-		cachedNodeModulesDir = void 0;
-	}
-	/**
-	* Ensure virtual package directory exists
-	*/
-	static ensureVirtualPackageExists() {
-		const nodeModulesDir = getNodeModulesDir();
-		const { virtualModuleDir } = getNormalizeModuleFederationOptions();
-		const virtualPackagePath = resolve(nodeModulesDir, virtualModuleDir);
-		mkdirSync(virtualPackagePath, { recursive: true });
-		writeFileSync(resolve(virtualPackagePath, "empty.js"), "");
-		writeFileSync(resolve(virtualPackagePath, "package.json"), JSON.stringify({
-			name: virtualModuleDir,
-			main: "empty.js"
-		}));
-	}
+	code;
 	static findModule(tag, str = "") {
 		if (!patternMap[tag]) patternMap[tag] = new RegExp(`(.*${packageNameEncode(tag)}(.+?)${packageNameEncode(tag)}.*)`);
 		const moduleName = (str.match(patternMap[tag]) || [])[2];
 		if (moduleName) return cacheMap[tag][packageNameDecode(moduleName)];
 	}
+	static findById(id) {
+		const normalized = id.replace(/^\0+/, "").replace(/^\/@id\//, "").replace(/^__x00__/, "").replace(/[?#].*$/, "");
+		for (const modules of Object.values(cacheMap)) for (const module of Object.values(modules)) if (module.getImportId() === normalized) return module;
+	}
 	constructor(name, tag = "__mf_v__", suffix = "") {
 		this.name = name;
 		this.tag = tag;
@@ -602,128 +676,23 @@ var VirtualModule = class {
 		if (!cacheMap[this.tag]) cacheMap[this.tag] = {};
 		cacheMap[this.tag][this.name] = this;
 	}
-	getPath() {
-		return resolve(getNodeModulesDir(), this.getImportId());
-	}
 	getImportId() {
-		const { internalName: mfName, virtualModuleDir } = getNormalizeModuleFederationOptions();
-		return `${virtualModuleDir}/${packageNameEncode(`${mfName}${this.tag}${this.name}${this.tag}`)}${this.suffix}`;
+		const { internalName: mfName } = getNormalizeModuleFederationOptions();
+		return `virtual:mf:${packageNameEncode(`${mfName}${this.tag}${this.name}${this.tag}`)}${this.suffix}`;
+	}
+	getResolvedId() {
+		return `\0${this.getImportId()}`;
 	}
 	writeSync(code, force) {
 		if (!force && this.inited) return;
 		if (!this.inited) this.inited = true;
-		const path = this.getPath();
-		mkdirSync(dirname(path), { recursive: true });
-		writeFileSync(path, code);
+		this.code = code;
 	}
 	write(code) {
-		const path = this.getPath();
-		mkdirSync(dirname(path), { recursive: true });
-		writeFile(path, code, function() {});
+		this.writeSync(code, true);
 	}
 };
 //#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 +823,99 @@ 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 getRuntimeInitPromiseBootstrapCode() {
+	return getRuntimeInitStateBootstrapCode({
+		globalKeyVar: "__mfPromiseGlobalKey",
+		stateVar: "__mfPromiseState",
+		exposedConst: "initPromise",
+		exposedProperty: "initPromise"
+	});
+}
+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 +1058,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 +1082,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;
@@ -1067,6 +1143,16 @@ function writePreBuildLibPath(pkg, shareItem) {
     export const jsx = __mfPrebuildExports.jsx;
     export const jsxs = __mfPrebuildExports.jsxs;
     export default __mfPrebuildExports;
+  `, true);
+		return;
+	}
+	const namedExports = getPackageNamedExports(pkg);
+	if (namedExports.length > 0) {
+		preBuildCacheMap[pkg].writeSync(`
+    import * as __mfPrebuildNamespace from ${escapeGeneratedStringLiteral(importSource)};
+    const __mfPrebuildExports = __mfPrebuildNamespace;
+    ${namedExports.map((name) => `export const ${name} = __mfPrebuildExports[${escapeGeneratedStringLiteral(name)}];`).join("\n    ")}
+    export default __mfPrebuildExports;
   `, true);
 		return;
 	}
@@ -1094,25 +1180,62 @@ function getLoadShareImportId(pkg, _isRolldown) {
 }
 function getLoadShareModulePath(pkg, isRolldown) {
 	if (!loadShareCacheMap[pkg]) getLoadShareImportId(pkg, isRolldown);
-	return loadShareCacheMap[pkg].getPath();
+	return loadShareCacheMap[pkg].getImportId();
 }
+function generateDeferredHostProvidedExports(namedExports, pkg) {
+	const namedExportVars = namedExports.map((_name, i) => `__mf_${i}`);
+	const declarations = ["let __mf_default;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ");
+	const assignments = [...namedExports.map((name, i) => `${namedExportVars[i]} = exportModule[${escapeGeneratedStringLiteral(name)}];`), "__mf_default = exportModule.default ?? exportModule;"].join("\n      ");
+	const namedExportLine = namedExports.length > 0 ? `\n    export { ${namedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : "";
+	return `${declarations}
+    const __mfApplyHostProvidedExports = (exportModule) => {
+      ${assignments}
+    };
+    let exportModule = __mfModuleCache.share[${escapeGeneratedStringLiteral(pkg)}];
+    if (exportModule === undefined) {
+      initPromise.then(() => {
+        exportModule = __mfModuleCache.share[${escapeGeneratedStringLiteral(pkg)}];
+        if (exportModule === undefined) {
+          throw new Error("[Module Federation] Shared module ${pkg} was imported before federation bootstrap finished.");
+        }
+        __mfApplyHostProvidedExports(exportModule);
+      });
+    } else {
+      __mfApplyHostProvidedExports(exportModule);
+    }
+    export { __mf_default as default };${namedExportLine}`;
+}
+function generateShareModuleUnwrapCode({ source, preserveNamedExports, stopWithReturn }) {
+	return `let current = ${source};
+      for (let i = 0; i < 5; i++) {
+        const defaultExport = current?.default;
+        ${stopWithReturn ? `if (!defaultExport || typeof defaultExport !== "object") return ${stopWithReturn};` : `if (!defaultExport || typeof defaultExport !== "object") break;`}${preserveNamedExports ? `
+        const namedValues = Object.keys(current).filter((key) => key !== "default").map((key) => current[key]);
+        if (namedValues.length > 0 && namedValues.some((value) => value !== undefined)) break;` : ""}
+        current = defaultExport;
+      }
+      return current;`;
+}
+const normalizeLocalShareModuleCode = `const __mfNormalizeShareModule = (mod) => {
+      ${generateShareModuleUnwrapCode({
+	source: "mod",
+	preserveNamedExports: true
+})}
+    };`;
 function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
 	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = new VirtualModule(pkg, LOAD_SHARE_TAG, ".mjs");
 	const importLine = getRuntimeModuleCacheBootstrapCode();
 	if (shareItem.shareConfig.import === false) {
 		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(", ")} };`}`;
+		if (namedExports.length > 0) exportLine = generateDeferredHostProvidedExports(namedExports, pkg);
 		else {
 			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 = "export default exportModule.default ?? exportModule";
+			exportLine = generateDeferredHostProvidedExports([], pkg);
 		}
 		loadShareCacheMap[pkg].writeSync(`
+    ${getRuntimeInitPromiseBootstrapCode()}
     ${importLine}
-    const exportModule = __mfModuleCache.share[${escapeGeneratedStringLiteral(pkg)}]
-    if (exportModule === undefined) {
-      throw new Error("[Module Federation] Shared module ${pkg} was imported before federation bootstrap finished.")
-    }
     ${exportLine}
   `, true);
 		return;
@@ -1124,21 +1247,35 @@ 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(", ")} };`}`;
+	if (namedExports.length > 0) {
+		const destructure = `const { ${namedExports.map((name, i) => `${name}: __mf_${i}`).join(", ")} } = exportModule;`;
+		const namedExportLine = `export { ${namedExports.map((name, i) => `__mf_${i} as ${name}`).join(", ")} };`;
+		exportLine = `const __mfDefaultExport = (() => {
+      ${generateShareModuleUnwrapCode({
+			source: "exportModule",
+			preserveNamedExports: false,
+			stopWithReturn: "defaultExport ?? current"
+		})}
+    })();
+    export default __mfDefaultExport;
+    ${destructure}
+    ${namedExportLine}`;
+	} 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(`
     ${prebuildImportLine}
     ${devDynamicImportLine}
     ${importLine}
+    ${normalizeLocalShareModuleCode}
     let exportModule = __mfModuleCache.share[${escapeGeneratedStringLiteral(pkg)}]
     if (exportModule === undefined) {
-      ${usesLazyLocalFallback ? `exportModule = await import(${escapeGeneratedStringLiteral(lazyLocalFallbackSource)});
-      __mfModuleCache.share[${escapeGeneratedStringLiteral(pkg)}] = exportModule;` : `exportModule = __mfLocalShare;
+      ${usesLazyLocalFallback ? `exportModule = __mfNormalizeShareModule(await import(${escapeGeneratedStringLiteral(lazyLocalFallbackSource)}));
+      __mfModuleCache.share[${escapeGeneratedStringLiteral(pkg)}] = exportModule;` : `exportModule = __mfNormalizeShareModule(__mfLocalShare);
       __mfModuleCache.share[${escapeGeneratedStringLiteral(pkg)}] = exportModule;`}
     }
     ${exportLine}
@@ -1153,15 +1290,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() {
@@ -1287,9 +1433,9 @@ function getShareItemForPreload(pkg) {
 function generateSharedCacheSeedItem(pkg, importPath) {
 	return `if (__mfModuleCache.share[${JSON.stringify(pkg)}] === undefined) {
         const mod = await import(${JSON.stringify(importPath)});
-        const exportModule = ${JSON.stringify(shouldUseDirectReactImport())} && ${JSON.stringify(pkg)} === "react"
-          ? (mod?.default ?? mod)
-          : {...mod};
+        ${normalizeRuntimeShareCode}
+        const normalizedModule = __mfNormalizeRuntimeShare(mod);
+        const exportModule = normalizedModule === mod ? {...mod} : normalizedModule;
         Object.defineProperty(exportModule, "__esModule", {
           value: true,
           enumerable: false
@@ -1297,6 +1443,17 @@ function generateSharedCacheSeedItem(pkg, importPath) {
         __mfModuleCache.share[${JSON.stringify(pkg)}] = exportModule;
       }`;
 }
+const normalizeRuntimeShareCode = `const __mfNormalizeRuntimeShare = (mod) => {
+            let current = mod;
+            for (let i = 0; i < 5; i++) {
+              const defaultExport = current?.default;
+              if (!defaultExport || typeof defaultExport !== "object") break;
+              const namedValues = Object.keys(current).filter((key) => key !== "default").map((key) => current[key]);
+              if (namedValues.length > 0 && namedValues.some((value) => value !== undefined)) break;
+              current = defaultExport;
+            }
+            return current;
+          };`;
 function generateDirectSharedCacheSeedCode(command = "build") {
 	return getOrderedUsedShares().map((pkg) => {
 		const shareItem = getShareItemForPreload(pkg);
@@ -1319,7 +1476,8 @@ function getHostAutoInitSharedSeedItems() {
 		return priority(a.pkg) - priority(b.pkg) || Number(aIsLocal) - Number(bIsLocal) || a.pkg.localeCompare(b.pkg);
 	});
 }
-function generateHostAutoInitSharedCacheSeedCode() {
+function generateHostAutoInitSharedCacheSeedCode(command = "build") {
+	if (command === "build") return "";
 	return getHostAutoInitSharedSeedItems().map(({ pkg, shareItem }) => {
 		if (!shareItem) return null;
 		return generateSharedCacheSeedItem(pkg, getBrowserImportPath(getDirectSharedCacheSeedImportPath(pkg, shareItem)));
@@ -1351,43 +1509,62 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   if (typeof __VUE_HMR_RUNTIME__ === 'undefined') {
     globalThis.__VUE_HMR_RUNTIME__ = { createRecord() {}, rerender() {}, reload() {} };
   }
-  import {createInstance, loadRemote} from "@module-federation/runtime";
+  import {init as runtimeInit, loadRemote} from "@module-federation/runtime";
   ${pluginImportNames.map((item) => item[1]).join("\n")}
   ${command === "build" ? getRuntimeInitResolveBootstrapCode() : getRuntimeInitBootstrapCode() + "\n  const { initResolve } = globalThis[globalKey];"}
   ${getRuntimeModuleCacheBootstrapCode()}
   const initTokens = {}
   const shareScopeName = ${JSON.stringify(options.shareScope)}
   const mfName = ${JSON.stringify(options.internalName)}
-  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
   }
 
   async function init(shared = {}, initScope = []) {
     const {usedShared, usedRemotes} = await getLocalSharedImportMap()
     ${generateDirectSharedCacheSeedCode(command)}
-    const runtimeOptions = {
+    const initRes = runtimeInit({
       name: mfName,
       remotes: usedRemotes,
       shared: usedShared,
       plugins: [${pluginImportNames.map((item) => `${item[0]}(${item[2]})`).join(", ")}],
       ${options.shareStrategy ? `shareStrategy: '${options.shareStrategy}'` : ""}
-    };
-    if (!runtimeInstance) {
-      runtimeInstance = createInstance(runtimeOptions);
-    } else {
-      runtimeInstance.initOptions(runtimeOptions);
-    }
-    const initRes = runtimeInstance;
+    });
     // handling circular init calls
     var initToken = initTokens[shareScopeName];
     if (!initToken)
@@ -1397,14 +1574,27 @@ 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)
     }
+    for (const [pkg, share] of Object.entries(usedShared)) {
+      if (share.shareConfig?.import !== false || __mfModuleCache.share[pkg] !== undefined) continue;
+      ${normalizeRuntimeShareCode}
+      const versions = shared?.[pkg];
+      const provider = versions && versions[Object.keys(versions)[0]];
+      if (!provider) continue;
+      const factory = provider.lib || (provider.loading ? await provider.loading : await provider.get?.());
+      const mod = typeof factory === "function" ? factory() : factory;
+      const resolved = await Promise.resolve(mod);
+      __mfModuleCache.share[pkg] = __mfNormalizeRuntimeShare(resolved);
+    }
     return initRes
   }
 
@@ -1429,10 +1619,11 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build") {
     async function initHost() {
       if (!hostInitPromise) {
         hostInitPromise = (async () => {
-          ${generateHostAutoInitSharedCacheSeedCode()}
+          ${generateHostAutoInitSharedCacheSeedCode(_command)}
           const remoteEntry = await import(${remoteEntryImport});
           const runtime = await remoteEntry.init();
           const usedShared = ${generateUsedSharedPreloadConfig()};
+          ${normalizeRuntimeShareCode}
           for (const [pkg, share] of Object.entries(usedShared)) {
             if (__mfModuleCache.share[pkg] !== undefined) {
               continue;
@@ -1442,7 +1633,7 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build") {
             }).then((factory) => {
               const mod = typeof factory === "function" ? factory() : factory;
               return Promise.resolve(mod).then((resolved) => {
-                __mfModuleCache.share[pkg] = resolved;
+                __mfModuleCache.share[pkg] = __mfNormalizeRuntimeShare(resolved);
               });
             });
           }
@@ -1471,7 +1662,7 @@ function getHostAutoInitImportId() {
 	return hostAutoInitModule.getImportId();
 }
 function getHostAutoInitPath() {
-	return hostAutoInitModule.getPath();
+	return hostAutoInitModule.getImportId();
 }
 //#endregion
 //#region src/virtualModules/virtualRemotes.ts
@@ -1494,7 +1685,9 @@ function getUsedRemotesMap() {
 }
 function generateRemotes(id, command) {
 	const useReactProxy = command === "serve" && hasPackageDependency("react");
-	const reactImportLine = useReactProxy ? `import * as __mfReact from "react";` : "";
+	const reactImportLine = useReactProxy ? `import __mfReactDefault from "react";
+    import * as __mfReactNamespace from "react";
+    const __mfReact = __mfReactDefault ?? __mfReactNamespace.default ?? __mfReactNamespace;` : "";
 	const importLine = command === "build" ? `${getRuntimeModuleCacheBootstrapCode()}
     import { hostInitPromise as __mfHostInitPromise } from ${JSON.stringify(getHostAutoInitPath())};` : `${getRuntimeInitBootstrapCode()}
     const { initPromise, moduleCache: __mfModuleCache } = globalThis[globalKey];`;
@@ -1504,13 +1697,13 @@ function generateRemotes(id, command) {
 }
 export const __moduleExports = exportModule;
 export const __mf_remote_pending = Promise.resolve(exportModule);
-export default exportModule?.__esModule ? exportModule.default : exportModule.default ?? exportModule` : command === "build" ? `if (__mfRemotePending) {
+export default exportModule?.__mf_is_remote_proxy ? exportModule : exportModule?.__esModule ? exportModule.default : exportModule.default ?? exportModule` : command === "build" ? `if (__mfRemotePending) {
   const mod = await __mfRemotePending;
   if (mod !== undefined) exportModule = mod;
 }
 export const __moduleExports = exportModule;
 export const __mf_remote_pending = Promise.resolve(exportModule);
-export default exportModule?.__esModule ? exportModule.default : exportModule.default ?? exportModule` : "export default exportModule";
+export default exportModule?.__mf_is_remote_proxy ? exportModule : exportModule?.__esModule ? exportModule.default : exportModule.default ?? exportModule` : "export default exportModule";
 	return `
     ${reactImportLine}
     ${importLine}
@@ -1683,17 +1876,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"));
 	}
@@ -1701,6 +1903,9 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 		if (inject === "html" && hasPackageDependency("@sveltejs/kit")) return false;
 		return inject === "entry" || !htmlFilePath;
 	}
+	function normalizeDevHtmlProxyId(id) {
+		return id.replace(/^\0/, "").replace(/^\/@id\//, "").replace(/^__x00__/, "");
+	}
 	return [{
 		name: "add-entry",
 		apply: "serve",
@@ -1719,7 +1924,20 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 			}
 		},
 		configureServer(server) {
-			server.middlewares.use((req, _res, next) => {
+			server.middlewares.use((req, res, next) => {
+				const rawUrl = req.url?.split("#")[0] ?? "";
+				if (normalizeDevHtmlProxyId(rawUrl.split("?")[0]) === DEV_HTML_PROXY_PREFIX.slice(0, -1)) {
+					const query = rawUrl.slice(rawUrl.indexOf("?") + 1);
+					const params = new URLSearchParams(query);
+					const initSrc = params.get("init");
+					const entrySrc = params.get("entry");
+					if (initSrc && entrySrc) {
+						res.statusCode = 200;
+						res.setHeader("Content-Type", "application/javascript");
+						res.end(getBootstrapSource(initSrc, entrySrc));
+						return;
+					}
+				}
 				if (!fileName) {
 					next();
 					return;
@@ -1736,7 +1954,7 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 				const base = viteConfig.base.replace(/\/$/, "");
 				const stripBase = (p) => base && p.startsWith(base + "/") ? p.slice(base.length) : p;
 				const html = rewriteEntryScripts(c, (originalSrc) => {
-					return `/@id/${DEV_HTML_PROXY_PREFIX}${new URLSearchParams({
+					return `/@id/__x00__${DEV_HTML_PROXY_PREFIX}${new URLSearchParams({
 						init: sanitizeDevEntryPath(stripBase(devEntryPath)),
 						entry: sanitizeDevEntryPath(stripBase(originalSrc))
 					}).toString()}`;
@@ -1745,11 +1963,12 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 			}
 		},
 		resolveId(id) {
-			if (id.startsWith(DEV_HTML_PROXY_PREFIX)) return id;
+			if (normalizeDevHtmlProxyId(id).startsWith(DEV_HTML_PROXY_PREFIX)) return id;
 		},
 		load(id) {
-			if (!id.startsWith(DEV_HTML_PROXY_PREFIX)) return;
-			const params = new URLSearchParams(id.slice(28));
+			const normalizedId = normalizeDevHtmlProxyId(id);
+			if (!normalizedId.startsWith(DEV_HTML_PROXY_PREFIX)) return;
+			const params = new URLSearchParams(normalizedId.slice(28));
 			const initSrc = params.get("init");
 			const entrySrc = params.get("entry");
 			if (!initSrc || !entrySrc) return;
@@ -1833,7 +2052,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 +2197,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 +2238,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 +2263,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 +2287,7 @@ function pluginDevRemoteHmr(options) {
 					}));
 				});
 				const broadcast = (file) => {
+					if (strategy === "native") return;
 					if (shouldIgnoreFile(file, options)) return;
 					server.ws.send({
 						type: "custom",
@@ -2116,6 +2352,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 +2377,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 +2700,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 +2742,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).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(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 +3052,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 +3239,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 +3259,7 @@ const Manifest = () => {
 						sync: assets.css.sync
 					}
 				}
-			};
+			}];
 		});
 		const exposes = Object.entries(options.exposes).map(([key, value]) => {
 			const formatKey = key.replace("./", "");
@@ -3008,7 +3411,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 +3450,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 +3508,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();
@@ -3122,23 +3539,24 @@ function pluginProxyRemotes_default(options) {
 		const remoteModule = getRemoteVirtualModule(source, command);
 		addUsedRemote(remoteName, source);
 		refreshHostAutoInit();
-		return remoteModule.getPath();
+		return remoteModule.getImportId();
 	}
 	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 +3657,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 +3673,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 +3824,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 +3872,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) {
@@ -3511,7 +3941,7 @@ async function collectFromEsLexer(code, isRemoteImport) {
 	await init;
 	let imports;
 	try {
-		[imports] = parse$1(code);
+		[imports] = parse(code);
 	} catch {
 		return;
 	}
@@ -3884,6 +4314,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";
 }
@@ -3928,12 +4361,12 @@ function isFederationHtmlPreloadDependency(dep, includeSharedRuntime = false) {
 	return includeSharedRuntime && (file.includes("preload-helper") || file.includes("rolldown-runtime") || file.startsWith("dist-"));
 }
 /**
-* Plugin that runs FIRST to create virtual module files in the config hook.
-* This prevents 504 "Outdated Optimize Dep" errors by ensuring files exist
+* Plugin that runs FIRST to register generated virtual modules in the config hook.
+* This prevents 504 "Outdated Optimize Dep" errors by ensuring ids are known
 * before Vite's optimization phase.
 */
 function createEarlyVirtualModulesPlugin(options) {
-	const { shared, remotes, virtualModuleDir } = options;
+	const { shared, remotes } = options;
 	const isLitShare = (pkg) => pkg === "lit" || pkg.startsWith("lit/");
 	return {
 		name: "vite:module-federation-early-init",
@@ -3943,9 +4376,6 @@ function createEarlyVirtualModulesPlugin(options) {
 			const root = config.root || process.cwd();
 			setPackageDetectionCwd(root);
 			const isVinext = hasPackageDependency("vinext");
-			initVirtualModuleInfrastructure(root, virtualModuleDir);
-			VirtualModule.setRoot(root);
-			VirtualModule.ensureVirtualPackageExists();
 			initVirtualModules(_command, getRemoteEntryId(options));
 			const isRolldown = getIsRolldown(this);
 			if (remotes && Object.keys(remotes).length > 0) {
@@ -3967,9 +4397,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;
@@ -3990,6 +4421,10 @@ function createEarlyVirtualModulesPlugin(options) {
 						optimizeDeps.esbuildOptions.plugins.push({
 							name: "module-federation:optimize-shared-proxy",
 							setup(build) {
+								build.onResolve({ filter: /^virtual:mf:/ }, (args) => ({
+									path: args.path,
+									external: true
+								}));
 								build.onResolve({ filter: /.*/ }, (args) => {
 									if (!args.importer || args.namespace === "mf-shared") return;
 									if (isSharedResolverInternalImporter(args.importer)) return;
@@ -4021,7 +4456,6 @@ export default __mfShared.default ?? __mfShared;`
 							}
 						});
 					}
-					config.optimizeDeps.include.push(virtualRuntimeInitStatus.getImportId());
 				}
 				for (const key of Object.keys(shared)) {
 					const shareItem = shared[key];
@@ -4032,7 +4466,6 @@ export default __mfShared.default ?? __mfShared;`
 							for (const subpath of getCommonSharedSubpaths(key)) {
 								writePreBuildLibPath(subpath, shareItem);
 								optimizeDeps.include.push(subpath);
-								optimizeDeps.include.push(getPreBuildLibImportId(subpath));
 							}
 						}
 						continue;
@@ -4049,14 +4482,11 @@ export default __mfShared.default ?? __mfShared;`
 						const optimizeDeps = config.optimizeDeps ??= {};
 						optimizeDeps.include ??= [];
 						optimizeDeps.exclude ??= [];
-						const shouldBypassOptimizeDep = isLitShare(key);
-						if (shouldBypassOptimizeDep) optimizeDeps.exclude.push(key);
-						if (!isRolldown && !shouldBypassOptimizeDep) optimizeDeps.include.push(getLoadShareImportId(key, isRolldown));
-						optimizeDeps.include.push(getPreBuildLibImportId(key));
+						if (isLitShare(key)) optimizeDeps.exclude.push(key);
+						else optimizeDeps.include.push(key);
 						for (const subpath of getCommonSharedSubpaths(key)) {
 							writePreBuildLibPath(subpath, shareItem);
 							optimizeDeps.include.push(subpath);
-							optimizeDeps.include.push(getPreBuildLibImportId(subpath));
 						}
 					}
 				}
@@ -4076,6 +4506,21 @@ function federation(mfUserOptions) {
 	let command;
 	let desiredRolldownOutput;
 	return [
+		{
+			name: "vite:module-federation-virtual-modules",
+			enforce: "pre",
+			resolveId(id) {
+				const virtualModule = VirtualModule.findById(id);
+				if (!virtualModule) return;
+				return virtualModule.getResolvedId();
+			},
+			load(id) {
+				const virtualModule = VirtualModule.findById(id);
+				if (!virtualModule) return;
+				if (command === "build" && (id.includes("__loadShare__") || id.includes("__loadRemote__"))) return;
+				return virtualModule.code;
+			}
+		},
 		createEarlyVirtualModulesPlugin(options),
 		...isVinext ? [{
 			name: "module-federation-vinext-react-server-build-alias",
@@ -4100,9 +4545,7 @@ function federation(mfUserOptions) {
 			config(_config, env) {
 				command = env.command;
 			},
-			configResolved(config) {
-				VirtualModule.setRoot(config.root);
-				VirtualModule.ensureVirtualPackageExists();
+			configResolved() {
 				initVirtualModules(command, remoteEntryId);
 			}
 		},
@@ -4245,9 +4688,8 @@ function federation(mfUserOptions) {
 				}
 			},
 			load(id) {
-				if (id.startsWith("\0")) return;
 				if (id.includes("__loadShare__") || id.includes("__loadRemote__")) {
-					let code = readFileSync(id, "utf-8");
+					let code = VirtualModule.findById(id)?.code ?? readFileSync(id, "utf-8");
 					code = code.replace(/import\s+["'][^"']*__prebuild__[^"']*["']\s*;?/g, "");
 					code = code.replace(/export\s+\*\s+from\s+["'][^"']*__prebuild__[^"']*["']\s*;?/g, "");
 					/**
@@ -4266,7 +4708,10 @@ function federation(mfUserOptions) {
 					*
 					* @see https://rollupjs.org/plugin-development/#synthetic-named-exports
 					*/
-					if (!code.includes("__moduleExports")) code = code.replace("export default exportModule", "export const __moduleExports = exportModule;\nexport default exportModule.__esModule ? exportModule.default : exportModule");
+					if (!/\bexport\s+const\s+__moduleExports\b/.test(code)) {
+						const nextCode = code.replace("export default exportModule", "export const __moduleExports = exportModule;\nexport default exportModule.__esModule ? exportModule.default : exportModule");
+						code = nextCode === code ? `${code}\nexport const __moduleExports = exportModule;\n` : nextCode;
+					}
 					if (getIsRolldown(this)) return { code };
 					return {
 						code,
@@ -4280,87 +4725,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,24 +4773,19 @@ function federation(mfUserOptions) {
 					find: "@module-federation/runtime",
 					replacement: implementation
 				});
-				config.build = defu(config.build || {}, { commonjsOptions: { strictRequires: "auto" } });
-				const virtualDir = options.virtualModuleDir;
+				config.build ||= {};
+				config.build.commonjsOptions ||= {};
+				config.build.commonjsOptions.strictRequires ??= "auto";
 				config.optimizeDeps ||= {};
 				config.optimizeDeps.include ||= [];
 				config.optimizeDeps.include.push("@module-federation/runtime");
-				config.optimizeDeps.include.push(virtualDir);
-				config.ssr ||= {};
-				config.ssr.noExternal ||= [];
-				if (Array.isArray(config.ssr.noExternal)) config.ssr.noExternal.push(virtualDir);
 				options.runtimePlugins.forEach((p) => {
 					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 {
-					config.optimizeDeps.needsInterop ||= [];
-					config.optimizeDeps.needsInterop.push(virtualDir);
-					config.optimizeDeps.needsInterop.push(getLocalSharedImportMapPath());
+				if (isRolldown) {
+					config.build ??= {};
+					config.build.target ??= "esnext";
 				}
 				const isAstro = hasPackageDependency("astro");
 				const resolvedTarget = options.target ?? (config.build?.ssr ? "node" : "web");