@module-federation/vite 1.16.11 → 1.16.13

package/lib/index.js

@@ -1,6 +1,6 @@
-import { _ as mfWarn, a as getIsRolldown, c as getPackageNameFromNodeModulePath, d as isNuxtProjectRoot, f as packageNameDecode, g as createModuleFederationError, h as setPackageDetectionCwd, i as getInstalledPackageJson, l as getSharedCacheKey, m as resolveImportPath, o as getPackageDetectionCwd, p as packageNameEncode, r as getInstalledPackageEntry, s as getPackageName, u as hasPackageDependency, v as normalizePathForImport, y as rebaseImport } from "./pluginDts-CrSsDUnT.js";
+import { _ as createModuleFederationError, a as getIsRolldown, b as rebaseImport, c as getPackageNameFromNodeModulePath, d as isNuxtProjectRoot, f as packageNameDecode, g as sharedCacheHelperCode, h as setPackageDetectionCwd, i as getInstalledPackageJson, l as getSharedCacheDescriptor, m as resolveImportPath, o as getPackageDetectionCwd, p as packageNameEncode, r as getInstalledPackageEntry, s as getPackageName, u as hasPackageDependency, v as mfWarn, y as normalizePathForImport } from "./pluginDts-CTAHkt4C.js";
 import { createRequire } from "node:module";
-import * as fs$1 from "fs";
+import * as fs$2 from "fs";
 import { existsSync, readFileSync, realpathSync, statSync, writeFileSync } from "fs";
 import { createRequire as createRequire$1 } from "module";
 import * as path$1 from "node:path";
@@ -8,6 +8,7 @@ import path, { basename } from "node:path";
 import { fileURLToPath, pathToFileURL } from "url";
 import { version } from "vite";
 import { createHash } from "node:crypto";
+import * as fs$1 from "node:fs";
 import { existsSync as existsSync$1, readFileSync as readFileSync$1 } from "node:fs";
 import { pathToFileURL as pathToFileURL$1 } from "node:url";
 //#region src/utils/codeRewriter.ts
