@module-federation/vite 1.16.1 → 1.16.3

package/lib/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_packageUtils = require("./packageUtils-CbbnJvKu.cjs");
+const require_packageUtils = require("./packageUtils-se-UDhCa.cjs");
 let fs = require("fs");
 fs = require_packageUtils.__toESM(fs);
 let module$1 = require("module");
@@ -418,24 +418,51 @@ function getSuffix(name) {
 }
 const patternMap = {};
 const cacheMap = {};
+const VITE_ID_PREFIX = "/@id/";
+const VITE_ENCODED_NULL_BYTE_PREFIX = `${VITE_ID_PREFIX}__x00__`;
+function escapeRegExp$1(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function createViteEncodedIdPrefixRegExp(sourcePrefix = "") {
+	return new RegExp(`^(?:${escapeRegExp$1(VITE_ENCODED_NULL_BYTE_PREFIX)})?${sourcePrefix}`);
+}
+function toViteEncodedId(id) {
+	return `${VITE_ENCODED_NULL_BYTE_PREFIX}${id}`;
+}
+function decodeViteId(id) {
+	if (!id.startsWith("/@id/")) return id;
+	const viteId = id.slice(5);
+	return viteId.startsWith("__x00__") ? `\0${viteId.slice(7)}` : viteId;
+}
 function assertModuleFound(tag, str = "") {
 	const module = VirtualModule.findModule(tag, str);
 	if (!module) throw require_packageUtils.createModuleFederationError(`Module Federation shared module '${str}' not found. Please ensure it's installed as a dependency in your package.json.`);
 	return module;
 }
-var VirtualModule = class {
+function normalizeVirtualModuleId(id) {
+	const decoded = decodeViteId(id).replace(/^\0+/, "");
+	const queryIndex = decoded.indexOf("?");
+	const hashIndex = decoded.indexOf("#");
+	const endIndex = queryIndex === -1 ? hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
+	return endIndex === -1 ? decoded : decoded.slice(0, endIndex);
+}
+var VirtualModule = class VirtualModule {
 	name;
 	tag;
 	suffix;
 	inited = false;
 	code;
-	static findModule(tag, str = "") {
+	static findName(tag, str = "") {
 		if (!patternMap[tag]) patternMap[tag] = new RegExp(`(.*${require_packageUtils.packageNameEncode(tag)}(.+?)${require_packageUtils.packageNameEncode(tag)}.*)`);
-		const moduleName = (str.match(patternMap[tag]) || [])[2];
-		if (moduleName) return cacheMap[tag][require_packageUtils.packageNameDecode(moduleName)];
+		const moduleName = (normalizeVirtualModuleId(str).match(patternMap[tag]) || [])[2];
+		return moduleName ? require_packageUtils.packageNameDecode(moduleName) : void 0;
+	}
+	static findModule(tag, str = "") {
+		const moduleName = VirtualModule.findName(tag, str);
+		return moduleName ? cacheMap[tag][moduleName] : void 0;
 	}
 	static findById(id) {
-		const normalized = id.replace(/^\0+/, "").replace(/^\/@id\//, "").replace(/^__x00__/, "").replace(/[?#].*$/, "");
+		const normalized = normalizeVirtualModuleId(id);
 		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 = "") {
@@ -749,11 +776,9 @@ function getPackageEsmEntryPath(pkg) {
 		resolveSubpathWithRequire: false
 	}) || resolvePackageEntryFromProjectRoot(pkg);
 }
-function getEsmNamedExports(pkg) {
+function getEsmNamedExportsFromFile(entryPath) {
 	let source = "";
-	let entryPath;
 	try {
-		entryPath = getPackageEsmEntryPath(pkg);
 		if (!entryPath) return [];
 		const { initSync, parse } = localRequire("es-module-lexer");
 		initSync();
@@ -768,6 +793,48 @@ function getEsmNamedExports(pkg) {
 		return source ? getNamedExportsViaRegex(source, entryPath) : [];
 	}
 }
+function getEsmNamedExports(pkg) {
+	return getEsmNamedExportsFromFile(getPackageEsmEntryPath(pkg));
+}
+function resolveConfiguredImportPath(importSource) {
+	if (pathe.default.isAbsolute(importSource)) return resolveFileLikeModule(importSource);
+	const projectRoot = require_packageUtils.getPackageDetectionCwd();
+	if (importSource.startsWith(".")) return resolveFileLikeModule(pathe.default.resolve(projectRoot, importSource));
+	const esmEntry = require_packageUtils.getInstalledPackageEntry(importSource, {
+		conditions: [
+			"browser",
+			"import",
+			"module",
+			"default"
+		],
+		resolveSubpathWithRequire: false
+	});
+	if (esmEntry) return esmEntry;
+	try {
+		return (0, module$1.createRequire)(new URL(`file://${pathe.default.join(projectRoot, "package.json")}`)).resolve(importSource);
+	} catch {
+		return;
+	}
+}
+function resolveFileLikeModule(filePath) {
+	if ((0, fs.existsSync)(filePath) && !(0, fs.statSync)(filePath).isDirectory()) return filePath;
+	const extensions = [
+		".ts",
+		".tsx",
+		".js",
+		".jsx",
+		".mjs",
+		".mts"
+	];
+	for (const ext of extensions) {
+		const candidate = filePath + ext;
+		if ((0, fs.existsSync)(candidate) && !(0, fs.statSync)(candidate).isDirectory()) return candidate;
+	}
+	for (const ext of extensions) {
+		const candidate = pathe.default.join(filePath, "index" + ext);
+		if ((0, fs.existsSync)(candidate) && !(0, fs.statSync)(candidate).isDirectory()) return candidate;
+	}
+}
 function resolveRelativeModule(filePath, specifier) {
 	const dir = pathe.default.dirname(filePath);
 	const exact = pathe.default.resolve(dir, specifier);
@@ -837,6 +904,14 @@ function getPackageNamedExports(pkg) {
 		return getEsmNamedExports(pkg);
 	}
 }
+function getSharedNamedExports(pkg, shareItem) {
+	const configuredImport = shareItem?.shareConfig.import;
+	if (typeof configuredImport === "string") {
+		const configuredNamedExports = getEsmNamedExportsFromFile(resolveConfiguredImportPath(configuredImport));
+		if (configuredNamedExports.length > 0) return configuredNamedExports;
+	}
+	return getPackageNamedExports(pkg);
+}
 function getLocalProviderImportPath(pkg) {
 	try {
 		const resolved = (0, module$1.createRequire)(new URL(`file://${pathe.default.join(require_packageUtils.getPackageDetectionCwd(), "package.json")}`)).resolve(pkg);
@@ -907,6 +982,20 @@ function writePreBuildLibPath(pkg, shareItem) {
 	if (!preBuildCacheMap[pkg]) preBuildCacheMap[pkg] = new VirtualModule(pkg, PREBUILD_TAG, ".js");
 	preBuildShareItemMap[pkg] = shareItem;
 	const importSource = getConcreteSharedImportSource(pkg, shareItem) || pkg;
+	if (pkg === "react/compiler-runtime") {
+		preBuildCacheMap[pkg].writeSync(`
+    const __mfCacheGlobalKey = "__mf_module_cache__";
+    export const c = function(size) {
+      const cache = globalThis[__mfCacheGlobalKey]?.share;
+      const sharedReact = cache?.['react'];
+      const reactExports = sharedReact?.default ?? sharedReact;
+      const internals = reactExports?.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+      return internals?.H?.useMemoCache(size);
+    };
+    export default { c };
+  `, true);
+		return;
+	}
 	if (pkg === "react/jsx-dev-runtime") {
 		preBuildCacheMap[pkg].writeSync(`
     import __mfPrebuildDefault from ${escapeGeneratedStringLiteral(importSource)};
@@ -930,7 +1019,7 @@ function writePreBuildLibPath(pkg, shareItem) {
   `, true);
 		return;
 	}
-	const namedExports = getPackageNamedExports(pkg);
+	const namedExports = getSharedNamedExports(pkg, shareItem);
 	if (namedExports.length > 0) {
 		const namedExportVars = namedExports.map((_name, i) => `__mf_${i}`);
 		const declarations = namedExports.map((name, i) => `const ${namedExportVars[i]} = __mfPrebuildExports[${escapeGeneratedStringLiteral(name)}];`).join("\n    ");
@@ -970,7 +1059,28 @@ function getLoadShareModulePath(pkg, isRolldown) {
 	if (!loadShareCacheMap[pkg]) getLoadShareImportId(pkg, isRolldown);
 	return loadShareCacheMap[pkg].getImportId();
 }
-function generateDeferredHostProvidedExports(namedExports, pkg) {
+function toViteOptimizedDepVirtualId(id) {
+	return toViteEncodedId(id);
+}
+function getCachedLoadSharePkg(id) {
+	const normalized = normalizeVirtualModuleId(id);
+	if (!normalized.startsWith("virtual:mf:")) return;
+	const pkg = VirtualModule.findName(LOAD_SHARE_TAG, normalized);
+	if (!pkg) return;
+	return pkg;
+}
+function materializeCachedLoadShareModule(options) {
+	const pkg = getCachedLoadSharePkg(options.id);
+	if (!pkg) return;
+	const key = options.findSharedKey(pkg, options.shared);
+	if (!key) return;
+	const shareItem = options.shared[key];
+	writeLoadShareModule(pkg, shareItem, options.command, options.isRolldown);
+	if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(pkg, shareItem);
+	options.addUsedShares(pkg);
+	options.writeLocalSharedImportMap();
+}
+function generateDeferredHostProvidedExports(namedExports, pkg, cacheKey) {
 	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      ");
@@ -979,10 +1089,10 @@ function generateDeferredHostProvidedExports(namedExports, pkg) {
     const __mfApplyHostProvidedExports = (exportModule) => {
       ${assignments}
     };
-    let exportModule = __mfModuleCache.share[${escapeGeneratedStringLiteral(pkg)}];
+    let exportModule = __mfModuleCache.share[${escapeGeneratedStringLiteral(cacheKey)}];
     if (exportModule === undefined) {
       initPromise.then(() => {
-        exportModule = __mfModuleCache.share[${escapeGeneratedStringLiteral(pkg)}];
+        exportModule = __mfModuleCache.share[${escapeGeneratedStringLiteral(cacheKey)}];
         if (exportModule === undefined) {
           throw new Error("[Module Federation] Shared module ${pkg} was imported before federation bootstrap finished.");
         }
@@ -1013,13 +1123,14 @@ const normalizeLocalShareModuleCode = `const __mfNormalizeShareModule = (mod) =>
 function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
 	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = new VirtualModule(pkg, LOAD_SHARE_TAG, ".mjs");
 	const importLine = getRuntimeModuleCacheBootstrapCode();
+	const cacheKey = require_packageUtils.getSharedCacheKey(pkg, shareItem);
 	if (shareItem.shareConfig.import === false) {
 		const namedExports = getPackageNamedExports(pkg);
 		let exportLine;
-		if (namedExports.length > 0) exportLine = generateDeferredHostProvidedExports(namedExports, pkg);
+		if (namedExports.length > 0) exportLine = generateDeferredHostProvidedExports(namedExports, pkg, cacheKey);
 		else {
 			require_packageUtils.mfWarn(`Shared dependency "${pkg}" has import: false but is not installed locally.\n  Named imports (e.g. import { ... } from '${pkg}') will not work in production builds.\n  Install it as a devDependency to enable named export detection.`);
-			exportLine = generateDeferredHostProvidedExports([], pkg);
+			exportLine = generateDeferredHostProvidedExports([], pkg, cacheKey);
 		}
 		loadShareCacheMap[pkg].writeSync(`
     ${getRuntimeInitPromiseBootstrapCode()}
@@ -1036,7 +1147,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
 	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);
+	const namedExports = getSharedNamedExports(pkg, shareItem);
 	let exportLine;
 	if (namedExports.length > 0) {
 		const destructure = `const { ${namedExports.map((name, i) => `${name}: __mf_${i}`).join(", ")} } = exportModule;`;
@@ -1060,11 +1171,11 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
     ${devDynamicImportLine}
     ${importLine}
     ${normalizeLocalShareModuleCode}
-    let exportModule = __mfModuleCache.share[${escapeGeneratedStringLiteral(pkg)}]
+    let exportModule = __mfModuleCache.share[${escapeGeneratedStringLiteral(cacheKey)}]
     if (exportModule === undefined) {
       ${usesLazyLocalFallback ? `exportModule = __mfNormalizeShareModule(await import(${escapeGeneratedStringLiteral(lazyLocalFallbackSource)}));
-      __mfModuleCache.share[${escapeGeneratedStringLiteral(pkg)}] = exportModule;` : `exportModule = __mfNormalizeShareModule(__mfLocalShare);
-      __mfModuleCache.share[${escapeGeneratedStringLiteral(pkg)}] = exportModule;`}
+      __mfModuleCache.share[${escapeGeneratedStringLiteral(cacheKey)}] = exportModule;` : `exportModule = __mfNormalizeShareModule(__mfLocalShare);
+      __mfModuleCache.share[${escapeGeneratedStringLiteral(cacheKey)}] = exportModule;`}
     }
     ${exportLine}
   `, true);
@@ -1136,7 +1247,7 @@ function generateLocalSharedImportMap() {
             version: ${JSON.stringify(shareItem.version)},
             scope: [${JSON.stringify(shareItem.scope)}],
             loaded: false,
-            from: ${JSON.stringify(options.internalName)},
+            from: ${JSON.stringify(options.name)},
             async get () {
               if (${shareItem.shareConfig.import === false}) {
                 throw new Error(\`[Module Federation] Shared module '\${${JSON.stringify(key)}}' must be provided by host\`);
@@ -1218,8 +1329,9 @@ function getShareItemForPreload(pkg) {
 	if (isExplicitSharedKey(pkg)) return shared[pkg];
 	if (isExplicitSharedKey(wildcardKey)) return shared[wildcardKey];
 }
-function generateSharedCacheSeedItem(pkg, importPath) {
-	return `if (__mfModuleCache.share[${JSON.stringify(pkg)}] === undefined) {
+function generateSharedCacheSeedItem(pkg, shareItem, importPath) {
+	const cacheKey = require_packageUtils.getSharedCacheKey(pkg, shareItem);
+	return `if (__mfModuleCache.share[${JSON.stringify(cacheKey)}] === undefined) {
         const mod = await import(${JSON.stringify(importPath)});
         ${normalizeRuntimeShareCode}
         const normalizedModule = __mfNormalizeRuntimeShare(mod);
@@ -1228,7 +1340,7 @@ function generateSharedCacheSeedItem(pkg, importPath) {
           value: true,
           enumerable: false
         });
-        __mfModuleCache.share[${JSON.stringify(pkg)}] = exportModule;
+        __mfModuleCache.share[${JSON.stringify(cacheKey)}] = exportModule;
       }`;
 }
 const normalizeRuntimeShareCode = `const __mfNormalizeRuntimeShare = (mod) => {
@@ -1246,7 +1358,7 @@ function generateDirectSharedCacheSeedCode(command = "build") {
 	return getOrderedUsedShares().map((pkg) => {
 		const shareItem = getShareItemForPreload(pkg);
 		if (!shareItem || shareItem.shareConfig.import === false) return null;
-		return generateSharedCacheSeedItem(pkg, command === "serve" ? getLocalSharedPackagePath(pkg, shareItem) : getDirectSharedCacheSeedImportPath(pkg, shareItem));
+		return generateSharedCacheSeedItem(pkg, shareItem, command === "serve" ? getLocalSharedPackagePath(pkg, shareItem) : getDirectSharedCacheSeedImportPath(pkg, shareItem));
 	}).filter((item) => item !== null).join("\n");
 }
 function getBrowserImportPath(importPath) {
@@ -1268,7 +1380,7 @@ function generateHostAutoInitSharedCacheSeedCode(command = "build") {
 	if (command === "build") return "";
 	return getHostAutoInitSharedSeedItems().map(({ pkg, shareItem }) => {
 		if (!shareItem) return null;
-		return generateSharedCacheSeedItem(pkg, getBrowserImportPath(getDirectSharedCacheSeedImportPath(pkg, shareItem)));
+		return generateSharedCacheSeedItem(pkg, shareItem, getBrowserImportPath(getDirectSharedCacheSeedImportPath(pkg, shareItem)));
 	}).filter((item) => item !== null).join("\n");
 }
 const REMOTE_ENTRY_ID = "virtual:mf-REMOTE_ENTRY_ID";
@@ -1306,7 +1418,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   ${getRuntimeModuleCacheBootstrapCode()}
   const initTokens = {}
   const shareScopeName = ${JSON.stringify(options.shareScope)}
-  const mfName = ${JSON.stringify(options.internalName)}
+  const mfName = ${JSON.stringify(options.name)}
   let localSharedImportMapPromise
   let exposesMapPromise
   const shouldRetrySharedInitError = ${command !== "build"} && ((error) => {
@@ -1348,6 +1460,28 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
 
   async function init(shared = {}, initScope = []) {
     const {usedShared, usedRemotes} = await getLocalSharedImportMap()
+    try {
+      const allInstances = globalThis.__FEDERATION__?.__SHARE__;
+      if (allInstances) {
+        ${normalizeRuntimeShareCode}
+        for (const [, scopes] of Object.entries(allInstances)) {
+          const scopeShare = scopes?.['${options.shareScope}'];
+          if (!scopeShare) continue;
+          for (const [pkg, versionMap] of Object.entries(scopeShare)) {
+            for (const [version, provider] of Object.entries(versionMap)) {
+              if (!provider.lib) continue;
+              const cacheKey = provider.shareConfig?.singleton ? pkg : \`\${pkg}@\${version}\`;
+              if (__mfModuleCache.share[cacheKey] !== undefined) continue;
+              const mod = typeof provider.lib === "function" ? provider.lib() : provider.lib;
+              const resolved = await Promise.resolve(mod);
+              __mfModuleCache.share[cacheKey] = __mfNormalizeRuntimeShare(resolved);
+            }
+          }
+        }
+      }
+    } catch (e) {
+      console.error('[Module Federation] Failed to bridge external shared modules', e)
+    }
     ${generateDirectSharedCacheSeedCode(command)}
     const __browserPlugins = [${pluginImportNames.filter((item) => !isSsrOnlyPlugin(item[1])).map((item) => `${item[0]}(${item[2]})`).join(", ")}];
     const __ssrPlugins = typeof globalThis.window === 'undefined'
@@ -1384,7 +1518,8 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       console.error('[Module Federation]', e)
     }
     for (const [pkg, share] of Object.entries(usedShared)) {
-      if (share.shareConfig?.import !== false || __mfModuleCache.share[pkg] !== undefined) continue;
+      const cacheKey = share.shareConfig?.singleton || !share.version ? pkg : \`\${pkg}@\${share.version}\`;
+      if (share.shareConfig?.import !== false || __mfModuleCache.share[cacheKey] !== undefined) continue;
       ${normalizeRuntimeShareCode}
       const versions = shared?.[pkg];
       const provider = versions && versions[Object.keys(versions)[0]];
@@ -1392,7 +1527,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       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);
+      __mfModuleCache.share[cacheKey] = __mfNormalizeRuntimeShare(resolved);
     }
     return initRes
   }
@@ -1426,7 +1561,8 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build") {
           ${normalizeRuntimeShareCode}
           ${shouldPreloadShares ? `
           for (const [pkg, share] of Object.entries(usedShared)) {
-            if (__mfModuleCache.share[pkg] !== undefined) {
+            const cacheKey = share.shareConfig?.singleton || !share.version ? pkg : \`\${pkg}@\${share.version}\`;
+            if (__mfModuleCache.share[cacheKey] !== undefined) {
               continue;
             }
             await runtime.loadShare(pkg, {
@@ -1434,7 +1570,7 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build") {
             }).then((factory) => {
               const mod = typeof factory === "function" ? factory() : factory;
               return Promise.resolve(mod).then((resolved) => {
-                __mfModuleCache.share[pkg] = __mfNormalizeRuntimeShare(resolved);
+                __mfModuleCache.share[cacheKey] = __mfNormalizeRuntimeShare(resolved);
               });
             });
           }
@@ -1802,7 +1938,7 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 		return inject === "entry" || !htmlFilePath;
 	}
 	function normalizeDevHtmlProxyId(id) {
-		return id.replace(/^\0/, "").replace(/^\/@id\//, "").replace(/^__x00__/, "");
+		return decodeViteId(id).replace(/^\0/, "");
 	}
 	function normalizeModuleId(id) {
 		return id.split("?")[0].replace(/\\/g, "/");
@@ -1836,7 +1972,7 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 		configResolved(config) {
 			viteConfig = config;
 			const resolvedEntryPath = getEntryPath();
-			if (resolvedEntryPath.startsWith("virtual:mf")) devEntryPath = config.base + "@id/" + resolvedEntryPath;
+			if (resolvedEntryPath.startsWith("virtual:mf")) devEntryPath = config.base + VITE_ID_PREFIX.slice(1) + resolvedEntryPath;
 			else {
 				const normalized = resolvedEntryPath.replace(/\\\\?/g, "/");
 				const root = config.root.replace(/\\\\?/g, "/").replace(/\/$/, "");
@@ -1877,10 +2013,10 @@ 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/__x00__${DEV_HTML_PROXY_PREFIX}${new URLSearchParams({
+					return toViteEncodedId(`${DEV_HTML_PROXY_PREFIX}${new URLSearchParams({
 						init: sanitizeDevEntryPath(stripBase(devEntryPath)),
 						entry: sanitizeDevEntryPath(stripBase(originalSrc))
-					}).toString()}`;
+					}).toString()}`);
 				});
 				return html === c ? injectEntryScript(c, stripBase(devEntryPath)) : html;
 			}
@@ -2826,9 +2962,19 @@ const processModuleAssets = (bundle, filesMap, moduleMatcher, options = {}) => {
 				foundCssViaMetadata = true;
 			}
 			if (!foundCssViaMetadata && chunkContainsCssModules(fileData.modules)) for (const cssAsset of Array.from(bundleCssAssets)) trackAsset(filesMap, matchKey, cssAsset, false, "css");
-			if (fileData.dynamicImports) for (const dynamicImport of fileData.dynamicImports) {
-				if (!bundle[dynamicImport]) continue;
-				trackAsset(filesMap, matchKey, dynamicImport, true, isCSSFile(dynamicImport) ? "css" : "js");
+			const visited = /* @__PURE__ */ new Set();
+			const queue = [fileName];
+			for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
+				const cur = queue[queueIndex];
+				if (visited.has(cur)) continue;
+				visited.add(cur);
+				const chunk = bundle[cur];
+				if (!chunk || chunk.type !== "chunk") continue;
+				if (chunk.dynamicImports) for (const dynamicImport of chunk.dynamicImports) {
+					if (!bundle[dynamicImport]) continue;
+					trackAsset(filesMap, matchKey, dynamicImport, true, isCSSFile(dynamicImport) ? "css" : "js");
+				}
+				if (chunk.imports) for (const imp of chunk.imports) queue.push(imp);
 			}
 		}
 	}
@@ -2876,7 +3022,11 @@ const buildFileToShareKeyMap = async (shareKeys, resolveFn) => {
 //#endregion
 //#region src/utils/pathNormalization.ts
 const COMMON_SHARED_SUBPATHS = {
-	react: ["react/jsx-runtime", "react/jsx-dev-runtime"],
+	react: [
+		"react/jsx-runtime",
+		"react/jsx-dev-runtime",
+		"react/compiler-runtime"
+	],
 	"react-dom": [
 		"react-dom/client",
 		"react-dom/server",
@@ -2929,7 +3079,7 @@ function getCommonSharedSubpathFromNodeModulePath(source, sharedKey) {
 */
 function resolvePublicPath(options, viteBase, originalBase) {
 	if (options.publicPath && options.publicPath !== "auto") return options.publicPath;
-	if (originalBase === "") return "auto";
+	if (!originalBase) return "auto";
 	if (viteBase) return ensureTrailingSlash(viteBase);
 	return "auto";
 }
@@ -3011,11 +3161,11 @@ function generateRemoteEntrySSR(options) {
    */
   async function init(shared = {}, initScope = []) {
     const initRes = runtimeInit({
-      name: ${JSON.stringify(options.internalName)},
+      name: ${JSON.stringify(options.name)},
       remotes: [],
       shared: {},
     });
-    const initToken = { from: ${JSON.stringify(options.internalName)} };
+    const initToken = { from: ${JSON.stringify(options.name)} };
     if (initScope.indexOf(initToken) >= 0) return;
     initScope.push(initToken);
     initRes.initShareScopeMap(${JSON.stringify(options.shareScope)}, shared);
@@ -3431,7 +3581,8 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 				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 resolvedPublicPath = resolvePublicPath(options, viteConfig.base);
+						const publicPath = JSON.stringify((resolvedPublicPath === "auto" ? "/" : resolvedPublicPath) + options.filename);
 						const fallbackOrigin = `//${host}:${viteConfig.server?.port}`;
 						const ssrRemoteEntry = "data:text/javascript," + encodeURIComponent("export async function init(){return {loadRemote:async()=>({}),loadShare:async()=>({})}}");
 						return `
@@ -3595,6 +3746,7 @@ function isBuildConfigImporter(importer) {
 }
 function matchesSharedSource(source, key) {
 	const keyBase = key.endsWith("/") ? key.slice(0, -1) : key;
+	if (keyBase === "vue" && (source === "vue/dist/vue.esm-bundler.js" || source === "vue/dist/vue.runtime.esm-bundler.js")) return true;
 	if (key.endsWith("/")) return source === keyBase || source.startsWith(`${keyBase}/`);
 	if (getCommonSharedSubpaths(keyBase).includes(source)) return true;
 	return source === keyBase;
@@ -3606,9 +3758,16 @@ function findSharedKey(source, shared) {
 function findSharedKeyForSource(source, shared) {
 	const key = findSharedKey(source, shared);
 	if (key) return key;
+	const explicitSharedSubpathKeys = Object.keys(shared || {}).filter((sharedKey) => require_packageUtils.getPackageName(sharedKey) !== sharedKey && !sharedKey.endsWith("/"));
 	if (isNodeModulePath(source)) {
-		const explicitSubpathKey = getMatchingNodeModuleSubpath(source, Object.keys(shared || {}).filter((sharedKey) => sharedKey.includes("/") && !sharedKey.endsWith("/")));
+		const explicitSubpathKey = getMatchingNodeModuleSubpath(source, explicitSharedSubpathKeys);
 		if (explicitSubpathKey) return explicitSubpathKey;
+		const normalizedSource = normalizeNodeModulePath(source);
+		const explicitSubpathEntryKey = explicitSharedSubpathKeys.find((sharedKey) => {
+			const entry = require_packageUtils.getInstalledPackageEntry(sharedKey, { cwd: require_packageUtils.getPackageDetectionCwd() });
+			return entry ? normalizeNodeModulePath(entry) === normalizedSource : false;
+		});
+		if (explicitSubpathEntryKey) return explicitSubpathEntryKey;
 	}
 	const packageName = require_packageUtils.getPackageNameFromNodeModulePath(source);
 	return packageName ? findSharedKey(packageName, shared) : void 0;
@@ -3653,6 +3812,7 @@ function proxySharedModule(options) {
 	let useRolldown = false;
 	const savePrebuild = new PromiseStore();
 	let devServer;
+	const materializedLoadShareSources = /* @__PURE__ */ new Set();
 	return [
 		{
 			name: "generateLocalSharedImportMap",
@@ -3709,6 +3869,12 @@ function proxySharedModule(options) {
 			name: "proxyPreBuildShared:resolve-shared-loadShare",
 			enforce: "pre",
 			async resolveId(source, importer) {
+				function shouldSkipTaggedImporterProxy(sharedKey, tag) {
+					if (!importer?.includes(tag)) return false;
+					const taggedModule = VirtualModule.findModule(tag, importer);
+					if (!taggedModule) return true;
+					return taggedModule.name === sharedKey || matchesSharedSource(source, taggedModule.name);
+				}
 				const key = findSharedKeyForSource(source, shared);
 				if (!key) return;
 				if (useDirectReactImport && key === "react") return;
@@ -3717,15 +3883,18 @@ function proxySharedModule(options) {
 				if (useDirectReactImport && source === "react") return;
 				if (importer && importer.includes("localSharedImportMap")) return;
 				if (importer && (importer.includes("hostAutoInit") || importer.includes("__H_A_I__"))) return;
-				if (importer && importer.includes("__loadShare__")) return;
-				if (importer && importer.includes("__prebuild__")) return;
-				const shareSource = isNodeModulePath(source) ? getCommonSharedSubpathFromNodeModulePath(source, key) || key : source;
+				if (shouldSkipTaggedImporterProxy(key, "__loadShare__")) return;
+				if (shouldSkipTaggedImporterProxy(key, "__prebuild__")) return;
+				const shareSource = key === "vue" && source.startsWith("vue/dist/") ? key : isNodeModulePath(source) ? getCommonSharedSubpathFromNodeModulePath(source, key) || key : source;
 				const loadSharePath = getLoadShareModulePath(shareSource, useRolldown);
-				writeLoadShareModule(shareSource, shared[key], _command, useRolldown);
-				if (shared[key].shareConfig.import !== false) writePreBuildLibPath(shareSource, shared[key]);
-				addUsedShares(shareSource);
-				writeLocalSharedImportMap();
-				refreshHostAutoInit();
+				if (!materializedLoadShareSources.has(shareSource)) {
+					materializedLoadShareSources.add(shareSource);
+					writeLoadShareModule(shareSource, shared[key], _command, useRolldown);
+					if (shared[key].shareConfig.import !== false) writePreBuildLibPath(shareSource, shared[key]);
+					addUsedShares(shareSource);
+					writeLocalSharedImportMap();
+					refreshHostAutoInit();
+				}
 				return this.resolve(loadSharePath, importer, { skipSelf: true });
 			}
 		},
@@ -3806,19 +3975,8 @@ function applyRewrites(code, imports, id) {
 	const ms = new CodeRewriter(code);
 	let changed = false;
 	let counter = 0;
-	for (const imp of imports) switch (imp.kind) {
-		case "static": {
-			const src = JSON.stringify(imp.source);
-			if (imp.namespaceLocal && !imp.defaultLocal && imp.named.length === 0) ms.overwrite(imp.start, imp.end, `import { __moduleExports as ${imp.namespaceLocal} } from ${src};`);
-			else {
-				const nsId = `__mf_ns_${counter++}`;
-				const importParts = [];
-				if (imp.defaultLocal) importParts.push(`default as ${imp.defaultLocal}`);
-				importParts.push(`__moduleExports as ${nsId}`);
-				let rewrite = `import { ${importParts.join(", ")} } from ${src};`;
-				if (imp.named.length > 0) {
-					const isProxyId = `__mf_is_proxy_${counter++}`;
-					const namedProxyHelper = `function __mfCreateNamedRemoteProxy(ns, key) {
+	let namedProxyHelperDeclared = false;
+	const namedProxyHelper = `function __mfCreateNamedRemoteProxy(ns, key) {
   const target = function (...args) {
     const value = ns[key];
     return typeof value === "function" ? value.apply(this, args) : value;
@@ -3836,13 +3994,29 @@ function applyRewrites(code, imports, id) {
     }
   });
 }`;
+	for (const imp of imports) switch (imp.kind) {
+		case "static": {
+			const src = JSON.stringify(imp.source);
+			if (imp.namespaceLocal && !imp.defaultLocal && imp.named.length === 0) ms.overwrite(imp.start, imp.end, `import { __moduleExports as ${imp.namespaceLocal} } from ${src};`);
+			else {
+				const nsId = `__mf_ns_${counter++}`;
+				const importParts = [];
+				if (imp.defaultLocal) importParts.push(`default as ${imp.defaultLocal}`);
+				importParts.push(`__moduleExports as ${nsId}`);
+				let rewrite = `import { ${importParts.join(", ")} } from ${src};`;
+				if (imp.named.length > 0) {
+					const isProxyId = `__mf_is_proxy_${counter++}`;
 					const tempNames = imp.named.map((_s) => `__mf_named_${counter++}`);
 					const destructParts = imp.named.map((s, index) => `${s.imported}: ${tempNames[index]}`);
 					const bindingLines = imp.named.map((s, index) => {
 						const temp = tempNames[index];
 						return `const ${s.local} = ${isProxyId} ? __mfCreateNamedRemoteProxy(${nsId}, ${JSON.stringify(s.imported)}) : ${temp};`;
 					});
-					rewrite += `\n${namedProxyHelper}\nconst ${isProxyId} = ${nsId} && ${nsId}.__mf_is_remote_proxy;`;
+					if (!namedProxyHelperDeclared) {
+						rewrite += `\n${namedProxyHelper}`;
+						namedProxyHelperDeclared = true;
+					}
+					rewrite += `\nconst ${isProxyId} = ${nsId} && ${nsId}.__mf_is_remote_proxy;`;
 					rewrite += `\nconst { ${destructParts.join(", ")} } = ${isProxyId} ? {} : ${nsId};`;
 					rewrite += `\n${bindingLines.join("\n")}`;
 				}
@@ -4244,7 +4418,7 @@ function pluginSSRRemoteEntry(options) {
 					try {
 						result = await fetchFn(id, importer, opts);
 					} catch (fetchErr) {
-						const bareId = id.startsWith("/@id/") ? id.slice(5).replace(/^__x00__/, "\0") : id;
+						const bareId = decodeViteId(id);
 						try {
 							const { createRequire } = await import("module");
 							const resolved = createRequire(new URL(`file://${server.config.root}/package.json`)).resolve(bareId.replace(/^\0/, ""));
@@ -4499,6 +4673,8 @@ var normalizeOptimizeDeps_default = {
 //#endregion
 //#region src/index.ts
 const patchedManualChunks = /* @__PURE__ */ new WeakSet();
+const PRELOAD_HELPER_CHUNK = "vite-preload-helper";
+const PRELOAD_HELPER_TEST = /\0?vite\/preload-helper/;
 function normalizeVinextRscPreloadHints(code) {
 	return code.replace(/(:HL\[[^\]\n]*?,)"stylesheet"/g, "$1\"style\"").replace(/(:HL\[[^\]\n]*?,)\\"stylesheet\\"/g, "$1\\\"style\\\"");
 }
@@ -4566,6 +4742,14 @@ function isFederationHtmlPreloadDependency(dep, includeSharedRuntime = false) {
 	if (file.includes("__mfe_internal__") || file.includes("virtual_mf-") || file.includes("virtualExposes") || file.includes("localSharedImportMap") || file.includes("hostInit")) return true;
 	return includeSharedRuntime && (file.includes("preload-helper") || file.includes("rolldown-runtime") || file.startsWith("dist-"));
 }
+function canResolveSharedSubpath(subpath, projectRoot) {
+	try {
+		(0, module$1.createRequire)(new URL(`file://${projectRoot}/package.json`)).resolve(subpath);
+		return true;
+	} catch {
+		return false;
+	}
+}
 /**
 * 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
@@ -4632,7 +4816,7 @@ function createEarlyVirtualModulesPlugin(options) {
 						optimizeDeps.esbuildOptions.plugins.push({
 							name: "module-federation:optimize-shared-proxy",
 							setup(build) {
-								build.onResolve({ filter: /^virtual:mf:/ }, (args) => ({
+								build.onResolve({ filter: createViteEncodedIdPrefixRegExp("virtual:mf:") }, (args) => ({
 									path: args.path,
 									external: true
 								}));
@@ -4652,15 +4836,15 @@ function createEarlyVirtualModulesPlugin(options) {
 									const key = findSharedKey(args.path, shared);
 									if (!key) return;
 									const shareItem = shared[key];
-									const loadSharePath = getLoadShareModulePath(args.path, isRolldown);
+									const optimizedLoadSharePath = toViteOptimizedDepVirtualId(getLoadShareModulePath(args.path, isRolldown));
 									writeLoadShareModule(args.path, shareItem, _command, isRolldown);
 									if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(args.path, shareItem);
 									addUsedShares(args.path);
 									return {
 										loader: "js",
 										resolveDir: root,
-										contents: `import * as __mfShared from ${JSON.stringify(loadSharePath)};
-export * from ${JSON.stringify(loadSharePath)};
+										contents: `import * as __mfShared from ${JSON.stringify(optimizedLoadSharePath)};
+export * from ${JSON.stringify(optimizedLoadSharePath)};
 export default __mfShared.default ?? __mfShared;`
 									};
 								});
@@ -4674,9 +4858,11 @@ export default __mfShared.default ?? __mfShared;`
 						if (_command === "serve" && shareItem.shareConfig?.import !== false) {
 							const optimizeDeps = config.optimizeDeps ??= {};
 							optimizeDeps.include ??= [];
+							optimizeDeps.exclude ??= [];
 							for (const subpath of getCommonSharedSubpaths(key)) {
 								writePreBuildLibPath(subpath, shareItem);
-								optimizeDeps.include.push(subpath);
+								if (canResolveSharedSubpath(subpath, root)) optimizeDeps.include.push(subpath);
+								else optimizeDeps.exclude.push(subpath);
 							}
 						}
 						continue;
@@ -4700,7 +4886,8 @@ export default __mfShared.default ?? __mfShared;`
 							writeLoadShareModule(subpath, shareItem, _command, isRolldown);
 							writePreBuildLibPath(subpath, shareItem);
 							addUsedShares(subpath);
-							optimizeDeps.include.push(subpath);
+							if (canResolveSharedSubpath(subpath, root)) optimizeDeps.include.push(subpath);
+							else optimizeDeps.exclude.push(subpath);
 						}
 					}
 				}
@@ -4721,6 +4908,7 @@ export default __mfShared.default ?? __mfShared;`
 				"react-dom",
 				"react/jsx-runtime",
 				"react/jsx-dev-runtime",
+				"react/compiler-runtime",
 				"@module-federation/runtime",
 				"@module-federation/runtime-core",
 				"@module-federation/sdk"
@@ -4744,7 +4932,7 @@ export default __mfShared.default ?? __mfShared;`
 const SSR_ONLY_PLUGINS = new Set(["@module-federation/vite/ssrEntryLoader"]);
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [Promise.resolve().then(() => require("./pluginDts-BEOKyKQ-.cjs")).then(({ default: pluginDts }) => pluginDts(options))];
+	return [Promise.resolve().then(() => require("./pluginDts-7EoFboCu.cjs")).then(({ default: pluginDts }) => pluginDts(options))];
 }
 function federation(mfUserOptions) {
 	if (isTestEnv()) return [];
@@ -4761,7 +4949,19 @@ function federation(mfUserOptions) {
 			name: "vite:module-federation-virtual-modules",
 			enforce: "pre",
 			resolveId(id) {
-				const virtualModule = VirtualModule.findById(id);
+				let virtualModule = VirtualModule.findById(id);
+				if (!virtualModule) {
+					materializeCachedLoadShareModule({
+						id,
+						shared: options.shared,
+						command,
+						isRolldown: require_packageUtils.getIsRolldown(this),
+						findSharedKey,
+						addUsedShares,
+						writeLocalSharedImportMap
+					});
+					virtualModule = VirtualModule.findById(id);
+				}
 				if (!virtualModule) return;
 				return virtualModule.getResolvedId();
 			},
@@ -4780,7 +4980,8 @@ function federation(mfUserOptions) {
 			resolveId(id) {
 				const reactServerEntryMap = {
 					"react/jsx-runtime": "react/cjs/react-jsx-runtime.production.js",
-					"react/jsx-dev-runtime": "react/cjs/react-jsx-dev-runtime.production.js"
+					"react/jsx-dev-runtime": "react/cjs/react-jsx-dev-runtime.production.js",
+					"react/compiler-runtime": "react/cjs/react-compiler-runtime.production.js"
 				};
 				if (!(id in reactServerEntryMap)) return;
 				const environmentName = this.environment?.name;
@@ -4882,6 +5083,8 @@ function federation(mfUserOptions) {
 					}
 					if (!output?.codeSplitting || typeof output.codeSplitting !== "object") return;
 					if (!("groups" in output.codeSplitting)) return;
+					const groups = output.codeSplitting.groups;
+					if (Array.isArray(groups) && groups.some((group) => typeof group?.name === "function" && patchedManualChunks.has(group.name))) return;
 					delete output.codeSplitting.groups;
 					if (Object.keys(output.codeSplitting).length === 0) delete output.codeSplitting;
 					if (warnedAboutCodeSplittingGroups) return;
@@ -4889,27 +5092,45 @@ function federation(mfUserOptions) {
 					require_packageUtils.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) => {
+				const applyManualChunks = (output, useCodeSplitting) => {
 					ensureCodeSplitting(output);
 					const isPatchedByPlugin = typeof output.manualChunks === "function" && patchedManualChunks.has(output.manualChunks);
 					if (output.manualChunks && !isPatchedByPlugin && !warnedAboutManualChunks) {
 						warnedAboutManualChunks = true;
 						require_packageUtils.mfWarn("Ignoring `output.manualChunks` because it conflicts with module federation. Module federation transforms shared dependency imports with async init wrappers, and grouping these transformed modules into a single chunk creates circular async dependencies that cause the application to silently hang.");
 					}
-					const mfManualChunks = function(id) {
+					const mfChunkName = function(id) {
 						if (id.includes(runtimeInitId)) return "runtimeInit";
 						if (id.includes("__loadShare__")) {
 							const match = id.match(/([^/\\]+__loadShare__[^/\\]+)/);
 							return match ? match[1] : "loadShare";
 						}
+						return null;
+					};
+					patchedManualChunks.add(mfChunkName);
+					if (!useCodeSplitting) {
+						const mfManualChunks = function(id) {
+							return mfChunkName(id) ?? void 0;
+						};
+						patchedManualChunks.add(mfManualChunks);
+						output.manualChunks = mfManualChunks;
+						return;
+					}
+					const groups = [{
+						name: PRELOAD_HELPER_CHUNK,
+						test: PRELOAD_HELPER_TEST,
+						priority: 100
+					}, { name: mfChunkName }];
+					output.codeSplitting = {
+						...output.codeSplitting || {},
+						groups
 					};
-					patchedManualChunks.add(mfManualChunks);
-					output.manualChunks = mfManualChunks;
+					delete output.manualChunks;
 				};
 				config.build.rollupOptions = config.build.rollupOptions || {};
 				const rollupOutput = config.build.rollupOptions.output;
-				if (Array.isArray(rollupOutput)) rollupOutput.forEach((output) => applyManualChunks(output));
-				else applyManualChunks(config.build.rollupOptions.output ||= {});
+				if (Array.isArray(rollupOutput)) rollupOutput.forEach((output) => applyManualChunks(output, false));
+				else applyManualChunks(config.build.rollupOptions.output ||= {}, false);
 				const buildWithRolldown = config.build;
 				buildWithRolldown.rolldownOptions = buildWithRolldown.rolldownOptions || {};
 				const rolldownOutput = buildWithRolldown.rolldownOptions.output;
@@ -4919,10 +5140,10 @@ function federation(mfUserOptions) {
 					assetFileNames: output.assetFileNames
 				});
 				if (Array.isArray(rolldownOutput)) {
-					rolldownOutput.forEach((output) => applyManualChunks(output));
+					rolldownOutput.forEach((output) => applyManualChunks(output, true));
 					desiredRolldownOutput = rolldownOutput.map((output) => snapshotRolldownOutput(output));
 				} else {
-					applyManualChunks(buildWithRolldown.rolldownOptions.output ||= {});
+					applyManualChunks(buildWithRolldown.rolldownOptions.output ||= {}, true);
 					desiredRolldownOutput = [snapshotRolldownOutput(buildWithRolldown.rolldownOptions.output)];
 				}
 			},