@module-federation/vite 1.14.3 → 1.14.5

package/README.md

@@ -190,15 +190,20 @@ const RemoteMFE = defineAsyncComponent( 👈
 </template>
 ```
 
-## ⚠️ `codeSplitting: false` is not supported
+## ⚠️ `codeSplitting` settings are controlled by the plugin
 
-Do not set `build.rolldownOptions.output.codeSplitting` to `false` with this plugin — it will be **automatically ignored**.
-Module federation requires chunk splitting to isolate shared dependencies and remote entries into separate chunks.
+Do not set either `build.rollupOptions.output.codeSplitting` or
+`build.rolldownOptions.output.codeSplitting` to `false` with this plugin — it will be **automatically ignored**.
+
+`codeSplitting.groups` is also ignored because grouping shared-runtime chunks can break MF init order.
+Module Federation needs `loadShare` and `runtimeInitStatus` isolated into separate chunks for correct bootstrap behavior.
 
 ## ⚠️ `manualChunks` is not supported
 
-Do not use `build.rollupOptions.output.manualChunks` with this plugin — it will be **automatically ignored**.
+Do not use `build.rollupOptions.output.manualChunks` or
+`build.rolldownOptions.output.manualChunks` with this plugin — it will be **automatically ignored**.
 Module federation transforms shared dependency imports with top-level `await`, and grouping these transformed modules into a single chunk creates circular async dependencies that cause the application to silently hang.
+The plugin injects its own split so `runtimeInitStatus` and `loadShare` are kept isolated.
 
 ### So far so good 🎉
 

package/lib/index.cjs

@@ -117,6 +117,15 @@ function setPackageDetectionCwd(cwd) {
 function getPackageDetectionCwd() {
 	return packageDetectionCwd || process.cwd();
 }
+function resolveExportsEntry(exportsField) {
+	if (typeof exportsField === "string") return exportsField;
+	if (!exportsField || typeof exportsField !== "object") return void 0;
+	const rootExport = exportsField["."];
+	if (typeof rootExport === "string") return rootExport;
+	if (!rootExport || typeof rootExport !== "object") return void 0;
+	const rootExportObject = rootExport;
+	return typeof rootExportObject.import === "string" && rootExportObject.import || typeof rootExportObject.default === "string" && rootExportObject.default || typeof rootExportObject.require === "string" && rootExportObject.require || void 0;
+}
 /**
 * Escaping rules:
 * Convert using the format __${mapping}__, where _ and $ are not allowed in npm package names but can be used in variable names.
@@ -152,6 +161,84 @@ function removePathFromNpmPackage(packageString) {
 	const match = packageString.match(/^(?:@[^/]+\/)?[^/]+/);
 	return match ? match[0] : packageString;
 }
+function getInstalledPackageJson(pkg, opts) {
+	const cwd = opts?.cwd || getPackageDetectionCwd();
+	const packageName = opts?.packageName || removePathFromNpmPackage(pkg);
+	const tryReadPackageJson = (packageJsonPath) => {
+		if (!(0, fs.existsSync)(packageJsonPath)) return void 0;
+		try {
+			return {
+				path: packageJsonPath,
+				dir: pathe.default.dirname(packageJsonPath),
+				packageJson: JSON.parse((0, fs.readFileSync)(packageJsonPath, "utf-8"))
+			};
+		} catch {
+			return;
+		}
+	};
+	const findPackageInPnpmStore = (startDir) => {
+		let currentDir = startDir;
+		const rootDir = pathe.default.parse(currentDir).root;
+		while (true) {
+			const pnpmStoreDir = pathe.default.join(currentDir, "node_modules", ".pnpm");
+			if ((0, fs.existsSync)(pnpmStoreDir)) try {
+				for (const entry of (0, fs.readdirSync)(pnpmStoreDir, { withFileTypes: true })) {
+					if (!entry.isDirectory()) continue;
+					const candidate = tryReadPackageJson(pathe.default.join(pnpmStoreDir, entry.name, "node_modules", packageName, "package.json"));
+					if (candidate?.packageJson.name === packageName) return candidate;
+				}
+			} catch {}
+			if (currentDir === rootDir) break;
+			currentDir = pathe.default.dirname(currentDir);
+		}
+	};
+	try {
+		const projectRequire = (0, module$1.createRequire)(new URL(`file://${pathe.default.join(cwd, "package.json")}`));
+		let resolvedPath;
+		try {
+			resolvedPath = projectRequire.resolve(pkg);
+		} catch {
+			resolvedPath = projectRequire.resolve(packageName);
+		}
+		let currentDir = pathe.default.dirname(resolvedPath);
+		const rootDir = pathe.default.parse(currentDir).root;
+		while (true) {
+			const packageJsonPath = pathe.default.join(currentDir, "package.json");
+			if ((0, fs.existsSync)(packageJsonPath)) {
+				const packageJsonContent = (0, fs.readFileSync)(packageJsonPath, "utf-8");
+				try {
+					const packageJson = JSON.parse(packageJsonContent);
+					if (packageJson.name === packageName) return {
+						path: packageJsonPath,
+						dir: currentDir,
+						packageJson
+					};
+				} catch (error) {
+					if (!(error instanceof SyntaxError)) throw error;
+				}
+			}
+			if (currentDir === rootDir) break;
+			currentDir = pathe.default.dirname(currentDir);
+		}
+	} catch {
+		let currentDir = cwd;
+		const rootDir = pathe.default.parse(currentDir).root;
+		while (true) {
+			const directCandidate = tryReadPackageJson(pathe.default.join(currentDir, "node_modules", packageName, "package.json"));
+			if (directCandidate?.packageJson.name === packageName) return directCandidate;
+			if (currentDir === rootDir) break;
+			currentDir = pathe.default.dirname(currentDir);
+		}
+		return findPackageInPnpmStore(cwd);
+	}
+}
+function getInstalledPackageEntry(pkg, opts) {
+	const installed = getInstalledPackageJson(pkg, opts);
+	if (!installed) return void 0;
+	const packageJson = installed.packageJson;
+	const explicitEntry = resolveExportsEntry(packageJson.exports) || (typeof packageJson.module === "string" ? packageJson.module : void 0) || (typeof packageJson.main === "string" ? packageJson.main : void 0) || "index.js";
+	return pathe.default.join(installed.dir, explicitEntry);
+}
 /**
 * Detect whether the current runtime is Vite 8+ by checking for a Vite version flag
 * on the plugin hook context, with Rolldown metadata kept as a compatibility fallback.
@@ -877,6 +964,14 @@ function pluginDts(options) {
 }
 //#endregion
 //#region src/utils/normalizeModuleFederationOptions.ts
+const INTERNAL_NAME_PREFIX = "__mfe_internal__";
+function toInternalModuleFederationName(name) {
+	return name.startsWith(INTERNAL_NAME_PREFIX) ? name : `${INTERNAL_NAME_PREFIX}${name}`;
+}
+function warnOnReservedInternalNamePrefix(name, kind) {
+	if (!name.startsWith(INTERNAL_NAME_PREFIX)) return;
+	mfWarn(`Reserved internal ${kind} prefix "${INTERNAL_NAME_PREFIX}" detected in public ${kind} "${name}". This prefix is reserved for internal module federation names and may cause conflicts.`);
+}
 function normalizeExposesItem(key, item) {
 	let importPath = "";
 	if (typeof item === "string") importPath = item;
@@ -900,6 +995,7 @@ function normalizeRemotes(remotes) {
 	return result;
 }
 function normalizeRemoteItem(key, remote) {
+	warnOnReservedInternalNamePrefix(key, "remoteAlias");
 	if (typeof remote === "string") {
 		const separatorIndex = remote.startsWith("@") ? remote.indexOf("@", 1) : remote.indexOf("@");
 		let entryGlobalName;
@@ -914,6 +1010,7 @@ function normalizeRemoteItem(key, remote) {
 		return {
 			type: "var",
 			name: key,
+			internalName: toInternalModuleFederationName(key),
 			entry,
 			entryGlobalName,
 			shareScope: "default"
@@ -922,9 +1019,13 @@ function normalizeRemoteItem(key, remote) {
 	return Object.assign({
 		type: "var",
 		name: key,
+		internalName: toInternalModuleFederationName(key),
 		shareScope: "default",
 		entryGlobalName: key
-	}, remote);
+	}, {
+		...remote,
+		internalName: toInternalModuleFederationName(remote.name || key)
+	});
 }
 /**
 * Tries to find the package.json's version of a shared package
@@ -956,6 +1057,12 @@ function inferVersionFromRequiredVersion(requiredVersion) {
 	if (!requiredVersion) return void 0;
 	return requiredVersion.match(/\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/)?.[0];
 }
+function getLitExportSubpathShares(sharedName) {
+	if (sharedName !== "lit") return [];
+	const exportsField = getInstalledPackageJson(sharedName, { packageName: sharedName })?.packageJson.exports;
+	if (!exportsField || typeof exportsField === "string") return [];
+	return Object.keys(exportsField).filter((key) => key.startsWith("./") && key !== "." && !key.includes("*")).map((key) => `${sharedName}/${key.slice(2)}`);
+}
 function normalizeShareItem(key, shareItem) {
 	let version;
 	if (!(typeof shareItem === "object" && shareItem.import === false)) try {
@@ -1000,14 +1107,21 @@ function normalizeShareItem(key, shareItem) {
 function normalizeShared(shared) {
 	if (!shared) return {};
 	const result = {};
-	if (Array.isArray(shared)) {
-		shared.forEach((key) => {
-			result[key] = normalizeShareItem(key, key);
-		});
-		return result;
-	}
-	if (typeof shared === "object") Object.keys(shared).forEach((key) => {
-		result[key] = normalizeShareItem(key, shared[key]);
+	const sourceEntries = [];
+	if (Array.isArray(shared)) shared.forEach((key) => {
+		result[key] = normalizeShareItem(key, key);
+		sourceEntries.push([key, key]);
+	});
+	else if (typeof shared === "object") Object.keys(shared).forEach((key) => {
+		const value = shared[key];
+		result[key] = normalizeShareItem(key, value);
+		sourceEntries.push([key, value]);
+	});
+	sourceEntries.forEach(([key, value]) => {
+		for (const subpathShare of getLitExportSubpathShares(key)) {
+			if (result[subpathShare]) continue;
+			result[subpathShare] = normalizeShareItem(subpathShare, value);
+		}
 	});
 	return result;
 }
@@ -1032,10 +1146,12 @@ function getNormalizeShareItem(key) {
 	return options.shared[key] || options.shared[removePathFromNpmPackage(key)] || options.shared[removePathFromNpmPackage(key) + "/"];
 }
 function normalizeModuleFederationOptions(options) {
+	warnOnReservedInternalNamePrefix(options.name, "containerName");
 	if (options.virtualModuleDir && options.virtualModuleDir.includes("/")) throw createModuleFederationError(`Invalid virtualModuleDir: "${options.virtualModuleDir}". The virtualModuleDir option cannot contain slashes (/). Please use a single directory name like '__mf__virtual__your_app_name'.`);
 	return config = {
 		exposes: normalizeExposes(options.exposes),
 		filename: options.filename || "remoteEntry-[hash]",
+		internalName: toInternalModuleFederationName(options.name),
 		library: normalizeLibrary(options.library),
 		name: options.name,
 		remotes: normalizeRemotes(options.remotes),
@@ -1210,7 +1326,7 @@ var VirtualModule = class {
 		return (0, pathe.resolve)(getNodeModulesDir(), this.getImportId());
 	}
 	getImportId() {
-		const { name: mfName, virtualModuleDir } = getNormalizeModuleFederationOptions();
+		const { internalName: mfName, virtualModuleDir } = getNormalizeModuleFederationOptions();
 		return `${virtualModuleDir}/${packageNameEncode(`${mfName}${this.tag}${this.name}${this.tag}`)}${this.suffix}`;
 	}
 	writeSync(code, force) {
@@ -1233,7 +1349,7 @@ function getExposesCssMapPlaceholder() {
 	return EXPOSES_CSS_MAP_PLACEHOLDER;
 }
 function getVirtualExposesId(options) {
-	return `virtual:mf-exposes:${`${options.name}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+	return `virtual:mf-exposes:${`${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
 }
 function generateExposes(options) {
 	return `
@@ -1467,52 +1583,6 @@ function resolvePackageEntryFromProjectRoot(pkg) {
 		return;
 	}
 }
-function getInstalledPackageJsonPath(pkg) {
-	try {
-		const packageName = removePathFromNpmPackage(pkg);
-		const projectRequire = (0, module$1.createRequire)(new URL(`file://${pathe.default.join(getPackageDetectionCwd(), "package.json")}`));
-		let resolvedPath;
-		try {
-			resolvedPath = projectRequire.resolve(pkg);
-		} catch {
-			resolvedPath = projectRequire.resolve(packageName);
-		}
-		let currentDir = pathe.default.dirname(resolvedPath);
-		const rootDir = pathe.default.parse(currentDir).root;
-		while (currentDir !== rootDir) {
-			const packageJsonPath = pathe.default.join(currentDir, "package.json");
-			if ((0, fs.existsSync)(packageJsonPath)) {
-				const packageJsonContent = (0, fs.readFileSync)(packageJsonPath, "utf-8");
-				try {
-					if (JSON.parse(packageJsonContent).name === packageName) return packageJsonPath;
-				} catch (error) {
-					if (!(error instanceof SyntaxError)) throw error;
-				}
-			}
-			currentDir = pathe.default.dirname(currentDir);
-		}
-		const rootPackageJsonPath = pathe.default.join(rootDir, "package.json");
-		if ((0, fs.existsSync)(rootPackageJsonPath)) {
-			const rootPackageJsonContent = (0, fs.readFileSync)(rootPackageJsonPath, "utf-8");
-			try {
-				if (JSON.parse(rootPackageJsonContent).name === packageName) return rootPackageJsonPath;
-			} catch (error) {
-				if (!(error instanceof SyntaxError)) throw error;
-			}
-		}
-	} catch {
-		const packageName = removePathFromNpmPackage(pkg);
-		let currentDir = getPackageDetectionCwd();
-		const rootDir = pathe.default.parse(currentDir).root;
-		while (currentDir !== rootDir) {
-			const packageJsonPath = pathe.default.join(currentDir, "node_modules", packageName, "package.json");
-			if ((0, fs.existsSync)(packageJsonPath)) return packageJsonPath;
-			currentDir = pathe.default.dirname(currentDir);
-		}
-		const rootPackageJsonPath = pathe.default.join(rootDir, "node_modules", packageName, "package.json");
-		return (0, fs.existsSync)(rootPackageJsonPath) ? rootPackageJsonPath : void 0;
-	}
-}
 function resolveImportTarget(exportsField) {
 	if (typeof exportsField === "string") return exportsField;
 	if (!exportsField || typeof exportsField !== "object") return void 0;
@@ -1533,14 +1603,14 @@ function resolveImportTarget(exportsField) {
 function getPackageEsmEntryPath(pkg) {
 	try {
 		const resolvedEntryPath = resolvePackageEntryFromProjectRoot(pkg);
-		const packageJsonPath = getInstalledPackageJsonPath(pkg);
-		if (!packageJsonPath) return resolvedEntryPath;
+		const installedPackageJson = getInstalledPackageJson(pkg);
+		if (!installedPackageJson) return resolvedEntryPath;
 		const packageName = removePathFromNpmPackage(pkg);
-		const packageJson = JSON.parse((0, fs.readFileSync)(packageJsonPath, "utf-8"));
+		const packageJson = installedPackageJson.packageJson;
 		const subpath = pkg === packageName ? "." : `.${pkg.slice(packageName.length)}`;
 		const target = resolveImportTarget(typeof packageJson.exports === "string" ? subpath === "." ? packageJson.exports : void 0 : packageJson.exports?.[subpath] ?? (subpath === "." ? packageJson.exports?.["."] ?? (packageJson.exports && !Object.keys(packageJson.exports).some((key) => key.startsWith(".")) ? packageJson.exports : void 0) : void 0)) || packageJson.module;
 		if (!target) return resolvedEntryPath;
-		return pathe.default.resolve(pathe.default.dirname(packageJsonPath), target);
+		return pathe.default.resolve(installedPackageJson.dir, target);
 	} catch {
 		return resolvePackageEntryFromProjectRoot(pkg);
 	}
@@ -1684,8 +1754,11 @@ function getSharedImportSource(pkg, shareItem) {
 }
 const LOAD_SHARE_TAG = "__loadShare__";
 const loadShareCacheMap = {};
+function shouldUseEsmLoadShare(pkg, command, isRolldown) {
+	return command === "build" || !!isRolldown || pkg === "lit" || pkg.startsWith("lit/");
+}
 function getLoadShareImportId(pkg, isRolldown, command) {
-	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = new VirtualModule(pkg, LOAD_SHARE_TAG, isRolldown || command === "build" ? ".mjs" : ".js");
+	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = new VirtualModule(pkg, LOAD_SHARE_TAG, shouldUseEsmLoadShare(pkg, command, isRolldown) ? ".mjs" : ".js");
 	return loadShareCacheMap[pkg].getImportId();
 }
 function getLoadShareModulePath(pkg, isRolldown, command) {
@@ -1693,8 +1766,8 @@ function getLoadShareModulePath(pkg, isRolldown, command) {
 	return loadShareCacheMap[pkg].getPath();
 }
 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;
+	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = new VirtualModule(pkg, LOAD_SHARE_TAG, shouldUseEsmLoadShare(pkg, command, isRolldown) ? ".mjs" : ".js");
+	const useESM = shouldUseEsmLoadShare(pkg, command, isRolldown);
 	const importLine = command === "build" ? getRuntimeInitPromiseBootstrapCode() : useESM ? `${getRuntimeInitBootstrapCode()}
     const { initPromise } = globalThis[globalKey];` : `const {initPromise} = require("${virtualRuntimeInitStatus.getImportId()}")`;
 	const awaitOrPlaceholder = useESM ? "await " : "/*mf top-level-await placeholder replacement mf*/";