@@ -360,7 +361,7 @@ function normalizeShared(shared) {
 		const result = {};
 		const packageJsonPath = path$1.join(getPackageDetectionCwd(), "package.json");
 		try {
-			const packageJson = JSON.parse(fs$1.readFileSync(packageJsonPath, "utf-8"));
+			const packageJson = JSON.parse(fs$2.readFileSync(packageJsonPath, "utf-8"));
 			if (packageJson.name === "@module-federation/vite") return result;
 			Object.keys(packageJson.dependencies || {}).filter((key) => shouldAutoShareDependency(key)).forEach((key) => {
 				result[key] = normalizeShareItem(key, {
@@ -434,7 +435,7 @@ function resolveRuntimeImplementation() {
 	const fallback = resolveImportPath("@module-federation/runtime");
 	try {
 		const packageJsonPath = resolveImportPath("@module-federation/runtime/package.json");
-		const packageJson = JSON.parse(fs$1.readFileSync(packageJsonPath, "utf-8"));
+		const packageJson = JSON.parse(fs$2.readFileSync(packageJsonPath, "utf-8"));
 		const importExport = packageJson.exports?.["."];
 		const exportImport = typeof importExport === "object" ? typeof importExport.import === "string" ? importExport.import : importExport.import?.default : void 0;
 		const esmEntry = packageJson.module || exportImport;
@@ -573,6 +574,27 @@ var VirtualModule = class VirtualModule {
 	}
 };
 //#endregion
+//#region src/utils/ssrCapabilities.ts
+/** A browser-safe generated expression that is true only in Node.js. */
+const SERVER_ENV_GUARD = "typeof process !== 'undefined' && !!process.versions && !!process.versions.node";
+/**
+* Single source of truth for SSR-related feature gates.
+*
+* - Vite 8+ dev: ModuleRunner + FetchableDevEnvironment for `/__mf_ssr__/` entries.
+* - Any Vite major on build/preview: HTTP fetch + temp-file import via ssrEntryLoader.
+*/
+function getSsrCapabilities(viteMajor, command, hasRemotes) {
+	if (!hasRemotes) return {
+		enableSsrInitBootstrap: false,
+		injectSsrEntryLoader: false
+	};
+	const supported = command === "build" || command === "serve" && viteMajor >= 8;
+	return {
+		enableSsrInitBootstrap: supported,
+		injectSsrEntryLoader: supported
+	};
+}
+//#endregion
 //#region src/utils/serializeRuntimeOptions.ts
 /**
 * Serializes a JavaScript object into a string of source code that can be evaluated.
@@ -628,7 +650,7 @@ function getExposesCssMapPlaceholder() {
 function getVirtualExposesId(options) {
 	return `virtual:mf-exposes:${`${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
 }
-function generateExposes(options) {
+function generateExposes(options, remoteDependencyMap = {}, command = "build") {
 	return `
     const cssAssetMap = ${JSON.stringify(options.bundleAllCSS ? EXPOSES_CSS_MAP_PLACEHOLDER : {})};
     const injectedCssHrefs = new Set();
@@ -661,8 +683,12 @@ function generateExposes(options) {
           }
           injectedCssHrefs.add(href);
 
+          // Check for any existing stylesheet with the same href, not just
+          // MF-injected ones. This prevents duplicate <link> tags when Vite's
+          // own CSS module injection or MF runtime's createLink has already
+          // created a <link rel="stylesheet"> for the same URL.
           const existingLink = document.querySelector(
-            \`link[rel="stylesheet"][data-mf-href="\${href}"]\`
+            \`link[rel="stylesheet"][href="\${href}"]\`
           );
           if (existingLink) {
             return Promise.resolve();
@@ -672,7 +698,6 @@ function generateExposes(options) {
             const link = document.createElement("link");
             link.rel = "stylesheet";
             link.href = href;
-            link.setAttribute("data-mf-href", href);
             link.onload = () => resolve();
             link.onerror = () => reject(new Error(\`[Module Federation] Failed to load CSS asset: \${href}\`));
             document.head.appendChild(link);
@@ -683,12 +708,22 @@ function generateExposes(options) {
 
     export default {
     ${Object.keys(options.exposes).map((key) => {
+		const remoteDependencyPreloads = (remoteDependencyMap[key] ?? []).map((remoteId) => {
+			const virtualRemote = getRemoteVirtualModule(remoteId, command);
+			return `import(${JSON.stringify(virtualRemote.getImportId())})
+            .then((mod) => mod.__mf_remote_pending)`;
+		}).join(",");
 		return `
         ${JSON.stringify(key)}: async () => {
           await injectCssAssets(${JSON.stringify(key)})
+          await Promise.all([${remoteDependencyPreloads}])
           const importModule = await importExposedModule(
             () => import(${JSON.stringify(options.exposes[key].import)})
           )
+          const dependencyPending = importModule && importModule.__mf_remote_dependency_pending;
+          if (dependencyPending && typeof dependencyPending.then === "function") {
+            await dependencyPending;
+          }
           const exportModule = {}
           Object.assign(exportModule, importModule)
           Object.defineProperty(exportModule, "__esModule", {
@@ -722,7 +757,7 @@ function setSsrRemotes(remotes) {
 }
 function getSsrNoopResolveCode(enableSsrInit, hostInitImportId, initResolveExpression = "initResolve") {
 	if (!enableSsrInit) return "";
-	return `if (typeof window === 'undefined') {
+	return `if (${SERVER_ENV_GUARD}) {
     var _noop = { loadRemote: function() { return Promise.resolve(undefined); }, loadShare: function() { return Promise.resolve(undefined); } };
     ${hostInitImportId ? `import(${JSON.stringify(hostInitImportId)})
       .then(function(mod) { return mod.hostInitPromise; })
@@ -781,7 +816,7 @@ globalThis[globalKey] = {
   };
 }
 ${enableSsrInit ? `
-if (typeof window === 'undefined' && !globalThis[globalKey].ssrInitStarted) {
+if (${SERVER_ENV_GUARD} && !globalThis[globalKey].ssrInitStarted) {
   globalThis[globalKey].ssrInitStarted = true;
   ${getSsrNoopResolveCode(enableSsrInit, hostInitImportId, "globalThis[globalKey].initResolve")}
 }` : ""}
@@ -862,6 +897,9 @@ function escapeGeneratedStringLiteral(value) {
 		}
 	});
 }
+function getSharedCacheDescriptorLiteral(pkg, shareItem) {
+	return JSON.stringify(getSharedCacheDescriptor(pkg, shareItem));
+}
 function isValidJsIdentifier(name) {
 	return JS_IDENTIFIER_REGEX.test(name);
 }
@@ -1031,7 +1069,7 @@ function getSharedNamedExports(pkg, shareItem) {
 }
 function getLocalProviderImportPath(pkg) {
 	try {
-		const resolved = createRequire$1(pathToFileURL(path$1.join(getPackageDetectionCwd(), "package.json"))).resolve(pkg);
+		const resolved = resolveWorkspaceEsmEntry(pkg, createRequire$1(pathToFileURL(path$1.join(getPackageDetectionCwd(), "package.json"))).resolve(pkg));
 		return isWorkspaceFilePath(resolved) ? resolved : void 0;
 	} catch {
 		const resolved = getInstalledPackageEntry(pkg, {
@@ -1052,7 +1090,7 @@ function getProjectResolvedImportPath(pkg) {
 		if (esmEntry) return esmEntry;
 	}
 	try {
-		return createRequire$1(pathToFileURL(path$1.join(getPackageDetectionCwd(), "package.json"))).resolve(pkg);
+		return resolveWorkspaceEsmEntry(pkg, createRequire$1(pathToFileURL(path$1.join(getPackageDetectionCwd(), "package.json"))).resolve(pkg));
 	} catch {
 		return;
 	}
@@ -1065,6 +1103,30 @@ function isWorkspaceFilePath(resolved) {
 	} catch {}
 	return !realResolved.includes("/node_modules/") && !realResolved.includes("\\node_modules\\");
 }
+/**
+* When createRequire resolves a workspace package to a CJS entry (e.g. dist/index.cjs),
+* re-resolve via getInstalledPackageEntry with ESM-preferring conditions.
+*
+* Workspace packages produce browser code, so they must use the ESM build — CJS files
+* contain `module.exports` which is undefined in the browser. createRequire().resolve()
+* follows Node.js CJS conditions ["node", "require"], which matches exports["."].require.default
+* and returns the .cjs path for packages with dual ESM/CJS exports.
+*/
+function resolveWorkspaceEsmEntry(pkg, resolved, cwd = getPackageDetectionCwd()) {
+	if (!isWorkspaceFilePath(resolved)) return resolved;
+	const esmEntry = getInstalledPackageEntry(pkg, {
+		cwd,
+		conditions: [
+			"browser",
+			"import",
+			"module",
+			"default"
+		],
+		resolveSubpathWithRequire: false
+	});
+	if (esmEntry && isWorkspaceFilePath(esmEntry)) return esmEntry;
+	return resolved;
+}
 function isWorkspacePackageEntry(pkg, resolved) {
 	if (!resolved || !path$1.isAbsolute(resolved) || !isWorkspaceFilePath(resolved)) return false;
 	return !!getInstalledPackageJson(pkg, {
@@ -1117,7 +1179,7 @@ function isWorkspaceSingletonConsumedByPeer(pkg) {
 }
 function tryResolveImportFromPackageRoot(pkg, root) {
 	try {
-		return createRequire$1(pathToFileURL(path$1.join(root, "package.json"))).resolve(pkg);
+		return resolveWorkspaceEsmEntry(pkg, createRequire$1(pathToFileURL(path$1.join(root, "package.json"))).resolve(pkg), root);
 	} catch {
 		return;
 	}
@@ -1143,11 +1205,18 @@ function writePreBuildLibPath(pkg, shareItem) {
 	preBuildShareItemMap[pkg] = shareItem;
 	const importSource = getConcreteSharedImportSource(pkg, shareItem) || pkg;
 	if (pkg === "react/compiler-runtime") {
+		const reactCacheDescriptor = getSharedCacheDescriptorLiteral("react", shareItem ?? {
+			name: "react",
+			from: "",
+			scope: "default",
+			shareConfig: { singleton: true }
+		});
 		preBuildCacheMap[pkg].writeSync(`
+    ${sharedCacheHelperCode}
     const __mfCacheGlobalKey = "__mf_module_cache__";
     export const c = function(size) {
       const cache = globalThis[__mfCacheGlobalKey]?.share;
-      const sharedReact = cache?.['react'];
+      const sharedReact = cache && __mfReadSharedCache(cache, ${reactCacheDescriptor});
       const reactExports = sharedReact?.default ?? sharedReact;
       const internals = reactExports?.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
       return internals?.H?.useMemoCache(size);
@@ -1189,7 +1258,7 @@ function writePreBuildLibPath(pkg, shareItem) {
     const __mfPrebuildExports = __mfPrebuildNamespace;
     ${declarations}
     ${namedExportLine}
-    export default __mfPrebuildExports;
+    export default __mfPrebuildNamespace.default ?? __mfPrebuildNamespace;
   `, true);
 		return;
 	}
@@ -1244,45 +1313,47 @@ function materializeCachedLoadShareModule(options) {
 	options.addUsedShares(pkg);
 	options.writeLocalSharedImportMap();
 }
-function generateEagerWorkspaceSingletonExports(namedExports, importSource, cacheKey) {
-	const namedExportLine = namedExports.length > 0 ? `\n    export { ${namedExports.join(", ")} } from ${escapeGeneratedStringLiteral(importSource)};` : "";
+function generateEagerWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor) {
+	const namedExportVars = namedExports.map((_name, i) => `__mf_${i}`);
+	const namedExportAssignments = namedExports.length > 0 ? `\n    ${namedExports.map((name, i) => `const ${namedExportVars[i]} = exportModule[${escapeGeneratedStringLiteral(name)}];`).join("\n    ")}` : "";
+	const namedExportLine = namedExports.length > 0 ? `\n    export { ${namedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : "";
 	return `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(importSource)};
-    let exportModule = __mfModuleCache.share[${escapeGeneratedStringLiteral(cacheKey)}];
+    let exportModule = __mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor});
     if (exportModule === undefined) {
       Promise.resolve().then(() => {
-        if (__mfModuleCache.share[${escapeGeneratedStringLiteral(cacheKey)}] === undefined) {
-          __mfModuleCache.share[${escapeGeneratedStringLiteral(cacheKey)}] = __mfNormalizeShareModule(__mfLocalShare);
+        if (__mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor}) === undefined) {
+          __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfNormalizeShareModule(__mfLocalShare));
         }
       });
       exportModule = __mfLocalShare;
     }
-    const __mf_default = exportModule.default ?? exportModule;
+    const __mf_default = exportModule.default ?? exportModule;${namedExportAssignments}
     export { __mf_default as default };${namedExportLine}`;
 }
-function generateLazyWorkspaceSingletonExports(namedExports, importSource, cacheKey, eagerLocalFallback) {
+function generateLazyWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor, eagerLocalFallback) {
 	const namedExportVars = namedExports.map((_name, i) => `__mf_${i}`);
 	const declarations = namedExports.length > 0 ? ["let __mf_default;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ") : "let __mf_default;";
 	const assignments = namedExports.length > 0 ? [...namedExports.map((name, i) => `${namedExportVars[i]} = mod[${escapeGeneratedStringLiteral(name)}];`), "__mf_default = mod.default ?? mod;"].join("\n      ") : "__mf_default = mod.default ?? mod;";
 	const namedExportLine = namedExports.length > 0 ? `\n    export { ${namedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : "";
 	const applyLocalFallback = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
-      __mfModuleCache.share[${escapeGeneratedStringLiteral(cacheKey)}] = exportModule;
+      __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule);
       __mfApplyLazyShareExports(exportModule);`;
 	const body = `${declarations}
     const __mfApplyLazyShareExports = (mod) => {
       ${assignments}
     };
-    let exportModule = __mfModuleCache.share[${escapeGeneratedStringLiteral(cacheKey)}];
+    let exportModule = __mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor});
     if (exportModule === undefined) {
       ${eagerLocalFallback ? applyLocalFallback : `if (import.meta.env.SSR) {
         ${applyLocalFallback}
       } else {
-        initPromise.then(() =>
+        (__mfModuleCache.pendingShareLoads ||= []).push(initPromise.then(() =>
           import(${escapeGeneratedStringLiteral(importSource)}).then((mod) => {
             exportModule = __mfNormalizeShareModule(mod);
-            __mfModuleCache.share[${escapeGeneratedStringLiteral(cacheKey)}] = exportModule;
+            __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule);
             __mfApplyLazyShareExports(exportModule);
           })
-        );
+        ));
       }`}
     } else {
       __mfApplyLazyShareExports(exportModule);
@@ -1301,28 +1372,25 @@ function prependWorkspaceSingletonSsrImport(code) {
 	const quote = importMatch[1];
 	return `import * as __mfLocalShare from ${quote}${importMatch[2]}${quote};\n${code}`;
 }
-function generateDeferredHostProvidedExports(namedExports, pkg, cacheKey) {
+function generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor) {
 	const namedExportVars = namedExports.map((_name, i) => `__mf_${i}`);
-	const declarations = ["let __mf_default;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ");
-	const assignments = [...namedExports.map((name, i) => `${namedExportVars[i]} = exportModule[${escapeGeneratedStringLiteral(name)}];`), "__mf_default = exportModule.default ?? exportModule;"].join("\n      ");
-	const namedExportLine = namedExports.length > 0 ? `\n    export { ${namedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : "";
-	return `${declarations}
+	return `${["let __mf_default;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ")}
     const __mfApplyHostProvidedExports = (exportModule) => {
-      ${assignments}
+      ${[...namedExports.map((name, i) => `${namedExportVars[i]} = exportModule[${escapeGeneratedStringLiteral(name)}];`), "__mf_default = exportModule.default ?? exportModule;"].join("\n      ")}
     };
-    let exportModule = __mfModuleCache.share[${escapeGeneratedStringLiteral(cacheKey)}];
+    let exportModule = __mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor});
     if (exportModule === undefined) {
-      initPromise.then(() => {
-        exportModule = __mfModuleCache.share[${escapeGeneratedStringLiteral(cacheKey)}];
+      (__mfModuleCache.pendingShareLoads ||= []).push(initPromise.then(() => {
+        exportModule = __mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor});
         if (exportModule === undefined) {
           throw new Error("[Module Federation] Shared module ${pkg} was imported before federation bootstrap finished.");
         }
         __mfApplyHostProvidedExports(exportModule);
-      });
+      }));
     } else {
       __mfApplyHostProvidedExports(exportModule);
     }
-    export { __mf_default as default };${namedExportLine}`;
+    export { __mf_default as default };${namedExports.length > 0 ? `\n    export { ${namedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : ""}`;
 }
 function generateShareModuleUnwrapCode({ source, preserveNamedExports, stopWithReturn }) {
 	return `let current = ${source};
@@ -1344,18 +1412,19 @@ const normalizeLocalShareModuleCode = `const __mfNormalizeShareModule = (mod) =>
 function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
 	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = new VirtualModule(pkg, LOAD_SHARE_TAG, ".js");
 	let importLine = getRuntimeModuleCacheBootstrapCode();
-	const cacheKey = getSharedCacheKey(pkg, shareItem);
+	const cacheDescriptor = getSharedCacheDescriptorLiteral(pkg, shareItem);
 	if (shareItem.shareConfig.import === false) {
 		const namedExports = getPackageNamedExports(pkg);
 		let exportLine;
-		if (namedExports.length > 0) exportLine = generateDeferredHostProvidedExports(namedExports, pkg, cacheKey);
+		if (namedExports.length > 0) exportLine = generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor);
 		else {
 			mfWarn(`Shared dependency "${pkg}" has import: false but is not installed locally.\n  Named imports (e.g. import { ... } from '${pkg}') will not work in production builds.\n  Install it as a devDependency to enable named export detection.`);
-			exportLine = generateDeferredHostProvidedExports([], pkg, cacheKey);
+			exportLine = generateDeferredHostProvidedExports([], pkg, cacheDescriptor);
 		}
 		loadShareCacheMap[pkg].writeSync(`
     ${getRuntimeInitPromiseBootstrapCode()}
     ${importLine}
+    ${sharedCacheHelperCode}
     ${exportLine}
   `, true);
 		return;
@@ -1372,10 +1441,10 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
 	const namedExports = getSharedNamedExports(pkg, shareItem);
 	let exportLine;
 	let initBlock = "";
-	if (usesEagerWorkspaceFallback) exportLine = generateEagerWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheKey);
+	if (usesEagerWorkspaceFallback) exportLine = generateEagerWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor);
 	else if (isWorkspaceSingleton) {
 		importLine = `${getRuntimeInitPromiseBootstrapCode()}\n    ${importLine}`;
-		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheKey, command !== "build");
+		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, command !== "build");
 	} else if (namedExports.length > 0) {
 		const destructure = `const { ${namedExports.map((name, i) => `${name}: __mf_${i}`).join(", ")} } = exportModule;`;
 		const namedExportLine = `export { ${namedExports.map((name, i) => `__mf_${i} as ${name}`).join(", ")} };`;
@@ -1390,11 +1459,11 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
     ${destructure}
     ${namedExportLine}`;
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
-      __mfModuleCache.share[${escapeGeneratedStringLiteral(cacheKey)}] = exportModule;`;
+      __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule);`;
 	} else {
 		exportLine = `export default exportModule.default ?? exportModule\n    export * from ${escapeGeneratedStringLiteral(sharedImportSource)}`;
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
-      __mfModuleCache.share[${escapeGeneratedStringLiteral(cacheKey)}] = exportModule;`;
+      __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule);`;
 	}
 	const prebuildImportLine = isWorkspaceSingleton || isWorkspacePackage && command !== "build" ? "" : `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(skipServePrebuildWarmup ? devImportSource : sharedImportSource)};`;
 	const devDynamicImportLine = isWorkspacePackage ? "" : command !== "build" && !skipServePrebuildWarmup ? `;() => import(${escapeGeneratedStringLiteral(devImportSource)}).catch(() => {});` : "";
@@ -1402,14 +1471,16 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
     ${prebuildImportLine}
     ${devDynamicImportLine}
     ${importLine}
+    ${sharedCacheHelperCode}
     ${normalizeLocalShareModuleCode}
     ${exportLine}
   ` : `
     ${prebuildImportLine}
     ${devDynamicImportLine}
     ${importLine}
+    ${sharedCacheHelperCode}
     ${normalizeLocalShareModuleCode}
-    let exportModule = __mfModuleCache.share[${escapeGeneratedStringLiteral(cacheKey)}]
+    let exportModule = __mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor})
     if (exportModule === undefined) {
       ${initBlock}
     }
@@ -1596,8 +1667,8 @@ function getShareItemForPreload(pkg) {
 	if (isExplicitSharedKey(wildcardKey)) return shared[wildcardKey];
 }
 function generateSharedCacheSeedItem(pkg, shareItem, importPath) {
-	const cacheKey = getSharedCacheKey(pkg, shareItem);
-	return `if (__mfModuleCache.share[${JSON.stringify(cacheKey)}] === undefined) {
+	const cacheDescriptor = getSharedCacheDescriptor(pkg, shareItem);
+	return `if (__mfReadSharedCache(__mfModuleCache.share, ${JSON.stringify(cacheDescriptor)}) === undefined) {
         const mod = await import(${JSON.stringify(importPath)});
         ${normalizeRuntimeShareCode}
         const normalizedModule = __mfNormalizeRuntimeShare(mod);
@@ -1606,14 +1677,9 @@ function generateSharedCacheSeedItem(pkg, shareItem, importPath) {
           value: true,
           enumerable: false
         });
-        __mfModuleCache.share[${JSON.stringify(cacheKey)}] = exportModule;
+        __mfWriteSharedCache(__mfModuleCache.share, ${JSON.stringify(cacheDescriptor)}, exportModule);
       }`;
 }
-const sharedCacheKeyHelperCode = `const __mfGetSharedCacheKey = (pkg, singleton, version, scope) => {
-            const normalizedScope = Array.isArray(scope) ? scope[0] : scope;
-            const prefix = (normalizedScope || "default") + ":";
-            return singleton || !version ? prefix + pkg : prefix + pkg + "@" + version;
-          };`;
 const normalizeRuntimeShareCode = `const __mfNormalizeRuntimeShare = (mod) => {
             let current = mod;
             for (let i = 0; i < 5; i++) {
@@ -1767,7 +1833,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   }
 
   async function init(shared = {}, initScope = []) {
-    ${sharedCacheKeyHelperCode}
+    ${sharedCacheHelperCode}
     const {usedShared, usedRemotes} = await getLocalSharedImportMap()
     try {
       const allInstances = globalThis.__FEDERATION__?.__SHARE__;
@@ -1786,16 +1852,16 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
               : Object.entries(versionMap);
             for (const [version, provider] of providerEntries) {
               if (!provider.lib) continue;
-              const cacheKey = __mfGetSharedCacheKey(pkg, provider.shareConfig?.singleton, version, ${JSON.stringify(options.shareScope)});
-              if (__mfModuleCache.share[cacheKey] !== undefined) continue;
+              const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, provider.shareConfig?.singleton, version, ${JSON.stringify(options.shareScope)});
+              if (__mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined) continue;
               const mod = typeof provider.lib === "function" ? provider.lib() : provider.lib;
               const resolved = await Promise.resolve(mod);
               const normalized = __mfNormalizeRuntimeShare(resolved);
-              __mfModuleCache.share[cacheKey] = normalized;
+              __mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, normalized);
               if (provider.shareConfig?.singleton && usedShare) {
-                const usedCacheKey = __mfGetSharedCacheKey(pkg, usedShare.shareConfig?.singleton, usedShare.version, usedShare.scope);
-                if (__mfModuleCache.share[usedCacheKey] === undefined) {
-                  __mfModuleCache.share[usedCacheKey] = normalized;
+                const usedCacheDescriptor = __mfGetSharedCacheDescriptor(pkg, usedShare.shareConfig?.singleton, usedShare.version, usedShare.scope);
+                if (__mfReadSharedCache(__mfModuleCache.share, usedCacheDescriptor) === undefined) {
+                  __mfWriteSharedCache(__mfModuleCache.share, usedCacheDescriptor, normalized);
                 }
               }
             }
@@ -1806,11 +1872,12 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       console.error('[Module Federation] Failed to bridge external shared modules', e)
     }
     for (const [pkg, share] of Object.entries(usedShared)) {
-      const cacheKey = __mfGetSharedCacheKey(pkg, share.shareConfig?.singleton, share.version, share.scope);
-      if (__mfModuleCache.share[cacheKey] !== undefined) continue;
-      const singletonCacheKey = __mfGetSharedCacheKey(pkg, true, share.version, share.scope);
-      if (__mfModuleCache.share[singletonCacheKey] !== undefined) {
-        __mfModuleCache.share[cacheKey] = __mfModuleCache.share[singletonCacheKey];
+      const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
+      if (__mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined) continue;
+      const singletonCacheDescriptor = __mfGetSharedCacheDescriptor(pkg, true, share.version, share.scope);
+      const singletonModule = __mfReadSharedCache(__mfModuleCache.share, singletonCacheDescriptor);
+      if (singletonModule !== undefined) {
+        __mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, singletonModule);
       }
     }
     ${generateDirectSharedCacheSeedCode(command)}
@@ -1836,7 +1903,6 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
     if (initScope.indexOf(initToken) >= 0) return;
     initScope.push(initToken);
     initRes.initShareScopeMap('${options.shareScope}', shared);
-    initResolve(initRes)
     try {
       await retrySharedInit(async () => {
         await Promise.all(await initRes.initializeSharing('${options.shareScope}', {
@@ -1849,8 +1915,8 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       console.error('[Module Federation]', e)
     }
     for (const [pkg, share] of Object.entries(usedShared)) {
-      const cacheKey = __mfGetSharedCacheKey(pkg, share.shareConfig?.singleton, share.version, share.scope);
-      if (share.shareConfig?.import !== false || __mfModuleCache.share[cacheKey] !== undefined) continue;
+      const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
+      if (share.shareConfig?.import !== false || __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined) continue;
       ${normalizeRuntimeShareCode}
       const versions = shared?.[pkg];
       const provider = __mfSelectSharedProvider(versions, pkg, share, '${options.shareStrategy}');
@@ -1858,8 +1924,9 @@ 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[cacheKey] = __mfNormalizeRuntimeShare(resolved);
+      __mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, __mfNormalizeRuntimeShare(resolved));
     }
+    initResolve(initRes)
     return initRes
   }
 
@@ -1885,16 +1952,16 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build") {
     async function initHost() {
       if (!hostInitPromise) {
         hostInitPromise = (async () => {
+          ${sharedCacheHelperCode}
           ${generateHostAutoInitSharedCacheSeedCode(_command)}
           const remoteEntry = await import(${remoteEntryImport});
           const runtime = await remoteEntry.init();
           const usedShared = ${generateUsedSharedPreloadConfig()};
-          ${sharedCacheKeyHelperCode}
           ${normalizeRuntimeShareCode}
           ${shouldPreloadShares ? `
           for (const [pkg, share] of Object.entries(usedShared)) {
-            const cacheKey = __mfGetSharedCacheKey(pkg, share.shareConfig?.singleton, share.version, share.scope);
-            if (__mfModuleCache.share[cacheKey] !== undefined) {
+            const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
+            if (__mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined) {
               continue;
             }
             await runtime.loadShare(pkg, {
@@ -1902,7 +1969,7 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build") {
             }).then((factory) => {
               const mod = typeof factory === "function" ? factory() : factory;
               return Promise.resolve(mod).then((resolved) => {
-                __mfModuleCache.share[cacheKey] = __mfNormalizeRuntimeShare(resolved);
+                __mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, __mfNormalizeRuntimeShare(resolved));
               });
             });
           }
@@ -2162,7 +2229,7 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
 	const eagerLoadClientRemote = shouldEagerLoadClientRemoteInDev(command, enableSsrInit);
 	const eagerClientInit = eagerLoadClientRemote ? getEagerDeferredClientInit() : deferredClientInit;
 	const loadedFirstClientInit = eagerLoadClientRemote ? getEagerDeferredClientInit() : deferredClientInit;
-	const environmentSplitInit = (clientInit, serverInit) => consumer === "client" ? clientInit : consumer === "server" ? serverInit : `if (typeof window === "undefined") {
+	const environmentSplitInit = (clientInit, serverInit) => consumer === "client" ? clientInit : consumer === "server" ? serverInit : `if (${SERVER_ENV_GUARD}) {
       ${serverInit}
     } else {
       ${clientInit}
@@ -2218,10 +2285,10 @@ function injectHostInitPreloads(html, bundle, resolvePath) {
 function getFirstHtmlEntryFile(entryFiles) {
 	return entryFiles.find((file) => file.endsWith(".html"));
 }
-function stripQueryAndHash(file) {
+function stripQueryAndHash$1(file) {
 	return file.split(/[?#]/)[0];
 }
-function resolveDevHashEntryFileName(fileName) {
+function resolveDevHashEntryFileName$1(fileName) {
 	if (!fileName.includes("[hash")) return fileName;
 	const normalized = fileName.replace(/(?:[._-]?\[hash(?::\d+)?\])/g, "");
 	const baseName = path$1.basename(normalized);
@@ -2298,8 +2365,8 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 		});
 	}
 	function walkFiles(dir, predicate) {
-		if (!fs$1.existsSync(dir)) return [];
-		return fs$1.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+		if (!fs$2.existsSync(dir)) return [];
+		return fs$2.readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
 			const entryPath = path$1.join(dir, entry.name);
 			if (entry.isDirectory()) return walkFiles(entryPath, predicate);
 			return entry.isFile() && predicate(entry.name) ? [entryPath] : [];
@@ -2315,17 +2382,17 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 	function patchSvelteKitStaticHtml() {
 		const buildDir = path$1.resolve(viteConfig.root, "build");
 		let initFile = emittedFileName ? path$1.resolve(buildDir, emittedFileName) : void 0;
-		if (!initFile || !fs$1.existsSync(initFile)) initFile = walkFiles(buildDir, (fileName) => fileName.endsWith(".js")).find((file) => {
-			const code = fs$1.readFileSync(file, "utf-8");
+		if (!initFile || !fs$2.existsSync(initFile)) initFile = walkFiles(buildDir, (fileName) => fileName.endsWith(".js")).find((file) => {
+			const code = fs$2.readFileSync(file, "utf-8");
 			return code.includes("hostInitPromise") && code.includes("initHost");
 		});
 		if (!initFile) return false;
 		let patched = false;
 		for (const htmlFile of walkHtmlFiles(buildDir)) {
-			const html = fs$1.readFileSync(htmlFile, "utf-8");
+			const html = fs$2.readFileSync(htmlFile, "utf-8");
 			const rewritten = rewriteSvelteKitInlineStart(html, toRelativeImport(htmlFile, initFile));
 			if (rewritten !== html) {
-				fs$1.writeFileSync(htmlFile, rewritten);
+				fs$2.writeFileSync(htmlFile, rewritten);
 				patched = true;
 			}
 		}
@@ -2365,6 +2432,9 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
   await __mfHostInit.__tla;
   const { initHost } = __mfHostInit;
   ${preloadBlock}
+  if (__mfModuleCache.pendingShareLoads) {
+    await Promise.all(__mfModuleCache.pendingShareLoads);
+  }
 })().then(() => ${importExpression(entrySrc)});
 `;
 		return [
@@ -2402,12 +2472,12 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 		if (!entryFiles.includes(normalized)) entryFiles.push(normalized);
 	}
 	function addHtmlScriptEntries(htmlPath) {
-		if (!fs$1.existsSync(htmlPath)) return;
-		const htmlContent = fs$1.readFileSync(htmlPath, "utf-8");
+		if (!fs$2.existsSync(htmlPath)) return;
+		const htmlContent = fs$2.readFileSync(htmlPath, "utf-8");
 		const scriptRegex = /<script\b(?=[^>]*\btype=["']module["'])(?=[^>]*\bsrc=["']([^"']+)["'])[^>]*>/gi;
 		let match;
 		while ((match = scriptRegex.exec(htmlContent)) !== null) {
-			const scriptSrc = stripQueryAndHash(match[1]);
+			const scriptSrc = stripQueryAndHash$1(match[1]);
 			if (/^(?:[a-z]+:)?\/\//i.test(scriptSrc)) continue;
 			addEntryFile(scriptSrc);
 			addEntryFile(scriptSrc.startsWith("/") ? path$1.resolve(viteConfig.root, scriptSrc.slice(1)) : path$1.resolve(path$1.dirname(htmlPath), scriptSrc));
@@ -2450,7 +2520,7 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 					next();
 					return;
 				}
-				const devFileName = resolveDevHashEntryFileName(fileName);
+				const devFileName = resolveDevHashEntryFileName$1(fileName);
 				if (devFileName !== fileName && req.url?.startsWith((viteConfig.base + devFileName).replace(/^\/?/, "/"))) req.url = req.url.replace(devFileName, fileName);
 				if (req.url && req.url.startsWith((viteConfig.base + fileName).replace(/^\/?/, "/"))) req.url = devEntryPath;
 				next();
@@ -2634,9 +2704,9 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 				const injection = `await import(${JSON.stringify(getEntryPath())}).then(({ initHost }) => initHost());\n      `;
 				return mapCodeToCodeWithSourcemap(code.replace("vueApp.mount(vueAppRootContainer);", `${injection}vueApp.mount(vueAppRootContainer);`));
 			}
-			const isHydrationEntryFallback = inject === "entry" && entryFiles.length === 0 && (!htmlFilePath || !fs$1.existsSync(htmlFilePath)) && !clientInjected && !isFederationInternalVirtualId(id) && !id.includes("node_modules") && (id.startsWith("\0") || /\.(js|ts|mjs|vue|jsx|tsx)(\?|$)/.test(id)) && (/hydrateRoot|createRoot|ReactDOM\.render/.test(code) || /\.mount\s*\(\s*['"#]/.test(code) || /\.mount\s*\(/.test(code) && /createSSRApp|createApp/.test(code));
+			const isHydrationEntryFallback = inject === "entry" && entryFiles.length === 0 && (!htmlFilePath || !fs$2.existsSync(htmlFilePath)) && !clientInjected && !isFederationInternalVirtualId(id) && !id.includes("node_modules") && (id.startsWith("\0") || /\.(js|ts|mjs|vue|jsx|tsx)(\?|$)/.test(id)) && (/hydrateRoot|createRoot|ReactDOM\.render/.test(code) || /\.mount\s*\(\s*['"#]/.test(code) || /\.mount\s*\(/.test(code) && /createSSRApp|createApp/.test(code));
 			const isNuxtEntryAsyncModule = /(?:^|\/)nuxt\/dist\/app\/entry\.async\.js(?:\?|$)/.test(id) && code.includes("entry();");
-			const isNuxtClientEntryFallback = _command === "serve" && inject === "entry" && (!htmlFilePath || !fs$1.existsSync(htmlFilePath)) && !clientInjected && !hasEntryBootstrapParam(id) && !id.includes("node_modules/.vite") && isNuxtEntryAsyncModule && !entryFiles.some((file) => projectId === file);
+			const isNuxtClientEntryFallback = _command === "serve" && inject === "entry" && (!htmlFilePath || !fs$2.existsSync(htmlFilePath)) && !clientInjected && !hasEntryBootstrapParam(id) && !id.includes("node_modules/.vite") && isNuxtEntryAsyncModule && !entryFiles.some((file) => projectId === file);
 			if (!(_command === "serve" && isNuxtEntryAsyncModule) && (injectedTransformIds.has(projectId) || injectEntry() && entryFiles.some((file) => projectId === file) || _command === "serve" && inject === "html" && !isVinext && !clientInjected && !skipHtmlDevFallback && !id.startsWith("\0") && !id.includes("node_modules") && /\.(js|ts|mjs|vue|jsx|tsx)(\?|$)/.test(id) || isHydrationEntryFallback || isNuxtClientEntryFallback)) {
 				clientInjected = true;
 				injectedTransformIds.add(projectId);
@@ -3783,6 +3853,7 @@ const Manifest = () => {
 		},
 		async generateBundle(_options, bundle) {
 			if (!mfManifestName) return;
+			if (this.environment?.name === "ssr") return;
 			let filesMap = {};
 			const foundRemoteEntryFile = findRemoteEntryFile(mfOptions.filename, bundle);
 			const expectedSsrRemoteEntryFile = getSsrRemoteEntryFileName(foundRemoteEntryFile || mfOptions.filename);
@@ -4033,8 +4104,39 @@ function pluginModuleParseEnd_default(excludeFn, options) {
 }
 //#endregion
 //#region src/plugins/pluginProxyRemoteEntry.ts
+function resolveDevHashEntryFileName(fileName) {
+	if (!fileName.includes("[hash")) return fileName;
+	const normalized = fileName.replace(/(?:[._-]?\[hash(?::\d+)?\])/g, "");
+	const baseName = path$1.basename(normalized);
+	return path$1.extname(baseName) ? normalized : `${normalized}.js`;
+}
 function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposesId }) {
 	let viteConfig, _command, root;
+	let exposeRemoteDependencies = {};
+	function isRemoteImport(source) {
+		return Object.keys(options.remotes).some((name) => source === name || source.startsWith(name + "/"));
+	}
+	function collectRemoteDependencies(code) {
+		const dependencies = /* @__PURE__ */ new Set();
+		for (const match of code.matchAll(/(?:^|[;\n\r])\s*import\s+(?:[\s\S]*?\s+from\s+)?["']([^"']+)["']|import\(\s*["']([^"']+)["']\s*\)/g)) {
+			const source = match[1] || match[2];
+			if (source && isRemoteImport(source)) dependencies.add(source);
+		}
+		return Array.from(dependencies).sort();
+	}
+	async function refreshExposeRemoteDependencies(ctx) {
+		const next = {};
+		for (const [exposeKey, expose] of Object.entries(options.exposes)) {
+			const resolved = await ctx.resolve(expose.import);
+			if (!resolved?.id || resolved.id.includes("\0")) continue;
+			try {
+				next[exposeKey] = collectRemoteDependencies(readFileSync$1(resolved.id, "utf8"));
+			} catch {
+				next[exposeKey] = [];
+			}
+		}
+		exposeRemoteDependencies = next;
+	}
 	return {
 		name: "proxyRemoteEntry",
 		enforce: "post",
@@ -4046,6 +4148,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 			_command = command;
 		},
 		async buildStart() {
+			await refreshExposeRemoteDependencies(this);
 			if (_command !== "build") return;
 			for (const expose of Object.values(options.exposes)) {
 				const resolved = await this.resolve(expose.import);
@@ -4067,19 +4170,19 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		},
 		load(id) {
 			if (id === remoteEntryId) return parsePromise.then((_) => generateRemoteEntry(options, virtualExposesId, _command));
-			if (id === virtualExposesId) return generateExposes(options);
+			if (id === virtualExposesId) return generateExposes(options, exposeRemoteDependencies, _command);
 			if (_command === "serve" && id.includes(getHostAutoInitPath())) return id;
 		},
 		transform(code, id) {
 			return mapCodeToCodeWithSourcemap((() => {
 				if (!filterId(id)) return;
 				if (id.includes(remoteEntryId)) return parsePromise.then((_) => generateRemoteEntry(options, virtualExposesId, _command));
-				if (id === virtualExposesId) return generateExposes(options);
+				if (id === virtualExposesId) return generateExposes(options, exposeRemoteDependencies, _command);
 				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 resolvedPublicPath = resolvePublicPath(options, viteConfig.base);
-						const publicPath = JSON.stringify((resolvedPublicPath === "auto" ? "/" : resolvedPublicPath) + options.filename);
+						const publicPath = JSON.stringify((resolvedPublicPath === "auto" ? "/" : resolvedPublicPath) + resolveDevHashEntryFileName(options.filename));
 						const fallbackOrigin = `//${host}:${viteConfig.server?.port}`;
 						const ssrRemoteEntry = "data:text/javascript," + encodeURIComponent("export async function init(){return {loadRemote:async()=>({}),loadShare:async()=>({})}}");
 						return `
@@ -4145,25 +4248,6 @@ function resolveRemoteConsumer(ctx, hasMultiEnvironment) {
 	return "server";
 }
 //#endregion
-//#region src/utils/ssrCapabilities.ts
-/**
-* Single source of truth for SSR-related feature gates.
-*
-* - Vite 8+ dev: ModuleRunner + FetchableDevEnvironment for `/__mf_ssr__/` entries.
-* - Any Vite major on build/preview: HTTP fetch + temp-file import via ssrEntryLoader.
-*/
-function getSsrCapabilities(viteMajor, command, hasRemotes) {
-	if (!hasRemotes) return {
-		enableSsrInitBootstrap: false,
-		injectSsrEntryLoader: false
-	};
-	const supported = command === "build" || command === "serve" && viteMajor >= 8;
-	return {
-		enableSsrInitBootstrap: supported,
-		injectSsrEntryLoader: supported
-	};
-}
-//#endregion
 //#region src/plugins/pluginProxyRemotes.ts
 function isNodeModulesImporter(importer) {
 	return importer?.includes("/node_modules/") || importer?.includes("\\node_modules\\");
@@ -4537,26 +4621,7 @@ function applyRewrites(code, imports, id) {
 	const ms = new CodeRewriter(code);
 	let changed = false;
 	let counter = 0;
-	let namedProxyHelperDeclared = false;
 	const dependencyPendingIds = [];
-	const namedProxyHelper = `function __mfCreateNamedRemoteProxy(ns, key) {
-  const target = function (...args) {
-    const value = ns[key];
-    return typeof value === "function" ? value.apply(this, args) : value;
-  };
-  return new Proxy(target, {
-    get(_target, prop) {
-      if (prop === "then") return undefined;
-      const value = ns[key];
-      if (prop === Symbol.toPrimitive) return () => value;
-      const item = value == null ? undefined : value[prop];
-      return typeof item === "function" ? item.bind(value) : item;
-    },
-    apply(target, thisArg, args) {
-      return target.apply(thisArg, args);
-    }
-  });
-}`;
 	for (const imp of imports) switch (imp.kind) {
 		case "static": {
 			const src = JSON.stringify(imp.source);
@@ -4574,20 +4639,8 @@ function applyRewrites(code, imports, id) {
 				importParts.push(`__mf_remote_pending as ${pendingId}`);
 				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};`;
-					});
-					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")}`;
+					const destructParts = imp.named.map((s) => `${s.imported}: ${s.local}`);
+					rewrite += `\nconst { ${destructParts.join(", ")} } = ${nsId};`;
 				}
 				ms.overwrite(imp.start, imp.end, rewrite);
 			}
@@ -4844,6 +4897,104 @@ function pluginRemoteNamedExports(options) {
 }
 //#endregion
 //#region src/plugins/pluginSSRRemoteEntry.ts
+const MAX_RUNNER_BODY_BYTES = 1024 * 1024;
+const ALLOWED_RUNNER_INVOKE_NAMES = new Set(["fetchModule", "getBuiltins"]);
+const VITE_FS_PREFIX = "/@fs/";
+function isPlainObject(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function stripQueryAndHash(id) {
+	const queryIndex = id.indexOf("?");
+	const hashIndex = id.indexOf("#");
+	const endIndex = queryIndex === -1 ? hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
+	return endIndex === -1 ? id : id.slice(0, endIndex);
+}
+function decodeRunnerFilePath(filePath) {
+	try {
+		return decodeURIComponent(filePath);
+	} catch {
+		return;
+	}
+}
+function hasRelativeTraversal(id) {
+	return id.split(/[\\/]+/).includes("..");
+}
+function getRealPathIfExists(filePath) {
+	try {
+		return fs$1.realpathSync.native(filePath);
+	} catch {
+		return;
+	}
+}
+function isPathWithinDirectory(filePath, directory) {
+	const realFilePath = getRealPathIfExists(filePath) ?? path$1.resolve(filePath);
+	const realDirectory = getRealPathIfExists(directory) ?? path$1.resolve(directory);
+	const relative = path$1.relative(realDirectory, realFilePath);
+	return relative === "" || !relative.startsWith("..") && !path$1.isAbsolute(relative);
+}
+function getRunnerAllowedDirectories(config) {
+	return [config.root, ...config.server?.fs?.allow ?? []].map((directory) => path$1.resolve(directory));
+}
+function isPathWithinAllowedDirectories(filePath, allowedDirectories) {
+	return allowedDirectories.some((directory) => isPathWithinDirectory(filePath, directory));
+}
+function isSafeRunnerFetchModuleId(id, config) {
+	if (typeof id !== "string" || !id || id.includes("\0")) return false;
+	const decoded = decodeViteId(id).replace(/^\0+/, "");
+	if (!decoded || decoded.startsWith("virtual:")) return !!decoded;
+	if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(decoded) || decoded.startsWith("//")) return false;
+	const cleanId = decodeRunnerFilePath(stripQueryAndHash(decoded));
+	if (!cleanId || hasRelativeTraversal(cleanId)) return false;
+	const allowedDirectories = getRunnerAllowedDirectories(config);
+	if (cleanId.startsWith(VITE_FS_PREFIX)) {
+		const fsPath = cleanId.slice(5);
+		return path$1.isAbsolute(fsPath) && isPathWithinAllowedDirectories(fsPath, allowedDirectories);
+	}
+	if (path$1.isAbsolute(cleanId)) {
+		if (isPathWithinAllowedDirectories(cleanId, allowedDirectories)) return true;
+		return !fs$1.existsSync(cleanId);
+	}
+	return true;
+}
+function isRunnerInvokePayload(payload, config) {
+	if (!payload || typeof payload !== "object") return false;
+	if (payload.type !== "custom" || payload.event !== "vite:invoke") return false;
+	const data = payload.data;
+	if (!data || typeof data !== "object") return false;
+	const name = data.name;
+	const args = data.data;
+	if (typeof name !== "string" || !ALLOWED_RUNNER_INVOKE_NAMES.has(name) || !Array.isArray(args)) return false;
+	if (name === "getBuiltins") return args.length === 0;
+	if (args.length < 1 || args.length > 3) return false;
+	const [id, importer, opts] = args;
+	return isSafeRunnerFetchModuleId(id, config) && (importer === void 0 || importer === null || isSafeRunnerFetchModuleId(importer, config)) && (opts === void 0 || isPlainObject(opts));
+}
+function readBoundedRunnerBody(req, res) {
+	return new Promise((resolve) => {
+		const chunks = [];
+		let size = 0;
+		let done = false;
+		const fail = (statusCode, message) => {
+			if (done) return;
+			done = true;
+			res.statusCode = statusCode;
+			res.end(message);
+			resolve(void 0);
+		};
+		req.on("data", (chunk) => {
+			if (done) return;
+			size += chunk.length;
+			if (size > MAX_RUNNER_BODY_BYTES) return fail(413, "Payload too large");
+			chunks.push(chunk);
+		});
+		req.on("end", () => {
+			if (done) return;
+			done = true;
+			resolve(Buffer.concat(chunks));
+		});
+		req.on("error", () => fail(400, "Bad request"));
+	});
+}
 /**
 * Emits a Node-compatible SSR remote entry alongside the browser entry.
 *
@@ -4861,6 +5012,9 @@ function pluginSSRRemoteEntry(options) {
 	const virtualExposesSSRId = getVirtualExposesSSRId(options);
 	let isRolldown = false;
 	let ssrOutputFilename = "";
+	let ssrOutputFiles = /* @__PURE__ */ new Set();
+	let ssrOutputDir = "";
+	let clientOutputDir = "";
 	const ssrOnlyExternals = [
 		"@module-federation/runtime",
 		"@module-federation/runtime-core",
@@ -4912,6 +5066,7 @@ function pluginSSRRemoteEntry(options) {
 		}
 	}, {
 		name: "mf:ssr-remote-entry",
+		sharedDuringBuild: true,
 		configResolved(config) {
 			viteConfig = config;
 			isNuxtProject = isNuxtProjectRoot(config.root);
@@ -4926,7 +5081,8 @@ function pluginSSRRemoteEntry(options) {
 			});
 			const ssrEnv = server.environments?.ssr;
 			const clientEnv = server.environments?.client;
-			if (typeof (ssrEnv?.fetchModule ?? clientEnv?.fetchModule) === "function") server.middlewares.use("/__mf_runner__", async (req, res) => {
+			const runnerEnv = typeof ssrEnv?.hot?.handleInvoke === "function" ? ssrEnv : typeof clientEnv?.hot?.handleInvoke === "function" ? clientEnv : void 0;
+			if (typeof (ssrEnv?.fetchModule ?? clientEnv?.fetchModule) === "function" && runnerEnv) server.middlewares.use("/__mf_runner__", async (req, res) => {
 				res.setHeader("Access-Control-Allow-Origin", "*");
 				if (req.method === "OPTIONS") {
 					res.setHeader("Access-Control-Allow-Methods", "POST");
@@ -4941,46 +5097,37 @@ function pluginSSRRemoteEntry(options) {
 					return;
 				}
 				try {
-					const chunks = [];
-					await new Promise((resolve, reject) => {
-						req.on("data", (chunk) => chunks.push(chunk));
-						req.on("end", resolve);
-						req.on("error", reject);
-					});
-					const body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
-					if (body.name === "getBuiltins") {
-						const builtins = (clientEnv ?? ssrEnv)?.config?.resolve?.builtins ?? [];
-						res.setHeader("Content-Type", "application/json");
-						res.end(JSON.stringify({ result: builtins }));
+					const rawBody = await readBoundedRunnerBody(req, res);
+					if (!rawBody) return;
+					let body;
+					try {
+						body = JSON.parse(rawBody.toString("utf8"));
+					} catch {
+						res.statusCode = 400;
+						res.end(JSON.stringify({ error: { message: "Invalid JSON" } }));
 						return;
 					}
-					if (body.name !== "fetchModule") {
+					if (!isRunnerInvokePayload(body, server.config)) {
 						res.statusCode = 400;
-						res.end(JSON.stringify({ error: { message: `Unsupported invoke: ${body.name}` } }));
+						res.end(JSON.stringify({ error: { message: "Invalid runner invoke" } }));
 						return;
 					}
-					const [id, importer, opts] = body.data;
-					const fetchEnv = ssrEnv ?? clientEnv;
-					const fetchFn = fetchEnv.fetchModule.bind(fetchEnv);
-					let result;
-					try {
-						result = await fetchFn(id, importer, opts);
-					} catch (fetchErr) {
-						const bareId = decodeViteId(id);
-						try {
+					let result = await runnerEnv.hot.handleInvoke(body);
+					if ("error" in result && body.data.name === "fetchModule") {
+						const id = body.data.data[0];
+						const bareId = typeof id === "string" ? decodeViteId(id).replace(/^\0/, "") : "";
+						if (bareId && !bareId.startsWith(".") && !bareId.startsWith("/") && !bareId.startsWith("file:") && !/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(bareId)) try {
 							const { createRequire } = await import("module");
 							const path = await import("path");
 							const { pathToFileURL } = await import("url");
-							result = {
-								externalize: pathToFileURL(createRequire(pathToFileURL(path.join(server.config.root, "package.json"))).resolve(bareId.replace(/^\0/, ""))).href,
+							result = { result: {
+								externalize: pathToFileURL(createRequire(pathToFileURL(path.join(server.config.root, "package.json"))).resolve(bareId)).href,
 								type: "module"
-							};
-						} catch {
-							throw fetchErr;
-						}
+							} };
+						} catch {}
 					}
 					res.setHeader("Content-Type", "application/json");
-					res.end(JSON.stringify({ result }));
+					res.end(JSON.stringify(result));
 				} catch (e) {
 					res.setHeader("Content-Type", "application/json");
 					res.end(JSON.stringify({ error: { message: String(e instanceof Error ? e.message : e) } }));
@@ -5041,11 +5188,62 @@ function pluginSSRRemoteEntry(options) {
 			const exposesChunk = findNuxtExposesChunk(bundle);
 			const ssrAsset = bundle[ssrOutputFilename];
 			if (exposesChunk && ssrAsset?.type === "asset" && typeof ssrAsset.source === "string") ssrAsset.source = ssrAsset.source.replace(/import\("virtual:mf-exposes-ssr:[^"]+"\)/g, `import("./${exposesChunk}")`);
+			if (this.environment?.name === "ssr") ssrOutputFiles = collectEntryOutputFiles(bundle, ssrOutputFilename);
 			if (!isRolldown) return;
 			const chunk = bundle[ssrOutputFilename];
 			if (!chunk || chunk.type !== "chunk") return;
+		},
+		writeBundle(outputOptions) {
+			const environmentName = this.environment?.name;
+			if (environmentName === "ssr" && outputOptions.dir) ssrOutputDir = outputOptions.dir;
+			else if (environmentName === "client" && outputOptions.dir) clientOutputDir = outputOptions.dir;
+			publishSsrOutputFiles(ssrOutputDir, clientOutputDir || viteConfig?.environments?.client?.build?.outDir);
 		}
 	}];
+	function publishSsrOutputFiles(ssrOutDir, clientOutDir) {
+		if (ssrOutputFiles.size === 0 || !ssrOutDir || !clientOutDir) return;
+		const root = viteConfig?.root ?? process.cwd();
+		const ssrDir = path$1.resolve(root, ssrOutDir);
+		const clientDir = path$1.resolve(root, clientOutDir);
+		if (ssrDir === clientDir || !fs$1.existsSync(ssrDir)) return;
+		fs$1.mkdirSync(clientDir, { recursive: true });
+		for (const fileName of ssrOutputFiles) {
+			const source = path$1.resolve(ssrDir, fileName);
+			const destination = path$1.resolve(clientDir, fileName);
+			if (!isWithinDirectory(source, ssrDir) || !isWithinDirectory(destination, clientDir)) continue;
+			if (!fs$1.existsSync(source) || fs$1.existsSync(destination)) continue;
+			fs$1.mkdirSync(path$1.dirname(destination), { recursive: true });
+			fs$1.copyFileSync(source, destination);
+		}
+	}
+}
+const RELATIVE_IMPORT_RE = /(?:\bfrom|\bimport\s*(?:\(\s*)?|\bexport\s*\*\s*from)\s*["'`](\.\.?\/[^"'`]+)["'`]/g;
+function collectEntryOutputFiles(bundle, entryFileName) {
+	const files = /* @__PURE__ */ new Set();
+	const visit = (fileName) => {
+		if (files.has(fileName)) return;
+		const file = bundle[fileName];
+		if (!file) return;
+		files.add(fileName);
+		const dependencies = new Set([
+			...file.imports || [],
+			...file.dynamicImports || [],
+			...file.implicitlyLoadedBefore || [],
+			...file.referencedFiles || []
+		]);
+		const source = typeof file.code === "string" ? file.code : typeof file.source === "string" ? file.source : "";
+		if (source) {
+			const directory = path$1.posix.dirname(fileName);
+			for (const match of source.matchAll(RELATIVE_IMPORT_RE)) dependencies.add(path$1.posix.normalize(path$1.posix.join(directory, match[1])));
+		}
+		for (const dependency of dependencies) visit(dependency);
+	};
+	visit(entryFileName);
+	return files;
+}
+function isWithinDirectory(filePath, directory) {
+	const relative = path$1.relative(directory, filePath);
+	return relative !== "" && !relative.startsWith(`..${path$1.sep}`) && relative !== "..";
 }
 //#endregion
 //#region src/plugins/pluginVarRemoteEntry.ts
@@ -5367,14 +5565,32 @@ function createEarlyVirtualModulesPlugin(options) {
 						optimizeDeps.rolldownOptions.plugins ??= [];
 						optimizeDeps.rolldownOptions.plugins.push({
 							name: "module-federation:optimize-shared-resolver",
+							load(id) {
+								if (id !== "module-federation:optimized-require-react") return;
+								const optimizedLoadSharePath = toViteOptimizedDepVirtualId(getLoadShareModulePath("react", isRolldown));
+								const source = JSON.stringify(optimizedLoadSharePath);
+								return "import * as __mfShared from " + source + ";\nexport * from " + source + ";\nexport default __mfShared.default ?? __mfShared;";
+							},
 							resolveId(source, importer, options) {
-								if (options?.kind?.startsWith("require")) return;
+								if (createViteEncodedIdPrefixRegExp("virtual:mf:").test(source)) return {
+									id: source,
+									external: true
+								};
 								if (isSharedResolverInternalImporter(importer)) return;
-								if (isCommonJsImporter(importer)) return;
 								const key = findSharedKey(source, shared);
 								if (!key) return;
 								if (source.endsWith(".css")) return;
 								const shareItem = shared[key];
+								const isReactSingleton = source === "react" && key === "react" && shareItem.shareConfig?.singleton === true;
+								const isReactRequire = options?.kind?.startsWith("require") && isReactSingleton;
+								if (options?.kind?.startsWith("require") && !isReactSingleton) return;
+								if (isCommonJsImporter(importer) && !isReactSingleton) return;
+								if (isReactRequire) {
+									writeLoadShareModule(source, shareItem, _command, isRolldown);
+									if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(source, shareItem);
+									addUsedShares(source);
+									return { id: "module-federation:optimized-require-react" };
+								}
 								const loadSharePath = getLoadShareModulePath(source, isRolldown);
 								writeLoadShareModule(source, shareItem, _command, isRolldown);
 								if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(source, shareItem);
@@ -5455,7 +5671,7 @@ export default __mfShared.default ?? __mfShared;`
 						const optimizeDeps = config.optimizeDeps ??= {};
 						optimizeDeps.include ??= [];
 						optimizeDeps.exclude ??= [];
-						const shouldBypassOptimizeDep = isLitShare(key) || key === "react" && hasPackageDependency("react-redux", root);
+						const shouldBypassOptimizeDep = isLitShare(key) || key === "react" && shareItem.shareConfig?.singleton === true;
 						if (optimizeDeps.include.includes(key)) optimizeDeps.exclude = optimizeDeps.exclude.filter((dep) => dep !== key);
 						else if (shouldBypassOptimizeDep) optimizeDeps.exclude.push(key);
 						else optimizeDeps.include.push(key);
@@ -5510,7 +5726,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 [import("./pluginDts-CrSsDUnT.js").then((n) => n.n).then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-CTAHkt4C.js").then((n) => n.n).then(({ default: pluginDts }) => pluginDts(options))];
 }
 function federation(mfUserOptions) {
 	if (isTestEnv()) return [];
@@ -5755,7 +5971,9 @@ function federation(mfUserOptions) {
 			},
 			load(id) {
 				if (id.includes("__loadShare__") || id.includes("__loadRemote__")) {
-					let code = VirtualModule.findById(id)?.code ?? readFileSync(id, "utf-8");
+					const virtualModule = VirtualModule.findById(id);
+					if (!virtualModule?.code) return null;
+					let code = virtualModule.code;
 					const environmentName = this.environment?.name;
 					if (environmentName && environmentName !== "client" || !environmentName && isSsrBuild) code = prependWorkspaceSingletonSsrImport(code);
 					code = code.replace(/import\s+["'][^"']*__prebuild__[^"']*["']\s*;?/g, "");
@@ -5839,7 +6057,15 @@ function federation(mfUserOptions) {
 				options.runtimePlugins.forEach((p) => {
 					const pluginPath = typeof p === "string" ? p : p[0];
 					if (SSR_ONLY_PLUGINS.has(pluginPath)) return;
-					if (pluginPath && !pluginPath.startsWith(".") && !pluginPath.startsWith("/") && !pluginPath.startsWith("\0") && !pluginPath.startsWith("virtual:")) config.optimizeDeps.include.push(pluginPath);
+					if (pluginPath && !pluginPath.startsWith(".") && !pluginPath.startsWith("/") && !pluginPath.startsWith("\0") && !pluginPath.startsWith("virtual:")) {
+						let optimizeDep = pluginPath;
+						if (pluginPath === "@module-federation/dts-plugin/dynamic-remote-type-hints-plugin") try {
+							optimizeDep = normalizePathForImport(resolveImportPath(pluginPath));
+						} catch {
+							optimizeDep = pluginPath;
+						}
+						config.optimizeDeps.include.push(optimizeDep);
+					}
 				});
 				if (isRolldown) {
 					config.build ??= {};