@module-federation/vite 1.16.11 → 1.16.12

package/README.md

@@ -6,6 +6,23 @@
 
 [Read the announcement](https://www.linkedin.com/posts/voidzero_github-module-federationvite-vite-plugin-activity-7449452398202241024-JyAL).
 
+<div align="center">
+  <h2>Gold Sponsor</h2>
+  <a href="https://www.zephyr-cloud.io/">
+    <img src="./docs/sponsors/zephyr-logo.png" alt="Zephyr Cloud" width="360" />
+  </a>
+
+  <h3>Sponsors</h3>
+  <p>
+    <a href="https://github.com/thecoder93">
+      <img src="https://github.com/thecoder93.png?size=96" alt="thecoder93" width="64" height="64" />
+    </a>
+    <a href="https://github.com/stephanelgrg">
+      <img src="https://github.com/stephanelgrg.png?size=96" alt="stephanelgrg" width="64" height="64" />
+    </a>
+  </p>
+</div>
+
 ## Reason why 🤔
 
 [Microservices](https://martinfowler.com/articles/microservices.html) nowadays is a well-known concept and maybe you are using it in your current company.

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.
@@ -722,7 +744,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 +803,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 +884,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 +1056,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 +1077,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 +1090,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 +1166,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 +1192,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);
@@ -1244,34 +1300,36 @@ 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}
@@ -1279,7 +1337,7 @@ function generateLazyWorkspaceSingletonExports(namedExports, importSource, cache
         initPromise.then(() =>
           import(${escapeGeneratedStringLiteral(importSource)}).then((mod) => {
             exportModule = __mfNormalizeShareModule(mod);
-            __mfModuleCache.share[${escapeGeneratedStringLiteral(cacheKey)}] = exportModule;
+            __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule);
             __mfApplyLazyShareExports(exportModule);
           })
         );
@@ -1301,19 +1359,16 @@ 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)}];
+        exportModule = __mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor});
         if (exportModule === undefined) {
           throw new Error("[Module Federation] Shared module ${pkg} was imported before federation bootstrap finished.");
         }
@@ -1322,7 +1377,7 @@ function generateDeferredHostProvidedExports(namedExports, pkg, cacheKey) {
     } 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 +1399,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 +1428,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 +1446,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 +1458,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 +1654,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 +1664,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 +1820,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 +1839,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 +1859,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)}
@@ -1849,8 +1903,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,7 +1912,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[cacheKey] = __mfNormalizeRuntimeShare(resolved);
+      __mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, __mfNormalizeRuntimeShare(resolved));
     }
     return initRes
   }
@@ -1885,16 +1939,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 +1956,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 +2216,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}
@@ -2298,8 +2352,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 +2369,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;
 			}
 		}
