@module-federation/vite 1.11.1 → 1.12.0

package/lib/index.mjs

@@ -10,6 +10,7 @@ import { walk } from "estree-walker";
 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 { createRequire as createRequire$1 } from "module";
 import { fileURLToPath } from "url";
 
 //#region \0rolldown/runtime.js
@@ -746,6 +747,22 @@ function serializeRuntimeOptions(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);
+	if (!existsSync(virtualPackagePath)) {
+		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;
@@ -834,9 +851,10 @@ var VirtualModule = class {
 
 //#endregion
 //#region src/virtualModules/virtualExposes.ts
-const VIRTUAL_EXPOSES = "virtual:mf-exposes";
-function generateExposes() {
-	const options = getNormalizeModuleFederationOptions();
+function getVirtualExposesId(options) {
+	return `virtual:mf-exposes:${`${options.name}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+}
+function generateExposes(options) {
 	return `
     export default {
     ${Object.keys(options.exposes).map((key) => {
@@ -886,10 +904,10 @@ ${exportStatement}
 //#region src/virtualModules/virtualRemotes.ts
 const cacheRemoteMap = {};
 const LOAD_REMOTE_TAG = "__loadRemote__";
-function getRemoteVirtualModule(remote, command) {
+function getRemoteVirtualModule(remote, command, isRolldown) {
 	if (!cacheRemoteMap[remote]) {
-		cacheRemoteMap[remote] = new VirtualModule(remote, LOAD_REMOTE_TAG, ".js");
-		cacheRemoteMap[remote].writeSync(generateRemotes(remote, command));
+		cacheRemoteMap[remote] = new VirtualModule(remote, LOAD_REMOTE_TAG, isRolldown ? ".mjs" : ".js");
+		cacheRemoteMap[remote].writeSync(generateRemotes(remote, command, isRolldown));
 	}
 	return cacheRemoteMap[remote];
 }
@@ -901,11 +919,11 @@ function addUsedRemote(remoteKey, remoteModule) {
 function getUsedRemotesMap() {
 	return usedRemotesMap;
 }
-function generateRemotes(id, command) {
-	const isBuild = command === "build";
-	const importLine = isBuild ? `import { initPromise } from "${virtualRuntimeInitStatus.getImportId()}"` : `const {initPromise} = require("${virtualRuntimeInitStatus.getImportId()}")`;
-	const awaitOrPlaceholder = isBuild ? "await " : "/*mf top-level-await placeholder replacement mf*/";
-	const exportLine = isBuild ? "export default exportModule" : "module.exports = exportModule";
+function generateRemotes(id, command, isRolldown) {
+	const useESM = command === "build" || isRolldown;
+	const importLine = useESM ? `import { initPromise } from "${virtualRuntimeInitStatus.getImportId()}"` : `const {initPromise} = require("${virtualRuntimeInitStatus.getImportId()}")`;
+	const awaitOrPlaceholder = useESM ? "await " : "/*mf top-level-await placeholder replacement mf*/";
+	const exportLine = command === "serve" && useESM ? "export default exportModule.default ?? exportModule" : useESM ? "export default exportModule" : "module.exports = exportModule";
 	return `
     ${importLine}
     const res = initPromise.then(runtime => runtime.loadRemote(${JSON.stringify(id)}))
@@ -916,6 +934,24 @@ function generateRemotes(id, command) {
 
 //#endregion
 //#region src/virtualModules/virtualShared_preBuild.ts
+/**
+* Even the resolveId hook cannot interfere with vite pre-build,
+* and adding query parameter virtual modules will also fail.
+* You can only proxy to the real file through alias
+*/
+/**
+* shared will be proxied:
+* 1. __prebuild__: export shareModule (pre-built source code of modules such as vue, react, etc.)
+* 2. __loadShare__: load shareModule (mfRuntime.loadShare('vue'))
+*/
+function getPackageNamedExports(pkg) {
+	try {
+		const mod = createRequire$1(new URL("file://" + process.cwd() + "/package.json"))(pkg);
+		return Object.keys(mod).filter((k) => k !== "default" && k !== "__esModule");
+	} catch {
+		return [];
+	}
+}
 const preBuildCacheMap = {};
 const PREBUILD_TAG = "__prebuild__";
 function writePreBuildLibPath(pkg) {
@@ -928,17 +964,24 @@ function getPreBuildLibImportId(pkg) {
 }
 const LOAD_SHARE_TAG = "__loadShare__";
 const loadShareCacheMap = {};
-function getLoadShareModulePath(pkg) {
-	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = new VirtualModule(pkg, LOAD_SHARE_TAG, ".js");
+function getLoadShareModulePath(pkg, isRolldown, command) {
+	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = new VirtualModule(pkg, LOAD_SHARE_TAG, isRolldown || command === "build" ? ".mjs" : ".js");
 	return loadShareCacheMap[pkg].getPath();
 }
-function writeLoadShareModule(pkg, shareItem, command) {
-	const isBuild = command === "build";
-	const importLine = isBuild ? `import { initPromise } from "${virtualRuntimeInitStatus.getImportId()}"` : `const {initPromise} = require("${virtualRuntimeInitStatus.getImportId()}")`;
-	const awaitOrPlaceholder = isBuild ? "await " : "/*mf top-level-await placeholder replacement mf*/";
-	const exportLine = isBuild ? "export default exportModule" : "module.exports = exportModule";
+function writeLoadShareModule(pkg, shareItem, command, isRolldown) {
+	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = new VirtualModule(pkg, LOAD_SHARE_TAG, isRolldown || command === "build" ? ".mjs" : ".js");
+	const useESM = command === "build" || isRolldown;
+	const importLine = useESM ? `import { initPromise } from "${virtualRuntimeInitStatus.getImportId()}"` : `const {initPromise} = require("${virtualRuntimeInitStatus.getImportId()}")`;
+	const awaitOrPlaceholder = useESM ? "await " : "/*mf top-level-await placeholder replacement mf*/";
+	const namedExports = getPackageNamedExports(pkg);
+	let exportLine;
+	if (namedExports.length > 0) {
+		const destructure = `const { ${namedExports.join(", ")} } = exportModule;`;
+		const namedExportLine = `export { ${namedExports.join(", ")} };`;
+		exportLine = useESM ? `export default exportModule;\n    ${destructure}\n    ${namedExportLine}` : `module.exports = exportModule;\n    ${destructure}\n    Object.assign(module.exports, { ${namedExports.join(", ")} });`;
+	} else exportLine = useESM ? `export default exportModule\n    export * from ${JSON.stringify(getPreBuildLibImportId(pkg))}` : "module.exports = exportModule";
 	loadShareCacheMap[pkg].writeSync(`
-    ;() => import(${JSON.stringify(getPreBuildLibImportId(pkg))}).catch(() => {});
+    import ${JSON.stringify(getPreBuildLibImportId(pkg))};
     ${command !== "build" ? `;() => import(${JSON.stringify(pkg)}).catch(() => {});` : ""}
     ${importLine}
     const res = initPromise.then(runtime => runtime.loadShare(${JSON.stringify(pkg)}, {
@@ -948,7 +991,7 @@ function writeLoadShareModule(pkg, shareItem, command) {
         requiredVersion: ${JSON.stringify(shareItem.shareConfig.requiredVersion)}
       }}
     }))
-    const exportModule = ${awaitOrPlaceholder}res.then(factory => factory())
+    const exportModule = ${awaitOrPlaceholder}res.then((factory) => (typeof factory === "function" ? factory() : factory))
     ${exportLine}
   `);
 }
@@ -1047,7 +1090,10 @@ function generateLocalSharedImportMap() {
       `;
 }
 const REMOTE_ENTRY_ID = "virtual:mf-REMOTE_ENTRY_ID";
-function generateRemoteEntry(options) {
+function getRemoteEntryId(options) {
+	return `${REMOTE_ENTRY_ID}:${`${options.name}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+}
+function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(options)) {
 	const pluginImportNames = options.runtimePlugins.map((p, i) => {
 		if (typeof p === "string") return [
 			`$runtimePlugin_${i}`,
@@ -1063,7 +1109,7 @@ function generateRemoteEntry(options) {
 	return `
   import {init as runtimeInit, loadRemote} from "@module-federation/runtime";
   ${pluginImportNames.map((item) => item[1]).join("\n")}
-  import exposesMap from "${VIRTUAL_EXPOSES}"
+  import exposesMap from "${virtualExposesId}"
   import {usedShared, usedRemotes} from "${getLocalSharedImportMapPath()}"
   import {
     initResolve
@@ -1115,9 +1161,9 @@ function generateRemoteEntry(options) {
 */
 const HOST_AUTO_INIT_TAG = "__H_A_I__";
 const hostAutoInitModule = new VirtualModule("hostAutoInit", HOST_AUTO_INIT_TAG);
-function writeHostAutoInit() {
+function writeHostAutoInit(remoteEntryId = REMOTE_ENTRY_ID) {
 	hostAutoInitModule.writeSync(`
-    const remoteEntryPromise = import("${REMOTE_ENTRY_ID}")
+    const remoteEntryPromise = import("${remoteEntryId}")
     // __tla only serves as a hack for vite-plugin-top-level-await.
     Promise.resolve(remoteEntryPromise)
       .then(remoteEntry => {
@@ -1135,9 +1181,9 @@ function getHostAutoInitPath() {
 
 //#endregion
 //#region src/virtualModules/index.ts
-function initVirtualModules(command) {
+function initVirtualModules(command, remoteEntryId) {
 	writeLocalSharedImportMap();
-	writeHostAutoInit();
+	writeHostAutoInit(remoteEntryId);
 	writeRuntimeInitStatus(command);
 }
 
@@ -1544,7 +1590,7 @@ function pluginModuleParseEnd_default(excludeFn, options) {
 			apply: "build",
 			moduleParsed(module) {
 				const id = module.id;
-				if (id === VIRTUAL_EXPOSES) exposesParseEnd = true;
+				if (id === options.virtualExposesId) exposesParseEnd = true;
 				if (excludeFn(id)) return;
 				parseEndSet.add(id);
 				if (exposesParseEnd && parseStartSet.size === parseEndSet.size) _resolve(1);
@@ -1556,7 +1602,7 @@ function pluginModuleParseEnd_default(excludeFn, options) {
 //#endregion
 //#region src/plugins/pluginProxyRemoteEntry.ts
 const filter = createFilter();
-function pluginProxyRemoteEntry_default() {
+function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposesId }) {
 	let viteConfig, _command;
 	return {
 		name: "proxyRemoteEntry",
@@ -1567,28 +1613,37 @@ function pluginProxyRemoteEntry_default() {
 		config(config, { command }) {
 			_command = command;
 		},
+		async buildStart() {
+			if (_command !== "build") return;
+			for (const expose of Object.values(options.exposes)) {
+				const resolved = await this.resolve(expose.import);
+				if (resolved) this.emitFile({
+					type: "chunk",
+					id: resolved.id
+				});
+			}
+		},
 		async resolveId(id, importer) {
-			if (id === REMOTE_ENTRY_ID) return REMOTE_ENTRY_ID;
-			if (id === VIRTUAL_EXPOSES) return VIRTUAL_EXPOSES;
+			if (id === remoteEntryId) return remoteEntryId;
+			if (id === virtualExposesId) return virtualExposesId;
 			if (_command === "serve" && id.includes(getHostAutoInitPath())) return id;
-			if (importer === REMOTE_ENTRY_ID && !id.startsWith(".") && !id.startsWith("/") && !id.startsWith("\0") && !id.startsWith("virtual:")) {
-				typeof __filename === "string" ? __filename : fileURLToPath(import.meta.url);
-				const resolved = await this.resolve(id, __filename, { skipSelf: true });
+			if (importer === remoteEntryId && !id.startsWith(".") && !id.startsWith("/") && !id.startsWith("\0") && !id.startsWith("virtual:")) {
+				const importPath = typeof __filename === "string" ? __filename : fileURLToPath(import.meta.url);
+				const resolved = await this.resolve(id, importPath, { skipSelf: true });
 				if (resolved) return resolved;
 			}
 		},
 		load(id) {
-			if (id === REMOTE_ENTRY_ID) return parsePromise.then((_) => generateRemoteEntry(getNormalizeModuleFederationOptions()));
-			if (id === VIRTUAL_EXPOSES) return generateExposes();
+			if (id === remoteEntryId) return parsePromise.then((_) => generateRemoteEntry(options, virtualExposesId));
+			if (id === virtualExposesId) return generateExposes(options);
 			if (_command === "serve" && id.includes(getHostAutoInitPath())) return id;
 		},
 		transform(code, id) {
 			return mapCodeToCodeWithSourcemap((() => {
 				if (!filter(id)) return;
-				if (id.includes(REMOTE_ENTRY_ID)) return parsePromise.then((_) => generateRemoteEntry(getNormalizeModuleFederationOptions()));
-				if (id === VIRTUAL_EXPOSES) return generateExposes();
+				if (id.includes(remoteEntryId)) return parsePromise.then((_) => generateRemoteEntry(options, virtualExposesId));
+				if (id === virtualExposesId) return generateExposes(options);
 				if (id.includes(getHostAutoInitPath())) {
-					const options = getNormalizeModuleFederationOptions();
 					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);
@@ -1618,13 +1673,14 @@ function pluginProxyRemotes_default(options) {
 	return {
 		name: "proxyRemotes",
 		config(config, { command: _command }) {
+			const isRolldown = !!this?.meta?.rolldownVersion;
 			Object.keys(remotes).forEach((key) => {
 				const remote = remotes[key];
 				config.resolve.alias.push({
 					find: new RegExp(`^(${remote.name}(\/.*|$))`),
 					replacement: "$1",
 					customResolver(source) {
-						const remoteModule = getRemoteVirtualModule(source, _command);
+						const remoteModule = getRemoteVirtualModule(source, _command, isRolldown);
 						addUsedRemote(remote.name, source);
 						return remoteModule.getPath();
 					}
@@ -1671,8 +1727,10 @@ var PromiseStore = class {
 //#endregion
 //#region src/plugins/pluginProxySharedModule_preBuild.ts
 function proxySharedModule(options) {
-	let { shared = {}, include, exclude } = options;
+	const { shared = {} } = options;
 	let _config;
+	let _command = "serve";
+	const savePrebuild = new PromiseStore();
 	return [{
 		name: "generateLocalSharedImportMap",
 		enforce: "post",
@@ -1685,19 +1743,23 @@ function proxySharedModule(options) {
 	}, {
 		name: "proxyPreBuildShared",
 		enforce: "post",
-		configResolved(config) {
-			_config = config;
-		},
 		config(config, { command }) {
+			const isRolldown = !!this?.meta?.rolldownVersion;
+			_command = command;
 			config.resolve.alias.push(...Object.keys(shared).map((key) => {
-				const pattern = key.endsWith("/") ? `(^${key.replace(/\/$/, "")}(\/.+)?$)` : `(^${key}$)`;
+				const keyBase = key.endsWith("/") ? key.slice(0, -1) : key;
+				const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+				const escapedKeyBase = escapeRegex(keyBase);
+				const pattern = key.endsWith("/") ? `^(${escapedKeyBase}(?:\\/.*)?)$` : `^(${escapedKeyBase})$`;
 				return {
 					find: new RegExp(pattern),
 					replacement: "$1",
 					customResolver(source, importer) {
 						if (/\.css$/.test(source)) return;
-						const loadSharePath = getLoadShareModulePath(source);
-						writeLoadShareModule(source, shared[key], command);
+						if (importer && importer.includes("localSharedImportMap")) return;
+						if (key.endsWith("/") && source !== key.slice(0, -1)) return;
+						const loadSharePath = getLoadShareModulePath(source, isRolldown, command);
+						writeLoadShareModule(source, shared[key], command, isRolldown);
 						writePreBuildLibPath(source);
 						addUsedShares(source);
 						writeLocalSharedImportMap();
@@ -1705,7 +1767,6 @@ function proxySharedModule(options) {
 					}
 				};
 			}));
-			const savePrebuild = new PromiseStore();
 			config.resolve.alias.push(...Object.keys(shared).map((key) => {
 				return command === "build" ? {
 					find: new RegExp(`(.*${PREBUILD_TAG}.*)`),
@@ -1718,11 +1779,22 @@ function proxySharedModule(options) {
 					async customResolver(source, importer) {
 						const pkgName = assertModuleFound(PREBUILD_TAG, source).name;
 						const result = await this.resolve(pkgName, importer).then((item) => item.id);
-						if (!result.includes(_config.cacheDir)) savePrebuild.set(pkgName, Promise.resolve(result));
+						if (_config && !result.includes(_config.cacheDir)) savePrebuild.set(pkgName, Promise.resolve(result));
 						return await this.resolve(await savePrebuild.get(pkgName), importer);
 					}
 				};
 			}));
+		},
+		configResolved(config) {
+			_config = config;
+			const isRolldown = !!config.experimental?.rolldownDev;
+			Object.keys(shared).forEach((key) => {
+				if (key.endsWith("/")) return;
+				writeLoadShareModule(key, shared[key], _command, isRolldown);
+				writePreBuildLibPath(key);
+				addUsedShares(key);
+			});
+			writeLocalSharedImportMap();
 		}
 	}];
 }
@@ -1833,20 +1905,60 @@ var normalizeOptimizeDeps_default = {
 			config.optimizeDeps = {};
 			optimizeDeps = config.optimizeDeps;
 		}
-		optimizeDeps.force = true;
 		if (!optimizeDeps.include) optimizeDeps.include = [];
+		if (!optimizeDeps.exclude) optimizeDeps.exclude = [];
 		if (!optimizeDeps.needsInterop) optimizeDeps.needsInterop = [];
 	}
 };
 
 //#endregion
 //#region src/index.ts
+/**
+* Plugin that runs FIRST to create virtual module files in the config hook.
+* This prevents 504 "Outdated Optimize Dep" errors by ensuring files exist
+* before Vite's optimization phase.
+*/
+function createEarlyVirtualModulesPlugin(options) {
+	const { shared, remotes, virtualModuleDir } = options;
+	return {
+		name: "vite:module-federation-early-init",
+		enforce: "pre",
+		config(config, { command: _command }) {
+			if (_command !== "serve") return;
+			const isRolldown = !!this?.meta?.rolldownVersion;
+			const root = config.root || process.cwd();
+			initVirtualModuleInfrastructure(root, virtualModuleDir);
+			VirtualModule.setRoot(root);
+			VirtualModule.ensureVirtualPackageExists();
+			initVirtualModules(_command, getRemoteEntryId(options));
+			if (remotes && Object.keys(remotes).length > 0) for (const key of Object.keys(remotes)) addUsedRemote(key, key);
+			if (shared && Object.keys(shared).length > 0) {
+				config.optimizeDeps = config.optimizeDeps || {};
+				config.optimizeDeps.include = config.optimizeDeps.include || [];
+				config.optimizeDeps.include.push(virtualRuntimeInitStatus.getImportId());
+				for (const key of Object.keys(shared)) {
+					if (key.endsWith("/")) continue;
+					const shareItem = shared[key];
+					getLoadShareModulePath(key, isRolldown);
+					writeLoadShareModule(key, shareItem, _command, isRolldown);
+					writePreBuildLibPath(key);
+					addUsedShares(key);
+					config.optimizeDeps.include.push(getPreBuildLibImportId(key));
+				}
+				writeLocalSharedImportMap();
+			}
+		}
+	};
+}
 function federation(mfUserOptions) {
 	const options = normalizeModuleFederationOptions(mfUserOptions);
 	const { name, remotes, shared, filename, hostInitInjectLocation } = options;
 	if (!name) throw new Error("name is required");
+	const remoteEntryId = getRemoteEntryId(options);
+	const virtualExposesId = getVirtualExposesId(options);
 	let command;
 	return [
+		createEarlyVirtualModulesPlugin(options),
 		{
 			name: "vite:module-federation-config",
 			enforce: "pre",
@@ -1856,7 +1968,7 @@ function federation(mfUserOptions) {
 			configResolved(config) {
 				VirtualModule.setRoot(config.root);
 				VirtualModule.ensureVirtualPackageExists();
-				initVirtualModules(command);
+				initVirtualModules(command, remoteEntryId);
 			}
 		},
 		aliasToArrayPlugin_default,
@@ -1865,7 +1977,7 @@ function federation(mfUserOptions) {
 		...pluginDts(options),
 		...addEntry({
 			entryName: "remoteEntry",
-			entryPath: REMOTE_ENTRY_ID,
+			entryPath: remoteEntryId,
 			fileName: filename
 		}),
 		...addEntry({
@@ -1875,22 +1987,51 @@ function federation(mfUserOptions) {
 		}),
 		...addEntry({
 			entryName: "virtualExposes",
-			entryPath: VIRTUAL_EXPOSES
+			entryPath: virtualExposesId
+		}),
+		pluginProxyRemoteEntry_default({
+			options,
+			remoteEntryId,
+			virtualExposesId
 		}),
-		pluginProxyRemoteEntry_default(),
 		pluginProxyRemotes_default(options),
 		...pluginModuleParseEnd_default((id) => {
-			return id.includes(getHostAutoInitImportId()) || id.includes(REMOTE_ENTRY_ID) || id.includes(VIRTUAL_EXPOSES) || id.includes(getLocalSharedImportMapPath());
-		}, { moduleParseTimeout: options.moduleParseTimeout }),
+			return id.includes(getHostAutoInitImportId()) || id.includes(remoteEntryId) || id.includes(virtualExposesId) || id.includes(getLocalSharedImportMapPath());
+		}, {
+			moduleParseTimeout: options.moduleParseTimeout,
+			virtualExposesId
+		}),
 		...proxySharedModule({ shared }),
 		{
 			name: "module-federation-esm-shims",
 			enforce: "pre",
 			apply: "build",
+			config(config) {
+				const runtimeInitId = virtualRuntimeInitStatus.getImportId();
+				config.build = config.build || {};
+				config.build.rollupOptions = config.build.rollupOptions || {};
+				if (!Array.isArray(config.build.rollupOptions.output)) {
+					const output = config.build.rollupOptions.output ||= {};
+					const existingManualChunks = output.manualChunks;
+					output.manualChunks = function(id) {
+						if (id.includes(runtimeInitId)) return "runtimeInit";
+						if (id.includes(LOAD_SHARE_TAG)) {
+							const match = id.match(/([^/\\]+__loadShare__[^/\\]+)/);
+							return match ? match[1] : "loadShare";
+						}
+						if (typeof existingManualChunks === "function") return existingManualChunks.apply(this, arguments);
+						if (existingManualChunks && typeof existingManualChunks === "object") {
+							for (const [key, ids] of Object.entries(existingManualChunks)) if (Array.isArray(ids) && ids.some((v) => id.includes(v))) return key;
+						}
+					};
+				}
+			},
 			load(id) {
 				if (id.startsWith("\0")) return;
 				if (id.includes(LOAD_SHARE_TAG) || id.includes(LOAD_REMOTE_TAG)) {
 					let code = readFileSync(id, "utf-8");
+					code = code.replace(/import\s+["'][^"']*__prebuild__[^"']*["']\s*;?/g, "");
+					code = code.replace(/export\s+\*\s+from\s+["'][^"']*__prebuild__[^"']*["']\s*;?/g, "");
 					/**
 					* Shared/remote shims only have `export default exportModule`.
 					*
@@ -1913,6 +2054,134 @@ function federation(mfUserOptions) {
 						syntheticNamedExports: "__moduleExports"
 					};
 				}
+			},
+			generateBundle(_, bundle) {
+				for (const [fileName, chunk] of Object.entries(bundle)) {
+					if (chunk.type !== "chunk") continue;
+					if (fileName.includes(LOAD_SHARE_TAG)) continue;
+					let code = chunk.code;
+					let m;
+					const importedFromLoadShare = /* @__PURE__ */ new Set();
+					const importRegex = /import\s*\{([^}]+)\}\s*from\s*["'][^"']*__loadShare__[^"']*["']/g;
+					while ((m = importRegex.exec(code)) !== null) for (const spec of m[1].split(",")) {
+						const parts = spec.trim().split(/\s+as\s+/);
+						const local = (parts[1] || parts[0]).trim();
+						if (local) importedFromLoadShare.add(local);
+					}
+					const allInits = [];
+					for (const v of importedFromLoadShare) if (new RegExp("\\(" + v + "\\(\\)\\s*,\\s*\\w+\\(\\w+\\)\\)").test(code)) allInits.push(v);
+					if (allInits.length === 0) continue;
+					const awaits = allInits.map((v) => `await ${v}();`).join("");
+					const lastFromRegex = /\bfrom\s*["'][^"']*["']\s*;?/g;
+					let lastFromEnd = -1;
+					while ((m = lastFromRegex.exec(code)) !== null) lastFromEnd = m.index + m[0].length;
+					if (lastFromEnd !== -1) {
+						chunk.code = code.slice(0, lastFromEnd) + awaits + code.slice(lastFromEnd);
+						continue;
+					}
+					const exportIdx = code.search(/\bexport\s*[{d]/);
+					if (exportIdx !== -1) {
+						chunk.code = code.slice(0, exportIdx) + awaits + code.slice(exportIdx);
+						continue;
+					}
+				}
+				const proxyChunks = /* @__PURE__ */ new Map();
+				for (const [fileName, chunk] of Object.entries(bundle)) {
+					if (chunk.type !== "chunk") continue;
+					if (fileName.includes(LOAD_SHARE_TAG) && fileName.includes("commonjs-proxy")) proxyChunks.set(fileName, {
+						code: chunk.code,
+						fileName
+					});
+				}
+				if (proxyChunks.size === 0) return;
+				for (const [fileName, chunk] of Object.entries(bundle)) {
+					if (chunk.type !== "chunk") continue;
+					if (fileName.includes(LOAD_SHARE_TAG)) continue;
+					let code = chunk.code;
+					let modified = false;
+					for (const [proxyFileName, proxyInfo] of proxyChunks) {
+						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 = [];
+						for (const b of bindings) {
+							const proxyLocal = exportMap[b.imported];
+							if (!proxyLocal) {
+								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
+								});
+							} else nonInlineable.push(b);
+						}
+						if (inlineable.length === 0) 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;
+					}
+					if (modified) chunk.code = code;
+				}
+			}
+		},
+		{
+			name: "module-federation-dev-await-shared-init",
+			apply: "serve",
+			enforce: "post",
+			transform(code, id) {
+				if (!id.includes(".vite/deps/")) return;
+				const initPattern = /\b(init_\w+__loadShare__\w+)\b/g;
+				const initFns = /* @__PURE__ */ new Set();
+				let match;
+				while ((match = initPattern.exec(code)) !== null) initFns.add(match[1]);
+				if (initFns.size === 0) return;
+				if (![...initFns].some((fn) => {
+					return code.includes(`${fn}(),`) || code.includes(`${fn}()`);
+				})) return;
+				if (/await\s+init_\w+__loadShare__/.test(code)) return;
+				if (code.includes("__esmMin")) return;
+				const awaits = [...initFns].map((fn) => `await ${fn}();`).join("\n");
+				const topLevelImportRe = /^import\s/gm;
+				let lastImportIdx = -1;
+				let importMatch;
+				while ((importMatch = topLevelImportRe.exec(code)) !== null) lastImportIdx = importMatch.index;
+				if (lastImportIdx === -1) return;
+				const lineEnd = code.indexOf("\n", lastImportIdx);
+				return code.slice(0, lineEnd + 1) + awaits + "\n" + code.slice(lineEnd + 1);
 			}
 		},
 		PluginDevProxyModuleTopLevelAwait(),
@@ -1921,16 +2190,22 @@ function federation(mfUserOptions) {
 			enforce: "post",
 			_options: options,
 			config(config, { command: _command }) {
+				const isRolldown = !!this?.meta?.rolldownVersion;
+				let implementation = options.implementation;
+				if (isRolldown) implementation = implementation.replace(/\.cjs\.cjs$/, ".esm.js");
 				config.resolve.alias.push({
 					find: "@module-federation/runtime",
-					replacement: options.implementation
+					replacement: implementation
 				});
 				config.build = defu(config.build || {}, { commonjsOptions: { strictRequires: "auto" } });
 				const virtualDir = options.virtualModuleDir || "__mf__virtual";
 				config.optimizeDeps?.include?.push("@module-federation/runtime");
 				config.optimizeDeps?.include?.push(virtualDir);
-				config.optimizeDeps?.needsInterop?.push(virtualDir);
-				config.optimizeDeps?.needsInterop?.push(getLocalSharedImportMapPath());
+				if (isRolldown) config.build = defu(config.build || {}, { target: "esnext" });
+				else {
+					config.optimizeDeps?.needsInterop?.push(virtualDir);
+					config.optimizeDeps?.needsInterop?.push(getLocalSharedImportMapPath());
+				}
 				const resolvedTarget = options.target ?? (config.build?.ssr ? "node" : "web");
 				if (!config.define) config.define = {};
 				if (!("ENV_TARGET" in config.define)) config.define["ENV_TARGET"] = JSON.stringify(resolvedTarget);
@@ -1938,7 +2213,25 @@ function federation(mfUserOptions) {
 			}
 		},
 		...Manifest(),
-		...VarRemoteEntry()
+		...VarRemoteEntry(),
+		...Object.keys(options.exposes).length > 0 ? [{
+			name: "module-federation-fix-preload",
+			enforce: "post",
+			apply: "build",
+			generateBundle(_, bundle) {
+				for (const chunk of Object.values(bundle)) {
+					if (chunk.type !== "chunk") continue;
+					if (!chunk.code.includes("modulepreload")) continue;
+					const replacement = "=function($1){return new URL(\"../\"+$1,import.meta.url).href}";
+					const replaced = chunk.code.replace(/=\(?(\w+)(?:,\w+)?\)?\s*=>\s*["'`][^"'`]*["'`]\s*\+\s*\1/, replacement);
+					if (replaced !== chunk.code) {
+						chunk.code = replaced;
+						continue;
+					}
+					chunk.code = chunk.code.replace(/=function\((\w+)(?:,\w+)?\)\{return\s*["'`][^"'`]*["'`]\s*\+\s*\1\s*\}/, replacement);
+				}
+			}
+		}] : []
 	];
 }