@@ -1728,6 +1801,7 @@ function writeLoadShareModule(pkg, shareItem, command, isRolldown) {
 	const devImportSource = concreteSharedImportSource || pkg;
 	const localProviderPath = getLocalProviderImportPath(pkg);
 	const isWorkspacePackage = isWorkspaceFilePath(localProviderPath) || isWorkspaceFilePath(concreteSharedImportSource);
+	const skipServePrebuildWarmup = command !== "build" && (pkg === "lit" || pkg.startsWith("lit/"));
 	const providerImportId = localProviderPath || concreteSharedImportSource || sharedImportSource;
 	const namedExports = getPackageNamedExports(pkg);
 	let exportLine;
@@ -1736,8 +1810,8 @@ function writeLoadShareModule(pkg, shareItem, command, isRolldown) {
 		const namedExportLine = `export { ${namedExports.map((name, i) => `__mf_${i} as ${name}`).join(", ")} };`;
 		exportLine = useESM ? `export default exportModule.default ?? exportModule;\n    ${destructure}\n    ${namedExportLine}` : `module.exports = exportModule;\n    ${destructure}\n    Object.assign(module.exports, { ${namedExports.map((name, i) => `"${name}": __mf_${i}`).join(", ")} });`;
 	} else exportLine = useESM ? `export default exportModule.default ?? exportModule\n    export * from ${escapeGeneratedStringLiteral(sharedImportSource)}` : "module.exports = exportModule";
-	const prebuildImportLine = isWorkspacePackage && command !== "build" ? "" : `import ${escapeGeneratedStringLiteral(sharedImportSource)};`;
-	const devDynamicImportLine = isWorkspacePackage ? "" : command !== "build" ? `;() => import(${escapeGeneratedStringLiteral(devImportSource)}).catch(() => {});` : "";
+	const prebuildImportLine = isWorkspacePackage && command !== "build" || skipServePrebuildWarmup ? "" : `import ${escapeGeneratedStringLiteral(sharedImportSource)};`;
+	const devDynamicImportLine = isWorkspacePackage ? "" : command !== "build" && !skipServePrebuildWarmup ? `;() => import(${escapeGeneratedStringLiteral(devImportSource)}).catch(() => {});` : "";
 	loadShareCacheMap[pkg].writeSync(`
     ${prebuildImportLine}
     ${devDynamicImportLine}
@@ -1811,7 +1885,7 @@ function generateLocalSharedImportMap() {
             version: ${JSON.stringify(shareItem.version)},
             scope: [${JSON.stringify(shareItem.scope)}],
             loaded: false,
-            from: ${JSON.stringify(options.name)},
+            from: ${JSON.stringify(options.internalName)},
             async get () {
               if (${shareItem.shareConfig.import === false}) {
                 throw new Error(\`[Module Federation] Shared module '\${${JSON.stringify(key)}}' must be provided by host\`);
@@ -1862,7 +1936,7 @@ function generateLocalSharedImportMap() {
 }
 const REMOTE_ENTRY_ID = "virtual:mf-REMOTE_ENTRY_ID";
 function getRemoteEntryId(options) {
-	return `${REMOTE_ENTRY_ID}:${`${options.name}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+	return `${REMOTE_ENTRY_ID}:${`${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
 }
 function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(options), command = "build") {
 	const pluginImportNames = options.runtimePlugins.map((p, i) => {
@@ -1891,7 +1965,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   ${command === "build" ? getRuntimeInitResolveBootstrapCode() : getRuntimeInitBootstrapCode() + "\n  const { initResolve } = globalThis[globalKey];"}
   const initTokens = {}
   const shareScopeName = ${JSON.stringify(options.shareScope)}
-  const mfName = ${JSON.stringify(options.name)}
+  const mfName = ${JSON.stringify(options.internalName)}
   let localSharedImportMapPromise
   let exposesMapPromise
 
@@ -2458,7 +2532,7 @@ function pluginModuleParseEnd_default(excludeFn, options) {
 }
 //#endregion
 //#region src/plugins/pluginProxyRemoteEntry.ts
-const filter = (0, _rollup_pluginutils.createFilter)();
+const filter$1 = (0, _rollup_pluginutils.createFilter)();
 function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposesId }) {
 	let viteConfig, _command, root;
 	return {
@@ -2498,7 +2572,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		},
 		transform(code, id) {
 			return mapCodeToCodeWithSourcemap((() => {
-				if (!filter(id)) return;
+				if (!filter$1(id)) return;
 				if (id.includes(remoteEntryId)) return parsePromise.then((_) => generateRemoteEntry(options, virtualExposesId, _command));
 				if (id === virtualExposesId) return generateExposes(options);
 				if (id.includes(getHostAutoInitPath())) {
@@ -2571,25 +2645,47 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 }
 //#endregion
 //#region src/plugins/pluginProxyRemotes.ts
-(0, _rollup_pluginutils.createFilter)();
+const filter = (0, _rollup_pluginutils.createFilter)();
+function isNodeModulesImporter(importer) {
+	return importer?.includes("/node_modules/") || importer?.includes("\\node_modules\\");
+}
 function pluginProxyRemotes_default(options) {
+	let command;
+	let root = process.cwd();
 	const { remotes } = options;
+	function resolveRemoteId(source, importer, remoteName, isRolldown) {
+		if (source === remoteName) {
+			const installedPackageEntry = getInstalledPackageEntry(source, { cwd: root });
+			if (installedPackageEntry && (importer === void 0 || isNodeModulesImporter(importer))) return installedPackageEntry;
+		}
+		const remoteModule = getRemoteVirtualModule(source, command, isRolldown);
+		addUsedRemote(remoteName, source);
+		return remoteModule.getPath();
+	}
 	return {
 		name: "proxyRemotes",
 		config(config, { command: _command }) {
+			command = _command;
+			root = config.root || process.cwd();
 			const isRolldown = getIsRolldown(this);
 			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, isRolldown);
-						addUsedRemote(remote.name, source);
-						return remoteModule.getPath();
+					customResolver(source, importer) {
+						return resolveRemoteId(source, importer, remote.name, isRolldown);
 					}
 				});
 			});
+		},
+		resolveId(source, importer) {
+			if (!filter(source)) return;
+			const isRolldown = getIsRolldown(this);
+			for (const remote of Object.values(remotes)) {
+				if (source !== remote.name) continue;
+				return resolveRemoteId(source, importer, remote.name, isRolldown);
+			}
 		}
 	};
 }
@@ -3065,24 +3161,31 @@ function collectFromRegex(code, isRemoteImport) {
 }
 function pluginRemoteNamedExports(options) {
 	const remoteNames = Object.keys(options.remotes);
-	function isRemoteImport(source) {
-		return remoteNames.some((name) => source === name || source.startsWith(name + "/")) || source.includes("__loadRemote__");
+	const isNodeModulesId = (id) => id.includes("/node_modules/") || id.includes("\\node_modules\\");
+	function isRemoteImport(source, importerId) {
+		return remoteNames.some((name) => {
+			if (source.startsWith(name + "/")) return true;
+			if (source !== name) return false;
+			return !isNodeModulesId(importerId);
+		}) || source.includes("__loadRemote__");
 	}
 	return {
 		name: "module-federation-remote-named-exports",
 		enforce: "post",
 		async transform(code, id) {
+			if (!getIsRolldown(this)) return;
 			if (remoteNames.length === 0) return;
 			if (id.includes("__loadRemote__") || id.includes("__loadShare__")) return;
 			if (!JS_EXTENSIONS_RE.test(id)) return;
 			if (!remoteNames.some((name) => code.includes(name))) return;
+			const matchesRemoteImport = (source) => isRemoteImport(source, id);
 			let imports;
 			try {
-				imports = await collectFromAST(this.parse(code), code, isRemoteImport);
+				imports = await collectFromAST(this.parse(code), code, matchesRemoteImport);
 			} catch {
-				imports = await collectFromEsLexer(code, isRemoteImport);
+				imports = await collectFromEsLexer(code, matchesRemoteImport);
 			}
-			if ((!imports || imports.length === 0) && REGEX_FALLBACK_EXTENSIONS_RE.test(id)) imports = collectFromRegex(code, isRemoteImport);
+			if ((!imports || imports.length === 0) && REGEX_FALLBACK_EXTENSIONS_RE.test(id)) imports = collectFromRegex(code, matchesRemoteImport);
 			if (!imports) return;
 			return applyRewrites(code, imports, id);
 		}
@@ -3330,6 +3433,7 @@ function insertAfterLastTopLevelImport(code, snippet) {
 */
 function createEarlyVirtualModulesPlugin(options) {
 	const { shared, remotes, virtualModuleDir } = options;
+	const isLitShare = (pkg) => pkg === "lit" || pkg.startsWith("lit/");
 	return {
 		name: "vite:module-federation-early-init",
 		enforce: "pre",
@@ -3342,16 +3446,23 @@ function createEarlyVirtualModulesPlugin(options) {
 			VirtualModule.ensureVirtualPackageExists();
 			initVirtualModules(_command, getRemoteEntryId(options));
 			const isRolldown = getIsRolldown(this);
-			if (remotes && Object.keys(remotes).length > 0) for (const key of Object.keys(remotes)) addUsedRemote(key, key);
+			if (remotes && Object.keys(remotes).length > 0) {
+				for (const key of Object.keys(remotes)) addUsedRemote(key, key);
+				if (_command === "serve" && isRolldown) {
+					config.optimizeDeps = config.optimizeDeps || {};
+					config.optimizeDeps.exclude = config.optimizeDeps.exclude || [];
+					config.optimizeDeps.include = config.optimizeDeps.include || [];
+					const collidingInstalledRemotes = Object.keys(remotes || {}).filter((remoteName) => getInstalledPackageJson(remoteName, { cwd: root }));
+					const collidingInstalledRemoteEntries = collidingInstalledRemotes.map((remoteName) => getInstalledPackageEntry(remoteName, { cwd: root }) || remoteName);
+					config.optimizeDeps.exclude.push(...Object.keys(remotes || {}).filter((remoteName) => !collidingInstalledRemotes.includes(remoteName)));
+					config.optimizeDeps.include.push(...collidingInstalledRemoteEntries);
+				}
+			}
 			if (shared && Object.keys(shared).length > 0) {
 				if (_command === "serve") {
 					config.optimizeDeps = config.optimizeDeps || {};
 					config.optimizeDeps.include = config.optimizeDeps.include || [];
 					config.optimizeDeps.include.push(virtualRuntimeInitStatus.getImportId());
-					if (isRolldown) {
-						config.optimizeDeps.exclude = config.optimizeDeps.exclude || [];
-						config.optimizeDeps.exclude.push(...Object.keys(remotes || {}));
-					}
 				}
 				for (const key of Object.keys(shared)) {
 					if (key.endsWith("/")) continue;
@@ -3365,8 +3476,13 @@ function createEarlyVirtualModulesPlugin(options) {
 					if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(key, shareItem);
 					addUsedShares(key);
 					if (_command === "serve" && shareItem.shareConfig?.import !== false) {
-						if (!isRolldown) config.optimizeDeps.include.push(getLoadShareImportId(key, isRolldown, _command));
-						config.optimizeDeps.include.push(getPreBuildLibImportId(key));
+						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, _command));
+						optimizeDeps.include.push(getPreBuildLibImportId(key));
 					}
 				}
 				writeLocalSharedImportMap();
@@ -3384,6 +3500,7 @@ function federation(mfUserOptions) {
 	const virtualExposesId = getVirtualExposesId(options);
 	let command;
 	let depsDir = "/node_modules/.vite/deps/";
+	let desiredRolldownOutput;
 	return [
 		createEarlyVirtualModulesPlugin(options),
 		...isVinext ? [{
@@ -3474,12 +3591,22 @@ function federation(mfUserOptions) {
 					};
 				}
 				let warnedAboutCodeSplitting = false;
+				let warnedAboutCodeSplittingGroups = false;
 				const ensureCodeSplitting = (output) => {
-					if (output?.codeSplitting !== false) return;
-					delete output.codeSplitting;
-					if (warnedAboutCodeSplitting) return;
-					warnedAboutCodeSplitting = true;
-					mfWarn("Ignoring `build.rolldownOptions.output.codeSplitting = false` because module federation requires chunk splitting.");
+					if (output?.codeSplitting === false) {
+						delete output.codeSplitting;
+						if (warnedAboutCodeSplitting) return;
+						warnedAboutCodeSplitting = true;
+						mfWarn("Ignoring `output.codeSplitting = false` because module federation requires chunk splitting.");
+						return;
+					}
+					if (!output?.codeSplitting || typeof output.codeSplitting !== "object") return;
+					if (!("groups" in output.codeSplitting)) return;
+					delete output.codeSplitting.groups;
+					if (Object.keys(output.codeSplitting).length === 0) delete output.codeSplitting;
+					if (warnedAboutCodeSplittingGroups) return;
+					warnedAboutCodeSplittingGroups = true;
+					mfWarn("Ignoring `output.codeSplitting.groups` because it conflicts with module federation. Grouping shared dependency init wrappers with their dependent modules can break runtime init order and cause standalone remotes to fail before mount.");
 				};
 				let warnedAboutManualChunks = false;
 				const applyManualChunks = (output) => {
@@ -3487,7 +3614,7 @@ function federation(mfUserOptions) {
 					const isPatchedByPlugin = !!(output.manualChunks && patchedManualChunks.has(output.manualChunks));
 					if (output.manualChunks && !isPatchedByPlugin && !warnedAboutManualChunks) {
 						warnedAboutManualChunks = true;
-						mfWarn("Ignoring `build.rollupOptions.output.manualChunks` because it conflicts with module federation. Module federation transforms shared dependency imports with top-level await, and grouping these transformed modules into a single chunk creates circular async dependencies that cause the application to silently hang.");
+						mfWarn("Ignoring `output.manualChunks` because it conflicts with module federation. Module federation transforms shared dependency imports with top-level await, and grouping these transformed modules into a single chunk creates circular async dependencies that cause the application to silently hang.");
 					}
 					const mfManualChunks = function(id) {
 						if (id.includes(runtimeInitId)) return "runtimeInit";
@@ -3500,10 +3627,46 @@ function federation(mfUserOptions) {
 					output.manualChunks = mfManualChunks;
 				};
 				config.build.rollupOptions = config.build.rollupOptions || {};
-				if (!Array.isArray(config.build.rollupOptions.output)) applyManualChunks(config.build.rollupOptions.output ||= {});
+				const rollupOutput = config.build.rollupOptions.output;
+				if (Array.isArray(rollupOutput)) rollupOutput.forEach((output) => applyManualChunks(output));
+				else applyManualChunks(config.build.rollupOptions.output ||= {});
 				const buildWithRolldown = config.build;
 				buildWithRolldown.rolldownOptions = buildWithRolldown.rolldownOptions || {};
-				if (!Array.isArray(buildWithRolldown.rolldownOptions.output)) applyManualChunks(buildWithRolldown.rolldownOptions.output ||= {});
+				const rolldownOutput = buildWithRolldown.rolldownOptions.output;
+				const snapshotRolldownOutput = (output) => ({
+					entryFileNames: output.entryFileNames,
+					chunkFileNames: output.chunkFileNames,
+					assetFileNames: output.assetFileNames
+				});
+				if (Array.isArray(rolldownOutput)) {
+					rolldownOutput.forEach((output) => applyManualChunks(output));
+					desiredRolldownOutput = rolldownOutput.map((output) => snapshotRolldownOutput(output));
+				} else {
+					applyManualChunks(buildWithRolldown.rolldownOptions.output ||= {});
+					desiredRolldownOutput = [snapshotRolldownOutput(buildWithRolldown.rolldownOptions.output)];
+				}
+			},
+			async buildApp(builder) {
+				if (!desiredRolldownOutput) return;
+				const applyRolldownOutput = (output, restoredOutput) => {
+					if (!output || !restoredOutput) return;
+					if (restoredOutput.entryFileNames !== void 0) output.entryFileNames = restoredOutput.entryFileNames;
+					if (restoredOutput.chunkFileNames !== void 0) output.chunkFileNames = restoredOutput.chunkFileNames;
+					if (restoredOutput.assetFileNames !== void 0) output.assetFileNames = restoredOutput.assetFileNames;
+				};
+				for (const environment of Object.values(builder.environments)) {
+					const getRolldownOptions = environment?.getRolldownOptions;
+					if (typeof getRolldownOptions !== "function") continue;
+					environment.getRolldownOptions = async () => {
+						const rolldownOptions = await getRolldownOptions.call(environment);
+						if (Array.isArray(rolldownOptions.output)) rolldownOptions.output.forEach((output, index) => applyRolldownOutput(output, desiredRolldownOutput?.[index]));
+						else {
+							rolldownOptions.output ||= {};
+							applyRolldownOutput(rolldownOptions.output, desiredRolldownOutput[0]);
+						}
+						return rolldownOptions;
+					};
+				}
 			},
 			load(id) {
 				if (id.startsWith("\0")) return;
@@ -3762,12 +3925,12 @@ function federation(mfUserOptions) {
 						const prefixToRoot = chunkDir === "." ? "" : `${pathe.default.relative(chunkDir, ".")}/`;
 						const replacementExpr = prefixToRoot ? `${escapeUnsafeJsSourceChars(JSON.stringify(prefixToRoot))}+$1` : "$1";
 						const replacement = `=function($1){return new URL(${replacementExpr},import.meta.url).href}`;
-						const replaced = chunk.code.replace(/=\(?(\w+)(?:,\w+)?\)?\s*=>\s*["'][./][^"']*["']\s*\+\s*\1/, replacement);
+						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);
+						chunk.code = chunk.code.replace(/=function\((\w+)(?:,\w+)?\)\{return\s*[`"'][./][^`"']*[`"']\s*\+\s*\1\s*\}/, replacement);
 						chunk.code = chunk.code.replace(/=function\((\w+)(?:,\w+)?\)\{return new URL\("\.\.\/"\+\1,import\.meta\.url\)\.href\}/, replacement);
 						chunk.code = chunk.code.replace(/new URL\("\.\.\/"\+(\w+),import\.meta\.url\)\.href/g, `new URL(${replacementExpr},import.meta.url).href`);
 					}

package/lib/index.d.cts

@@ -6,6 +6,7 @@ import { sharePlugin } from "@module-federation/sdk";
 interface RemoteObjectConfig {
   type?: string;
   name: string;
+  internalName?: string;
   entry: string;
   entryGlobalName?: string;
   shareScope?: string;