@@ -2402,8 +2456,8 @@ 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) {
@@ -2634,9 +2688,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 +3837,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);
@@ -4145,25 +4200,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\\");
@@ -4861,6 +4897,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 +4951,7 @@ function pluginSSRRemoteEntry(options) {
 		}
 	}, {
 		name: "mf:ssr-remote-entry",
+		sharedDuringBuild: true,
 		configResolved(config) {
 			viteConfig = config;
 			isNuxtProject = isNuxtProjectRoot(config.root);
@@ -5041,11 +5081,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 +5458,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 +5564,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 +5619,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 [];

package/lib/{pluginDts-CrSsDUnT.js → pluginDts-CTAHkt4C.js}

@@ -193,10 +193,56 @@ function getPackageNameFromNodeModulePath(source) {
 	if (parts[0].startsWith("@")) return parts[1] ? `${parts[0]}/${parts[1]}` : void 0;
 	return parts[0];
 }
-function getSharedCacheKey(pkg, shareItem) {
-	const prefix = `${shareItem.scope || "default"}:`;
-	return shareItem.shareConfig.singleton || !shareItem.version ? `${prefix}${pkg}` : `${prefix}${pkg}@${shareItem.version}`;
+function getSharedCacheKeyParts(input) {
+	const scope = (Array.isArray(input.scope) ? input.scope[0] : input.scope) || "default";
+	const id = input.singleton || !input.version ? input.pkg : `${input.pkg}@${input.version}`;
+	return {
+		scope,
+		id,
+		key: `${scope}:${id}`
+	};
+}
+function getSharedCacheDescriptor(pkg, shareItem) {
+	const parts = getSharedCacheKeyParts({
+		pkg,
+		singleton: shareItem.shareConfig.singleton,
+		version: shareItem.version,
+		scope: shareItem.scope
+	});
+	return {
+		canonical: parts.key,
+		...parts.scope === "default" ? { aliases: [parts.id] } : {}
+	};
 }
+const sharedCacheHelperCode = `const __mfGetSharedCacheDescriptor = (pkg, singleton, version, scope) => {
+            const normalizedScope = Array.isArray(scope) ? scope[0] : scope;
+            const scopeName = normalizedScope || "default";
+            const id = singleton || !version ? pkg : pkg + "@" + version;
+            const descriptor = { canonical: scopeName + ":" + id };
+            if (scopeName === "default") descriptor.aliases = [id];
+            return descriptor;
+          };
+          const __mfReadSharedCache = (cache, descriptor) => {
+            const value = cache[descriptor.canonical];
+            if (value !== undefined) return value;
+            const aliases = descriptor.aliases || [];
+            for (const alias of aliases) {
+              const aliasValue = cache[alias];
+              if (aliasValue !== undefined) {
+                cache[descriptor.canonical] = aliasValue;
+                return aliasValue;
+              }
+            }
+            return undefined;
+          };
+          const __mfWriteSharedCache = (cache, descriptor, value) => {
+            cache[descriptor.canonical] = value;
+            const aliases = descriptor.aliases || [];
+            for (const alias of aliases) {
+              if (cache[alias] === undefined) cache[alias] = value;
+            }
+            return value;
+          };`;
 function getInstalledPackageJson(pkg, opts) {
 	const cwd = opts?.cwd || getPackageDetectionCwd();
 	const packageName = opts?.packageName || getPackageName(pkg);
@@ -630,4 +676,4 @@ function pluginDts(options) {
 	}];
 }
 //#endregion
-export { mfWarn as _, getIsRolldown as a, getPackageNameFromNodeModulePath as c, isNuxtProjectRoot as d, packageNameDecode as f, createModuleFederationError as g, setPackageDetectionCwd as h, getInstalledPackageJson as i, getSharedCacheKey as l, resolveImportPath as m, pluginDts_exports as n, getPackageDetectionCwd as o, packageNameEncode as p, getInstalledPackageEntry as r, getPackageName as s, DEFAULT_PUBLIC_TYPES_FOLDER as t, hasPackageDependency as u, normalizePathForImport as v, rebaseImport as y };
+export { createModuleFederationError as _, getIsRolldown as a, rebaseImport as b, getPackageNameFromNodeModulePath as c, isNuxtProjectRoot as d, packageNameDecode as f, sharedCacheHelperCode as g, setPackageDetectionCwd as h, getInstalledPackageJson as i, getSharedCacheDescriptor as l, resolveImportPath as m, pluginDts_exports as n, getPackageDetectionCwd as o, packageNameEncode as p, getInstalledPackageEntry as r, getPackageName as s, DEFAULT_PUBLIC_TYPES_FOLDER as t, hasPackageDependency as u, mfWarn as v, normalizePathForImport as y };

package/lib/utils/ssrEntryLoader.d.ts

@@ -8,7 +8,7 @@
  * `loadScriptNode` — if the hook returns a value, the runtime uses it directly.
  *
  * Strategy:
- *  - In Node (typeof window === 'undefined'), fetch the remote's mf-manifest.json
+ *  - In Node (detected through process.versions.node), fetch the remote's mf-manifest.json
  *    to discover the ssrRemoteEntry URL and its type.
  *  - ESM entry: use a dynamic `import()` — the SSR entry has no browser
  *    globals and all shared packages are external.

package/lib/utils/ssrEntryLoader.js

@@ -8,7 +8,7 @@
 * `loadScriptNode` — if the hook returns a value, the runtime uses it directly.
 *
 * Strategy:
-*  - In Node (typeof window === 'undefined'), fetch the remote's mf-manifest.json
+*  - In Node (detected through process.versions.node), fetch the remote's mf-manifest.json
 *    to discover the ssrRemoteEntry URL and its type.
 *  - ESM entry: use a dynamic `import()` — the SSR entry has no browser
 *    globals and all shared packages are external.
@@ -34,6 +34,7 @@ async function nodeImport(id) {
 ));
 	return importCache.get(id);
 }
+const isNodeServer = () => typeof globalThis.process?.versions?.node === "string";
 const runnerCache = /* @__PURE__ */ new Map();
 /**
 * Import `vite/module-runner` dynamically. Returns null on Vite < 8 where the
@@ -362,7 +363,7 @@ function ssrEntryLoaderPlugin(options = {}) {
 	return {
 		name: "mf-vite:ssr-entry-loader",
 		async loadEntry({ remoteInfo }) {
-			if (typeof globalThis.window !== "undefined") return;
+			if (!isNodeServer()) return;
 			const ssrEntry = await getSSREntry(remoteInfo.entry);
 			if (!ssrEntry) return;
 			const mod = await loadSSRRemoteEntry(ssrEntry, resolvedShared);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/vite",
-  "version": "1.16.11",
+  "version": "1.16.12",
   "description": "Vite plugin for Module Federation",
   "type": "module",
   "main": "./lib/index.js",