@module-federation/vite 1.21.6 → 1.22.0

package/README.md

@@ -242,6 +242,27 @@ You can specify the place the host initialization file is injected with the **ho
 The **moduleParseTimeout** option allows you to configure the maximum time to wait for module parsing during the build process.
 The **moduleParseIdleTimeout** option is an alternative that resets the timer on every parsed module. It only fires when there has been no module activity for the configured duration, making it suitable for large codebases where the total build time exceeds the fixed timeout.
 
+## SSR entry loading strategy
+
+SSR hosts can choose how HTTP ESM remote entries are evaluated during build and preview:
+
+```ts
+federation({
+  name: "host",
+  remotes: {
+    // ...
+  },
+  ssrEntryLoader: {
+    strategy: "vm",
+  },
+});
+```
+
+- `"temp-file"` (default) fetches the remote graph, rewrites imports to host-resolved shared packages, writes temporary files, and loads them with `import()`.
+- `"vm"` evaluates the graph in memory with `vm.SourceTextModule` and resolves shared packages through the Module Federation share scope.
+
+The `"vm"` strategy requires Node.js to run with `--experimental-vm-modules`. When unavailable, the loader warns once and falls back to `"temp-file"`. Vite 8 development uses `ModuleRunner`; this option primarily affects build and preview SSR entry loading.
+
 ## Runtime capability optimization
 
 Runtime features that a build never uses can be removed at build time:
@@ -326,9 +347,9 @@ This deployment step is separate from the local Vite build; the plugin only emit
 
 ## External runtime (`experiments`)
 
-Share one `@module-federation/runtime-core` instance from a pure consumer host so remotes do not bundle their own copy. Pair the flags — remotes with `externalRuntime` require a host that provides the global.
+Share one `@module-federation/runtime-core` instance from the host so remotes do not bundle their own copy. Pair the flags — remotes with `externalRuntime` require a host that provides the global.
 
-**Host (pure consumer, no `exposes`):**
+**Host:**
 
 ```ts
 federation({
@@ -361,14 +382,14 @@ federation({
 });
 ```
 
-`provideExternalRuntime` injects a local runtime plugin that publishes `runtime-core` on `globalThis._FEDERATION_RUNTIME_CORE`. `externalRuntime` rewrites imports of `@module-federation/runtime-core` to read that global. Using `provideExternalRuntime` together with `exposes` throws — only pure consumers may provide the runtime.
+`provideExternalRuntime` injects a local runtime plugin that publishes `runtime-core` on `globalThis._FEDERATION_RUNTIME_CORE`. `externalRuntime` rewrites imports of `@module-federation/runtime-core` to read that global. A container that also `exposes` (e.g. a host consumed by its own remotes) may provide the runtime too, as long as exactly one container on the page does and it is loaded before any `externalRuntime` remote evaluates (a second provider is ignored with a `Detect multiple module federation runtime!` warning; a remote evaluated before the provider throws `_FEDERATION_RUNTIME_CORE is missing`).
 The `externalRuntime` rewrite applies to the browser remote graph; SSR remote entries continue to resolve `@module-federation/runtime-core` from Node so they do not depend on the browser global.
 
 ## ⚠️ `codeSplitting` is managed by the plugin
 
 Do not set `build.rollupOptions.output.codeSplitting` or
 `build.rolldownOptions.output.codeSplitting` to `false` — it will be **ignored** (with a warning).
-Module Federation requires chunk splitting so `loadShare` and `runtimeInitStatus` stay isolated for correct bootstrap order.
+Module Federation requires chunk splitting so `runtimeInitStatus` and deferred `loadShare` wrappers stay isolated for correct bootstrap order. Eager `loadShare` wrappers are coalesced into one `loadShare-eager` chunk on Vite 8+ to reduce startup requests.
 
 ### `codeSplitting.groups` (Vite 8+ / Rolldown)
 

package/lib/{dtsConstants-BsaLBaaK.js → dtsConstants-BEGrtvcw.js}

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, readdirSync } from "fs";
 import { createRequire } from "module";
 import * as path$1 from "node:path";
 import { fileURLToPath, pathToFileURL } from "url";
+import { createHash } from "node:crypto";
 //#region src/utils/logger.ts
 const MODULE_FEDERATION_LOG_PREFIX = "[Module Federation]";
 function formatModuleFederationMessage(message) {
@@ -136,22 +137,37 @@ function getPackageExportsTarget(pkg, packageName, exportsField) {
 *  - => 3
 *  . => 4
 */
+const MF_HASHED_NAME_THRESHOLD = 90;
+const MF_HASHED_NAME_HASH_LENGTH = 16;
+const MF_HASHED_NAME_PREFIX_LENGTH = MF_HASHED_NAME_THRESHOLD - MF_HASHED_NAME_HASH_LENGTH;
+const mfHashedNameMap = /* @__PURE__ */ new Map();
 /**
-* Encodes a package name into a valid file name.
-* @param {string} name - The package name, e.g., "@scope/xx-xx.xx".
+* Encodes a package name (or shared-module specifier, which may include a
+* deep import subpath) into a valid file name, falling back to a
+* readable-prefix + content-hash id when the plain encoding would be too
+* long for a filesystem path segment.
+* @param {string} name - The package name or specifier, e.g., "@scope/xx-xx.xx" or "@scope/pkg/deep/sub-path".
 * @returns {string} - The encoded file name.
 */
 function packageNameEncode(name) {
 	if (typeof name !== "string") throw createModuleFederationError("A string package name is required");
-	return name.replace(/@/g, "_mf_0_").replace(/\//g, "_mf_1_").replace(/-/g, "_mf_2_").replace(/\./g, "_mf_3_");
+	const encoded = name.replace(/@/g, "_mf_0_").replace(/\//g, "_mf_1_").replace(/-/g, "_mf_2_").replace(/\./g, "_mf_3_");
+	if (encoded.length <= MF_HASHED_NAME_THRESHOLD) return encoded;
+	const hashedName = `${encoded.slice(0, MF_HASHED_NAME_PREFIX_LENGTH)}${createHash("sha256").update(name).digest("hex").slice(0, MF_HASHED_NAME_HASH_LENGTH)}`;
+	mfHashedNameMap.set(hashedName, name);
+	return hashedName;
 }
 /**
-* Decodes an encoded file name back to the original package name.
+* Decodes an encoded file name back to the original package name or
+* shared-module specifier, whether it was plainly substituted or hashed
+* down by `packageNameEncode`.
 * @param {string} encoded - The encoded file name, e.g., "_mf_0_scope_mf_1_xx_mf_2_xx_mf_3_xx".
-* @returns {string} - The decoded package name.
+* @returns {string} - The decoded package name or specifier.
 */
 function packageNameDecode(encoded) {
 	if (typeof encoded !== "string") throw createModuleFederationError("A string encoded file name is required");
+	const original = mfHashedNameMap.get(encoded);
+	if (original !== void 0) return original;
 	return encoded.replace(/_mf_0_/g, "@").replace(/_mf_1_/g, "/").replace(/_mf_2_/g, "-").replace(/_mf_3_/g, ".");
 }
 /**

package/lib/index.d.ts

@@ -126,6 +126,13 @@ type ModuleFederationOptions = {
    * add any other Node-only packages that should not be bundled into the SSR entry.
    */
   ssrExternals?: string[];
+  /**
+   * Options for the auto-injected `@module-federation/vite/ssrEntryLoader`.
+   * When omitted, the loader uses the `'temp-file'` strategy. Set
+   * `strategy: 'vm'` to opt into `vm.SourceTextModule` evaluation while keeping
+   * the computed `resolvedShared` map.
+   */
+  ssrEntryLoader?: SsrEntryLoaderConfig;
   /**
    * Experimental Module Federation capabilities.
    *
@@ -141,13 +148,28 @@ interface PluginExperimentsOptions {
    */
   externalRuntime?: boolean;
   /**
-   * Pure-consumer only (no `exposes`). Injects a local runtime plugin that
-   * publishes `runtime-core` on `globalThis._FEDERATION_RUNTIME_CORE`.
+   * Injects a local runtime plugin that publishes `runtime-core` on
+   * `globalThis._FEDERATION_RUNTIME_CORE`. Set it on exactly one container
+   * per page; that container may also `exposes`.
    */
   provideExternalRuntime?: boolean;
   /** Generate the React SSR/hydration island capability for eligible exposes. */
   ssrMode?: 'ISLAND';
 }
+type SsrEntryLoaderStrategy = 'temp-file' | 'vm';
+type SsrEntryLoaderConfig = {
+  /**
+   * How the auto-injected `@module-federation/vite/ssrEntryLoader` evaluates
+   * remote SSR entries.
+   *
+   * - `'temp-file'` (default when omitted): fetch the ESM graph, rewrite
+   *   specifiers, write temp files and `import()` them.
+   * - `'vm'`: evaluate the graph with `vm.SourceTextModule`. Requires
+   *   `--experimental-vm-modules`; the loader emits a single warning and
+   *   falls back to `'temp-file'` when that API is unavailable.
+   */
+  strategy?: SsrEntryLoaderStrategy;
+};
 type HostInitInjectLocationOptions = 'entry' | 'html';
 interface PluginDevOptions {
   disableLiveReload?: boolean;
@@ -227,4 +249,4 @@ interface DtsHostOptions {
 declare function federation(mfUserOptions: ModuleFederationOptions): any[];
 declare function createModuleFederationConfig<T extends ModuleFederationOptions>(options: T): T;
 //#endregion
-export { type ModuleFederationOptions, type PluginExperimentsOptions, type PluginManifestOptions, type TreeShakingConfig, createModuleFederationConfig, federation };
+export { type ModuleFederationOptions, type PluginExperimentsOptions, type PluginManifestOptions, type SsrEntryLoaderConfig, type SsrEntryLoaderStrategy, type TreeShakingConfig, createModuleFederationConfig, federation };

package/lib/index.js

@@ -1,5 +1,5 @@
 import { i as resolveHashPlaceholderFileName, n as normalizePathForImport, r as rebaseImport } from "./buildPaths-BoaQTkxt.js";
-import { a as getPackageDetectionCwd, c as getSharedCacheDescriptor, d as packageNameDecode, f as packageNameEncode, g as createModuleFederationError, h as sharedCacheHelperCode, i as getIsRolldown, l as hasPackageDependency, m as setPackageDetectionCwd, n as getInstalledPackageEntry, o as getPackageName, p as resolveImportPath, r as getInstalledPackageJson, s as getPackageNameFromNodeModulePath, u as isNuxtProjectRoot, v as mfWarn } from "./dtsConstants-BsaLBaaK.js";
+import { a as getPackageDetectionCwd, c as getSharedCacheDescriptor, d as packageNameDecode, f as packageNameEncode, g as createModuleFederationError, h as sharedCacheHelperCode, i as getIsRolldown, l as hasPackageDependency, m as setPackageDetectionCwd, n as getInstalledPackageEntry, o as getPackageName, p as resolveImportPath, r as getInstalledPackageJson, s as getPackageNameFromNodeModulePath, u as isNuxtProjectRoot, v as mfWarn } from "./dtsConstants-BEGrtvcw.js";
 import { a as filterId, c as getCommonSharedSubpaths, d as isNodeModulePath, f as isNuxtClientBase, h as resolvePublicPath, i as ensureTrailingSlash, l as getMatchingNodeModuleSubpath, m as normalizeNodeModulePath, n as invalidateSharedKeyMatcher, o as getBasePath$1, p as isViteOptimizableEntry, r as matchesSharedSource, s as getCommonSharedSubpathFromNodeModulePath, t as findSharedKey, u as isAssetLikeImport } from "./sharedKeyMatcher-DiUzRVH1.js";
 import { createRequire } from "node:module";
 import * as fs$2 from "fs";
@@ -373,6 +373,38 @@ async function mapCodeToCodeWithSourcemap(code) {
 	};
 }
 //#endregion
+//#region src/utils/remoteConsumerTarget.ts
+function getPluginEnvironmentName(ctx) {
+	if (ctx == null || typeof ctx !== "object") return void 0;
+	const environment = ctx["environment"];
+	if (environment == null || typeof environment !== "object") return void 0;
+	const name = environment["name"];
+	return typeof name === "string" ? name : void 0;
+}
+/**
+* Classify a plugin hook context's Vite environment. Environment names are
+* user-defined, so Vite's `config.consumer` is the semantic role; fall back to
+* the name only when it is missing (Vite 5–7). Returns `undefined` when the hook
+* has no environment context at all.
+*/
+function resolveEnvironmentConsumerTarget(ctx) {
+	if (ctx == null || typeof ctx !== "object") return void 0;
+	const environment = ctx["environment"];
+	if (environment == null || typeof environment !== "object") return void 0;
+	const consumer = environment.config?.consumer;
+	if (consumer === "client" || consumer === "server") return consumer;
+	const envName = getPluginEnvironmentName(ctx);
+	return !envName || envName === "client" ? "client" : "server";
+}
+/** Vite 5–7 hooks have no environment context and keep their client build behavior. */
+function isClientEnvironment(ctx) {
+	return resolveEnvironmentConsumerTarget(ctx) !== "server";
+}
+function resolveRemoteConsumer(ctx, hasMultiEnvironment) {
+	if (!hasMultiEnvironment) return "unified";
+	return resolveEnvironmentConsumerTarget(ctx) ?? "client";
+}
+//#endregion
 //#region src/utils/codePositionMap.ts
 const REGEX_PREFIX_KEYWORDS = /* @__PURE__ */ new Set([
 	"await",
@@ -887,6 +919,11 @@ function normalizeExperiments(experiments) {
 		ssrMode: experiments?.ssrMode === "ISLAND" ? "ISLAND" : void 0
 	};
 }
+function normalizeSsrEntryLoader(ssrEntryLoader) {
+	const strategy = ssrEntryLoader?.strategy;
+	if (strategy !== "temp-file" && strategy !== "vm") return void 0;
+	return { strategy };
+}
 let config;
 let explicitSharedKeys = /* @__PURE__ */ new Set();
 const explicitSharedKeysByOptions = /* @__PURE__ */ new WeakMap();
@@ -905,6 +942,18 @@ function resolveRuntimeImplementation() {
 function getNormalizeModuleFederationOptions() {
 	return config;
 }
+function hasRemotes(options = getNormalizeModuleFederationOptions()) {
+	return Object.keys(options.remotes || {}).length > 0;
+}
+function isRemoteContainer(options = getNormalizeModuleFederationOptions()) {
+	return Object.keys(options.exposes || {}).length > 0;
+}
+function isRemoteOnlyContainer(options = getNormalizeModuleFederationOptions()) {
+	return isRemoteContainer(options) && !hasRemotes(options);
+}
+function isLocalOnlyContainer(options = getNormalizeModuleFederationOptions()) {
+	return !isRemoteContainer(options) && !hasRemotes(options);
+}
 function isExplicitSharedKey(key, options) {
 	return (options ? explicitSharedKeysByOptions.get(options) : explicitSharedKeys)?.has(key) ?? false;
 }
@@ -945,6 +994,7 @@ function normalizeModuleFederationOptions(options) {
 		varFilename: options.varFilename,
 		target: options.target,
 		ssrExternals: options.ssrExternals,
+		ssrEntryLoader: normalizeSsrEntryLoader(options.ssrEntryLoader),
 		disableRemote: options.disableRemote,
 		disableShared: options.disableShared,
 		disableSnapshot: options.disableSnapshot,
@@ -1022,11 +1072,14 @@ var VirtualModule = class VirtualModule {
 		cacheMap[this.tag][this.name] = this;
 	}
 	getImportId() {
-		const importIdKey = `${this.scopeName ?? getNormalizeModuleFederationOptions().internalName}${this.tag}${this.name}${this.tag}`;
+		const mfName = this.scopeName ?? getNormalizeModuleFederationOptions().internalName;
+		const importIdKey = `${mfName}${this.tag}${this.name}${this.tag}`;
 		if (this.importId && this.importIdKey === importIdKey) return this.importId;
 		if (this.importId) delete idCacheMap[this.importId];
 		this.importIdKey = importIdKey;
-		this.importId = `virtual:mf:${packageNameEncode(importIdKey)}${this.suffix}`;
+		const namePart = packageNameEncode(this.name);
+		const mfNamePart = packageNameEncode(mfName);
+		this.importId = `virtual:mf:${mfNamePart}${this.tag}${namePart}${this.tag}${this.suffix}`;
 		idCacheMap[this.importId] = this;
 		return this.importId;
 	}
@@ -2191,8 +2244,12 @@ function getPackageEsmEntryPath(pkg) {
 }
 const packageNamedExportsCache = /* @__PURE__ */ new Map();
 const sharedExportInspectionCache = /* @__PURE__ */ new Map();
+const sharedMutableExportsCache = /* @__PURE__ */ new Map();
 function invalidateSharedExportInspectionCache(filePath) {
-	if (!/(?:^|[/\\])node_modules(?:[/\\]|$)/.test(filePath)) sharedExportInspectionCache.clear();
+	if (!/(?:^|[/\\])node_modules(?:[/\\]|$)/.test(filePath)) {
+		sharedExportInspectionCache.clear();
+		sharedMutableExportsCache.clear();
+	}
 }
 const DEFAULT_SHARED_EXPORT_CONDITIONS = [
 	"browser",
@@ -2278,7 +2335,7 @@ function getMutableExportsFromFile(entryPath, exportConditions = DEFAULT_SHARED_
 				if (isValidEsmExportName(exported) && (mutableBindings.has(local) || reExportedMutable.has(local))) mutableExports.add(exported);
 			}
 		}
-		const starExportRegex = /export\s+\*\s+from\s+['"]([^'"]+)['"]/g;
+		const starExportRegex = /export\s*\*\s*from\s*['"]([^'"]+)['"]/g;
 		while ((match = starExportRegex.exec(source)) !== null) {
 			if (!codePositions[match.index]) continue;
 			const resolved = resolveReExportModule(entryPath, match[1], exportConditions);
@@ -2293,10 +2350,18 @@ function getMutableExportsFromFile(entryPath, exportConditions = DEFAULT_SHARED_
 }
 function getSharedMutableExports(pkg, shareItem, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
 	const configuredImport = shareItem?.shareConfig.import;
-	return getMutableExportsFromFile(typeof configuredImport === "string" ? resolveConfiguredImportPath(configuredImport, exportConditions) : getInstalledPackageEntry(pkg, {
+	const entryPath = typeof configuredImport === "string" ? resolveConfiguredImportPath(configuredImport, exportConditions) : getInstalledPackageEntry(pkg, {
 		conditions: exportConditions,
 		resolveSubpathWithRequire: false
-	}), exportConditions);
+	});
+	if (!entryPath) return [];
+	const cacheKey = `${entryPath}\0${exportConditions.join("\0")}`;
+	let mutableExports = sharedMutableExportsCache.get(cacheKey);
+	if (!mutableExports) {
+		mutableExports = getMutableExportsFromFile(entryPath, exportConditions);
+		sharedMutableExportsCache.set(cacheKey, mutableExports);
+	}
+	return mutableExports;
 }
 function resolveConfiguredImportPath(importSource, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
 	if (path$1.isAbsolute(importSource)) return resolveFileLikeModule(importSource);
@@ -2609,15 +2674,15 @@ function getNamedExportsViaRegex(source, filePath, visited, scanState = { comple
 			else if (name === "default" || name === "__esModule") {} else scanState.complete = false;
 		}
 	}
-	const namespaceReExportRegex = new RegExp(`export\\s+\\*\\s+as\\s+(${JS_IDENTIFIER_PATTERN})\\s+from\\s+['"][^'"]+['"]`, "gu");
+	const namespaceReExportRegex = new RegExp(`export\\s*\\*\\s*as\\s+(${JS_IDENTIFIER_PATTERN})\\s*from\\s*['"][^'"]+['"]`, "gu");
 	while ((match = namespaceReExportRegex.exec(source)) !== null) {
 		if (!codePositions[match.index]) continue;
 		recognizedExportStarts.add(match.index);
 		if (isValidEsmExportName(match[1])) names.add(match[1]);
 	}
-	if (hasCodeMatch(source, /export\s+\*\s+as\s+['"]/g, codePositions)) scanState.complete = false;
+	if (hasCodeMatch(source, /export\s*\*\s*as\s*['"]/g, codePositions)) scanState.complete = false;
 	if (filePath) {
-		const starExportRegex = /export\s+\*\s+from\s+['"]([^'"]+)['"]/g;
+		const starExportRegex = /export\s*\*\s*from\s*['"]([^'"]+)['"]/g;
 		while ((match = starExportRegex.exec(source)) !== null) {
 			if (!codePositions[match.index]) continue;
 			recognizedExportStarts.add(match.index);
@@ -2852,12 +2917,6 @@ function isSharedSingletonConsumedByPeer(pkg, options = getNormalizeModuleFedera
 	};
 	return Array.from(sharedKeyByPackageName.values()).some((sharedPkg) => sharedPkg !== pkg && reachesPkg(sharedPkg, /* @__PURE__ */ new Set([sharedPkg])));
 }
-function isRemoteOnlyContainer(options = getNormalizeModuleFederationOptions()) {
-	return Object.keys(options.exposes || {}).length > 0 && Object.keys(options.remotes || {}).length === 0;
-}
-function isLocalOnlyContainer(options = getNormalizeModuleFederationOptions()) {
-	return Object.keys(options.exposes || {}).length === 0 && Object.keys(options.remotes || {}).length === 0;
-}
 function tryResolveImportFromPackageRoot(pkg, root) {
 	try {
 		return resolveWorkspaceEsmEntry(pkg, createRequire$1(pathToFileURL(path$1.join(root, "package.json"))).resolve(pkg), root);
@@ -3378,11 +3437,10 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	const liveNamedExportLine = liveNamedExports.length ? `export { ${liveNamedExports.join(", ")} } from ${escapeGeneratedStringLiteral(sharedImportSource)};` : "";
 	const hasCompleteExportCoverage = detectedNamedExports !== void 0;
 	const isWorkspaceSingleton = isWorkspacePackage && shareItem.shareConfig.singleton === true;
-	const isDefaultShareScope = shareItem.scope === void 0 || shareItem.scope === "default" || Array.isArray(shareItem.scope) && shareItem.scope[0] === "default";
-	const usesDeferredSingletonFallback = hasCompleteExportCoverage && shareItem.shareConfig.eager !== true && (isWorkspacePackage || command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true || command === "build" && isRemoteOnlyContainer(resolvedOptions) && (shareItem.shareConfig.singleton === true || isDefaultShareScope) && !isSharedSingletonConsumedByPeer(pkg, resolvedOptions, true));
+	const usesDeferredSingletonFallback = hasCompleteExportCoverage && shareItem.shareConfig.eager !== true && (isWorkspacePackage || command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true || command === "build" && isRemoteContainer(resolvedOptions) && !isSharedSingletonConsumedByPeer(pkg, resolvedOptions, true));
 	const servesRemoteSingletonFallback = command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true;
 	const isConsumedByPeerSingleton = isSharedSingletonConsumedByPeer(pkg, resolvedOptions);
-	const usesEntryInjectedRemoteFallback = hasCompleteExportCoverage && !isWorkspaceSingleton && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true && resolvedOptions.hostInitInjectLocation === "entry" && (command === "build" || isConsumedByPeerSingleton);
+	const usesEntryInjectedRemoteFallback = hasCompleteExportCoverage && !isWorkspaceSingleton && isRemoteContainer(resolvedOptions) && shareItem.shareConfig.singleton === true && resolvedOptions.hostInitInjectLocation === "entry" && (command === "build" || isConsumedByPeerSingleton);
 	const usesEagerWorkspaceFallback = hasCompleteExportCoverage && isWorkspaceSingleton && !servesRemoteSingletonFallback && (isConsumedByPeerSingleton || shareItem.shareConfig.eager === true);
 	const usesDeferredTreeShakingFallback = hasCompleteExportCoverage && Boolean(treeShakingConsumer);
 	const reactMixedModeGuard = pkg === "react" ? createReactMixedModeRuntimeGuard() : "";
@@ -3566,6 +3624,7 @@ function generateLocalSharedImportMap(options) {
 	const useDirectReactImport = shouldUseDirectReactImport();
 	const orderedShares = getOrderedUsedShares(options);
 	const sharesToMaterialize = new Set(getMaterializedShares(options));
+	const hasConsumeOnlyShare = orderedShares.some((pkg) => getNormalizeShareItem(pkg, resolvedOptions)?.shareConfig.import === false);
 	return `
     import {loadShare} from "@module-federation/runtime";
     ${orderedShares.map((pkg, index) => {
@@ -3574,12 +3633,47 @@ function generateLocalSharedImportMap(options) {
 		return `import * as __mfEagerShare_${index} from ${toSafeJsLiteral(getLocalSharedPackagePath(pkg, shareItem, options))};`;
 	}).filter(Boolean).join("\n")}
     ${normalizeRuntimeShareCode}
+    const __mfGetCachedReactFamily = (keys, reactKeys, localVersion, requiredExport) => {
+      const cache = globalThis.__mf_module_cache__?.share;
+      const react = reactKeys.map((key) => cache?.[key]).find((value) => value !== undefined);
+      const reactVersion = react?.version ?? react?.default?.version;
+      const actual = String(reactVersion || '').split(/[^0-9]+/).map(Number);
+      const expected = String(localVersion || '').split(/[^0-9]+/).map(Number);
+      for (let index = 0; index < Math.max(actual.length, expected.length); index++) {
+        if ((actual[index] || 0) < (expected[index] || 0)) return undefined;
+        if ((actual[index] || 0) > (expected[index] || 0)) break;
+      }
+      for (const key of keys) {
+        const cached = cache?.[key];
+        if (cached === undefined) continue;
+        if (!requiredExport || typeof cached?.[requiredExport] === 'function' || typeof cached?.default?.[requiredExport] === 'function') return cached;
+      }
+      return undefined;
+    };
+    ${hasConsumeOnlyShare ? `// A consume-only share has no local module: its entry is the same shape for every key, so one helper builds it instead of a literal per key
+    const __mfHostOnly = (name) => async () => {
+      throw new Error(\`[Module Federation] Shared module '\${name}' must be provided by host\`);
+    };
+    const __mfConsumeOnly = (name, version, scope, materialize, shareConfig) => ({
+      name,
+      version,
+      scope: [scope],
+      loaded: false,
+      materialize,
+      eager: shareConfig.eager,
+      from: ${toSafeJsLiteral(resolvedOptions.name)},
+      canLiveRebind: true,
+      get: __mfHostOnly(name),
+      shareConfig: { ...shareConfig, import: false },
+    });` : ""}
     const importMap = {
       ${orderedShares.map((pkg, index) => {
 		const shareItem = getNormalizeShareItem(pkg, resolvedOptions);
+		if (shareItem?.shareConfig.import === false) return `
+        ${toSafeJsLiteral(pkg)}: __mfHostOnly(${toSafeJsLiteral(pkg)})`;
 		return `
         ${toSafeJsLiteral(pkg)}: async () => {
-          ${shareItem?.shareConfig.import === false ? `throw new Error(\`[Module Federation] Shared module '\${${toSafeJsLiteral(pkg)}}' must be provided by host\`);` : shareItem?.shareConfig.eager ? `let pkg = __mfEagerShare_${index};
+          ${shareItem?.shareConfig.eager ? `let pkg = __mfEagerShare_${index};
             return pkg;` : `let pkg = await import(${toSafeJsLiteral(getLocalSharedPackagePath(pkg, shareItem, options))});
             return pkg;`}
         }
@@ -3590,9 +3684,20 @@ function generateLocalSharedImportMap(options) {
       ${orderedShares.map((key) => {
 		const shareItem = getNormalizeShareItem(key, resolvedOptions);
 		if (!shareItem) return null;
+		const isReactFamily = key.startsWith("react/") || key === "react-dom/client";
+		const cacheKeys = [key, ...key === "react-dom/client" ? ["react-dom"] : []].flatMap((pkg) => {
+			const descriptor = getSharedCacheDescriptor(pkg, shareItem);
+			return [descriptor.canonical, ...descriptor.aliases ?? []];
+		});
+		const reactCacheKeys = ["react"].flatMap((pkg) => {
+			const descriptor = getSharedCacheDescriptor(pkg, shareItem);
+			return [descriptor.canonical, ...descriptor.aliases ?? []];
+		});
 		const detectedNamedExports = getSharedNamedExports(key, shareItem);
 		const canLiveRebind = shareItem.shareConfig.import === false || detectedNamedExports !== void 0;
 		const treeShakingConfig = canLiveRebind ? shareItem.shareConfig.treeShaking : void 0;
+		if (shareItem.shareConfig.import === false && !treeShakingConfig) return `
+          ${toSafeJsLiteral(key)}: __mfConsumeOnly(${toSafeJsLiteral(key)}, ${toSafeJsLiteral(shareItem.version)}, ${toSafeJsLiteral(shareItem.scope)}, ${sharesToMaterialize.has(key)}, {singleton: ${shareItem.shareConfig.singleton}, requiredVersion: ${toSafeJsLiteral(shareItem.shareConfig.requiredVersion)}, strictVersion: ${shareItem.shareConfig.strictVersion}, eager: ${Boolean(shareItem.shareConfig.eager)}})`;
 		const treeShakingUsage = treeShakingConfig ? getTreeShakingExportUsage(key, shareItem, shareItem.name, options) : void 0;
 		const treeShakingProviderExports = treeShakingUsage?.kind === "exports" ? treeShakingUsage.usedExports : [];
 		const treeShakingUsedExports = resolvedOptions.injectTreeShakingUsedExports === false ? treeShakingConfig?.usedExports || [] : treeShakingProviderExports;
@@ -3609,26 +3714,54 @@ function generateLocalSharedImportMap(options) {
             eager: ${Boolean(shareItem.shareConfig.eager)},
             from: ${toSafeJsLiteral(resolvedOptions.name)},
             canLiveRebind: ${canLiveRebind},
-            async get () {
+            get () {
               if (${shareItem.shareConfig.import === false}) {
                 throw new Error(\`[Module Federation] Shared module '\${${toSafeJsLiteral(key)}}' must be provided by host\`);
               }
-              usedShared[${toSafeJsLiteral(key)}].loaded = true
-              const {${toSafeJsLiteral(key)}: pkgDynamicImport} = importMap
-              const res = await pkgDynamicImport()
-              const exportModule = ${toSafeJsLiteral(useDirectReactImport)} && ${toSafeJsLiteral(key)} === "react"
-                ? (res?.default ?? res)
-                : __mfNormalizeRuntimeShare({...res})
-              // All npm packages pre-built by vite will be converted to esm
-              if (exportModule.__esModule !== true) {
-                Object.defineProperty(exportModule, "__esModule", {
-                  value: true,
-                  enumerable: false
-                })
-              }
-              return function () {
-                return exportModule
+              // A webpack consumer built with eager: true calls get() synchronously and needs the
+              // factory, not a promise: once the module is loaded, hand the same factory back directly,
+              // and while it is loading hand every caller the same pending promise.
+              const share = usedShared[${toSafeJsLiteral(key)}]
+              if (share.lib) return share.lib
+              if (share.loading) return share.loading
+              const cachedSingleton = ${shareItem.shareConfig.singleton && isReactFamily}
+                ? __mfGetCachedReactFamily(
+                    ${toSafeJsLiteral(cacheKeys)},
+                    ${toSafeJsLiteral(reactCacheKeys)},
+                    ${toSafeJsLiteral(shareItem.version)},
+                    ${toSafeJsLiteral(key === "react-dom/client" ? "createRoot" : void 0)}
+                  )
+                : undefined
+              if (cachedSingleton !== undefined) {
+                share.lib = function () { return cachedSingleton }
+                share.loaded = true
+                return share.lib
               }
+              share.loading = (async () => {
+                try {
+                  const {${toSafeJsLiteral(key)}: pkgDynamicImport} = importMap
+                  const res = await pkgDynamicImport()
+                  const exportModule = ${toSafeJsLiteral(useDirectReactImport)} && ${toSafeJsLiteral(key)} === "react"
+                    ? (res?.default ?? res)
+                    : __mfNormalizeRuntimeShare({...res})
+                  // All npm packages pre-built by vite will be converted to esm
+                  if (exportModule.__esModule !== true) {
+                    Object.defineProperty(exportModule, "__esModule", {
+                      value: true,
+                      enumerable: false
+                    })
+                  }
+                  share.lib = function () {
+                    return exportModule
+                  }
+                  share.loaded = true
+                  return share.lib
+                } finally {
+                  // A failed import must not pin the rejection: the next get() retries
+                  share.loading = undefined
+                }
+              })()
+              return share.loading
             },
             shareConfig: {
               singleton: ${shareItem.shareConfig.singleton},
@@ -4054,10 +4187,26 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy, options) {
           );
           return;
         }
-        const pendingExternalProvider = typeof __mfGetPendingExternalSharedProvider === 'function'
-          ? __mfGetPendingExternalSharedProvider(pkg, share)
+        const externalProvider = typeof __mfGetExternalSharedProvider === 'function'
+          ? __mfGetExternalSharedProvider(pkg, share)
           : undefined;
-        if (pendingExternalProvider && !pendingExternalProvider.lib && !pendingExternalProvider.loaded) {
+        if (externalProvider) {
+          let externalFactory = externalProvider.lib;
+          if (!externalFactory && externalProvider.loading) externalFactory = await externalProvider.loading;
+          if (!externalFactory && externalProvider.loaded && typeof externalProvider.get === 'function') {
+            externalFactory = await externalProvider.get();
+          }
+          if (externalFactory) {
+            const externalModule = typeof externalFactory === "function" ? externalFactory() : externalFactory;
+            const externalResolved = await Promise.resolve(externalModule);
+            ${normalizeRuntimeShareCode}
+            __mfWriteSharedCache(
+              __mfModuleCache.share,
+              cacheDescriptor,
+              __mfNormalizeRuntimeShare(externalResolved),
+              externalProvider.from
+            );
+          }
           return;
         }
         const providerKey = cacheDescriptor.canonical;
@@ -4342,7 +4491,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
 	const needsSharedProviderSelectionHelper = Object.keys(options.shared ?? {}).length > 0;
 	const hasTreeShakingShared = Object.values(options.shared ?? {}).some((share) => !!share?.shareConfig.treeShaking);
 	const hasMultipleShareScopes = Array.isArray(options.shareScope);
-	const guardHostAutoInit = command === "build" && Object.keys(options.exposes ?? {}).length > 0 && Object.keys(options.remotes ?? {}).length > 0;
+	const guardHostAutoInit = command === "build" && isRemoteContainer(options) && hasRemotes(options);
 	const materializedShareBatches = toSafeJsLiteral(getShareBatches(options, false));
 	const runtimeImports = [
 		"init as runtimeInit",
@@ -4397,6 +4546,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   import {${runtimeImports}} from "@module-federation/runtime";
   ${runtimeHelperImports.length ? `import {${runtimeHelperImports.join(", ")}} from "@module-federation/runtime/helpers";` : ""}
   ${pluginImportNames.filter((item) => !isSsrOnlyPlugin(item[1])).map((item) => item[1]).join("\n")}
+  import __mfExposesMap from "${virtualExposesId}"
   ${command === "build" ? getRuntimeInitResolveBootstrapCode(false, getRuntimeInitStatusImportId(options)) : getRuntimeInitBootstrapCode(false, getRuntimeInitStatusImportId(options), void 0, void 0, exportConditions) + "\n  const { initResolve } = globalThis[globalKey];"}
   ${getRuntimeModuleCacheBootstrapCode(exportConditions)}
   const initTokens = {}
@@ -4405,7 +4555,6 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   const mfName = ${toSafeJsLiteral(options.name)}
   const __mfMaterializedShareBatches = ${materializedShareBatches}
   let localSharedImportMapPromise
-  let exposesMapPromise
   let __mfLateBridgeShared
   const shouldRetrySharedInitError = ${command !== "build"} && ((error) => {
     const message = String((error && error.message) || error || '');
@@ -4439,12 +4588,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   }
 
   async function getExposesMap() {
-    if (!exposesMapPromise) {
-      exposesMapPromise = retrySharedInit(() => import("${virtualExposesId}"))
-        .then((mod) => mod.default ?? mod)
-        .catch((e) => { exposesMapPromise = undefined; throw e; });
-    }
-    return exposesMapPromise
+    return __mfExposesMap
   }
 
   async function init(shared = {}, initScope = [], remoteEntryInitOptions = {}) {
@@ -4560,29 +4704,33 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       const parts = pkg.split('/');
       return pkg.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0];
     };
-    const __mfGetPendingExternalSharedProvider = (pkg, share, versionMap) => {
+    const __mfGetExternalSharedProvider = (pkg, share, versionMap, includePackage) => {
       if (typeof __mfSelectExternalSharedProvider !== 'function') return undefined;
       const packageName = __mfGetSharePackageName(pkg);
-      const candidates = packageName === pkg
+      const candidates = !includePackage || packageName === pkg
         ? [[pkg, share]]
         : [[pkg, share], [packageName, usedShared[packageName]]];
       for (const [candidatePkg, candidateShare] of candidates) {
         if (!candidateShare) continue;
         const candidateVersionMap = versionMap
           ? (candidatePkg === pkg ? versionMap : initialShared[candidatePkg])
-          : ${hasMultipleShareScopes ? "getShareVersions(candidatePkg, candidateShare)" : "shared[candidatePkg]"};
+          : (initialShared[candidatePkg] ?? ${hasMultipleShareScopes ? "getShareVersions(candidatePkg, candidateShare)" : "shared[candidatePkg]"});
         const provider = __mfSelectExternalSharedProvider(
           candidateVersionMap,
           candidatePkg,
           candidateShare,
           '${options.shareStrategy}'
         );
-        if (provider && isWebpackProvider(provider) && !provider.lib && !provider.loaded) {
-          return provider;
-        }
+        if (provider) return provider;
       }
       return undefined;
     };
+    const __mfGetPendingExternalSharedProvider = (pkg, share, versionMap) => {
+      const provider = __mfGetExternalSharedProvider(pkg, share, versionMap, true);
+      return provider && isWebpackProvider(provider) && !provider.lib && !provider.loaded
+        ? provider
+        : undefined;
+    };
     // handling circular init calls before an external provider can re-enter this container
     ${hasMultipleShareScopes ? `const shareScopeNamesToInitialize = [];
     for (const shareScopeName of shareScopeNames) {
@@ -5451,6 +5599,7 @@ function generatePendingSharesCode(command = "build", options) {
 	const pendingShareImports = command === "build" ? getMaterializedShares(options).filter((pkg) => {
 		const shareItem = getShareItemForPreload(pkg, resolvedOptions);
 		if (!shareItem || pkg.endsWith("/")) return false;
+		if (shareItem.shareConfig.eager) return false;
 		return shareItem.shareConfig.import !== false && !shareItem.shareConfig.treeShaking;
 	}).map((pkg) => `[${toSafeJsLiteral(pkg)}, () => import(${toSafeJsLiteral(getLoadShareModulePath(pkg, false, options))})]`) : [];
 	return `
@@ -5793,9 +5942,10 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
 	const devRuntimeBootstrap = `${getRuntimeInitBootstrapCode(enableSsrInit, getRuntimeInitStatusImportId(options), ssrRemotes, hostAutoInitPath, exportConditions)}
     const { initPromise, initResolve, initReject, moduleCache: __mfModuleCache } = globalThis[globalKey];`;
 	const importLine = command === "build" ? `${getRuntimeModuleCacheBootstrapCode(exportConditions)}
-    import { hostInitPromise as __mfHostInitPromise } from ${JSON.stringify(hostAutoInitPath)};` : `${devRuntimeBootstrap}
+    const __mfHostInitPromise = () => import(${JSON.stringify(hostAutoInitPath)})
+      .then((mod) => mod.hostInitPromise);` : `${devRuntimeBootstrap}
     ${command === "serve" && consumer !== "server" ? browserHostInitCode : ""}`;
-	const remoteLoadRuntimePromise = command === "build" ? "__mfHostInitPromise" : "initPromise";
+	const remoteLoadRuntimePromise = command === "build" ? "__mfHostInitPromise()" : "initPromise";
 	const remoteCacheKey = `${getRuntimeRemoteCachePrefix(options)}${id}`;
 	const remoteLoadFailureHandler = command === "build" ? `.catch((error) => {
             delete __mfModuleCache.remote[pendingKey];
@@ -5859,24 +6009,19 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
 }
 //#endregion
 //#region src/plugins/pluginAddEntry.ts
-const isPreloadableVirtualMfChunk = (name) => name.includes("virtual_mf") && !name.includes("__prebuild__") && !name.includes("__loadShare__");
+const isPreloadableVirtualMfChunk = (name) => name.includes("virtual_mf") && !name.includes("__prebuild__") && !name.includes("__loadShare__") && !name.includes("__loadRemote__");
 const HOST_INIT_PRELOAD_CHUNKS = [
 	(name) => name === "hostInit",
 	(name) => name === "remoteEntry",
-	(name) => name === "virtualExposes",
 	isPreloadableVirtualMfChunk,
 	(name) => name === "index"
 ];
 const isRemoteWarmupExcluded = (name) => name.includes("__prebuild__") || name.includes("__loadShare__");
-const REMOTE_ENTRY_WARMUP_CHUNKS = [
-	(name) => name === "hostInit",
-	(name) => name === "virtualExposes",
-	(name) => isPreloadableVirtualMfChunk(name) && !isRemoteWarmupExcluded(name)
-];
+const REMOTE_ENTRY_WARMUP_CHUNKS = [(name) => name === "hostInit", (name) => isPreloadableVirtualMfChunk(name) && !isRemoteWarmupExcluded(name)];
 function getChunksByFileName(bundle) {
 	return new Map(Object.values(bundle).filter((chunk) => chunk.type === "chunk").map((chunk) => [chunk.fileName, chunk]));
 }
-function collectPreloadChunkFiles(chunksByFileName, seeds, excludeFromClosure = (name) => name.includes("__prebuild__")) {
+function collectPreloadChunkFiles(chunksByFileName, seeds, excludeFromClosure = (name) => name.includes(PREBUILD_TAG)) {
 	const seenFiles = /* @__PURE__ */ new Set();
 	const files = [];
 	const queue = [...seeds];
@@ -6081,7 +6226,7 @@ const __mfCurrentScript = document.currentScript;
 		const remoteSources = isLoadedFirstClientBuild ? Array.from(getPreloadRemotes(normalizedOptions)) : Object.keys(getUsedRemotesMap(federationOptions));
 		return Array.from(new Set(remoteSources.flatMap((remote) => {
 			const registration = getRemoteRegistration(remote, normalizedOptions.remotes, federationOptions);
-			return registration && (registration.type === "module" || registration.type === "esm") && /^(?:https?:)?\/\//.test(registration.entry) ? [registration.entry] : [];
+			return registration && (registration.type === "module" || registration.type === "esm") && /^(?:https?:)?\/\//.test(registration.entry) && !/\.json(?:[?#]|$)/i.test(registration.entry) ? [registration.entry] : [];
 		})));
 	}
 	function getBootstrapSource(initSrc, entrySrc, useSystemImportFallback = false, options) {
@@ -6109,7 +6254,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
   import(/* @vite-ignore */ __mfRemoteEntryPrefetchUrl).catch(() => {});
 }
 ` : "";
-		const sharedPreloadSources = _command === "serve" && waitsForInit && Object.keys(normalizedOptions.exposes || {}).length > 0 && Object.keys(normalizedOptions.remotes || {}).length === 0 && federationOptions ? Array.from(getUsedShares(federationOptions)).filter((pkg) => !pkg.endsWith("/")).filter((pkg) => {
+		const sharedPreloadSources = _command === "serve" && waitsForInit && isRemoteOnlyContainer(normalizedOptions) && federationOptions ? Array.from(getUsedShares(federationOptions)).filter((pkg) => !pkg.endsWith("/")).filter((pkg) => {
 			const shareItem = federationOptions.shared[pkg] || Object.entries(federationOptions.shared).find(([key]) => key.endsWith("/") && pkg.startsWith(key))?.[1];
 			const isExplicitShare = Object.hasOwn(federationOptions.shared, pkg);
 			return shareItem?.shareConfig?.singleton === true && shareItem?.shareConfig?.import !== false && !shareItem?.shareConfig?.treeShaking && (isExplicitShare || typeof shareItem?.shareConfig?.import === "string" || Boolean(getProjectResolvedImportPath(pkg)));
@@ -6195,7 +6340,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 	}
 	function isFederationInternalVirtualId(id) {
 		const normalized = decodeViteId(id).replace(/^\0+/, "");
-		return normalized.includes("virtual:mf:") || /__(?:loadShare|prebuild|loadRemote)__/.test(normalized);
+		return normalized.includes("virtual:mf:") || normalized.startsWith("virtual:mf-") || /__(?:loadShare|prebuild|loadRemote)__/.test(normalized);
 	}
 	function isWorkspaceSourceId(id) {
 		const normalized = normalizeModuleId(decodeViteId(id));
@@ -6334,15 +6479,24 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 		configResolved(config) {
 			viteConfig = config;
 			skipTransformIds = new Set(skipTransformFor.map(resolveProjectId));
-			const ctx = this;
-			const envName = ctx != null && typeof ctx === "object" ? ctx["environment"] : void 0;
-			if (envName?.name && envName.name !== "client") return;
-			const inputOptions = getBuildInput(config);
+			const clientEnvironmentInputs = [];
+			for (const environment of Object.values(config.environments ?? {})) {
+				if (environment.consumer !== "client") continue;
+				const input = getBuildInput(environment);
+				if (!input) {
+					htmlFilePath ??= path$1.resolve(config.root, "index.html");
+					continue;
+				}
+				if (typeof input === "string") clientEnvironmentInputs.push(input);
+				else if (Array.isArray(input)) clientEnvironmentInputs.push(...input);
+				else clientEnvironmentInputs.push(...Object.values(input));
+			}
+			const inputOptions = clientEnvironmentInputs.length > 0 ? clientEnvironmentInputs : getBuildInput(config);
 			if (!inputOptions) htmlFilePath = path$1.resolve(config.root, "index.html");
 			else if (typeof inputOptions === "string") entryFiles = [resolveProjectId(inputOptions)];
 			else if (Array.isArray(inputOptions)) entryFiles = inputOptions.filter((input) => !isReactRouterClientRouteInput(String(input))).map(resolveProjectId);
 			else if (typeof inputOptions === "object") entryFiles = Object.values(inputOptions).filter((input) => !isReactRouterClientRouteInput(String(input))).map((input) => resolveProjectId(String(input)));
-			if (entryFiles.length > 0) htmlFilePath = getFirstHtmlEntryFile(entryFiles);
+			if (entryFiles.length > 0) htmlFilePath = getFirstHtmlEntryFile(entryFiles) ?? htmlFilePath;
 			if (config.command === "serve" && !htmlFilePath) {
 				const rootIndexHtml = path$1.resolve(config.root, "index.html");
 				if (fs$2.existsSync(rootIndexHtml)) htmlFilePath = rootIndexHtml;
@@ -6457,14 +6611,13 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 		},
 		transform(code, id) {
 			if (skipSvelteKitSsrBuild()) return;
+			if (viteConfig?.command === "build" && !waitsForInit) return;
 			if (isSvelteKitServerModule(id)) return;
 			if (hasEntryBootstrapParam(id)) return;
 			if (normalizeModuleId(id).endsWith(".html")) return;
 			const projectId = resolveProjectId(id);
 			if (skipTransformIds.has(projectId)) return;
-			const transformCtx = this;
-			const transformEnv = transformCtx != null && typeof transformCtx === "object" ? transformCtx["environment"] : void 0;
-			if (transformEnv?.name && transformEnv.name !== "client") return;
+			if (!isClientEnvironment(this)) return;
 			const isVinext = hasPackageDependency("vinext");
 			if (isVinext && inject === "html" && id.includes("virtual:vite-rsc/remove-duplicate-server-css")) {
 				const namespaceReactImport = `import * as React from 'react';`;
@@ -7252,7 +7405,7 @@ function pluginExternalRuntimeCore() {
 }
 //#endregion
 //#region package.json
-var version$1 = "1.21.6";
+var version$1 = "1.22.0";
 //#endregion
 //#region src/virtualModules/index.ts
 function initVirtualModules(command, remoteEntryId, enableSsrInit = false, options) {
@@ -7699,8 +7852,38 @@ function collectImportedCss(chunks) {
 	for (const chunk of chunks) for (const cssFile of chunk.viteMetadata?.importedCss ?? []) css.add(cssFile);
 	return Array.from(css);
 }
-function expandExposeAssets(filesMap, exposeModules, bundle, remoteEntryFileName, options) {
+/**
+* Collects the virtual module ids of the `__loadShare__` wrappers belonging to shares
+* that are not eager.
+*
+* Such a wrapper resolves its share through the host at runtime, so it is a deferred
+* dependency even though the expose statically imports it. Advertising it as a sync
+* asset makes a preloader fetch a provider the host is going to supply anyway.
+*/
+function collectDeferredShareModules(options, isRolldown) {
+	const deferred = /* @__PURE__ */ new Set();
+	for (const shareKey of getUsedShares(options)) {
+		const shareConfig = getNormalizeShareItem(shareKey, options)?.shareConfig;
+		if (shareConfig?.eager === true) continue;
+		if (shareConfig?.import === false) continue;
+		deferred.add(normalizeVirtualModuleId(getLoadShareModulePath(shareKey, isRolldown, options)));
+	}
+	return deferred;
+}
+/**
+* True when the chunk exists to load a deferred share rather than expose code.
+*
+* `chunk.moduleIds` carry Rollup's `\0` virtual-module prefix while
+* `getLoadShareModulePath` returns the unprefixed id, so both sides are normalized —
+* the same comparison `isContainerBootstrapChunk` makes.
+*/
+function isDeferredShareChunk(chunk, deferredShareModules) {
+	if (!chunk || chunk.type !== "chunk" || deferredShareModules.size === 0) return false;
+	return [chunk.facadeModuleId, ...chunk.moduleIds ?? []].some((id) => typeof id === "string" && deferredShareModules.has(normalizeVirtualModuleId(id)));
+}
+function expandExposeAssets(filesMap, exposeModules, bundle, remoteEntryFileName, options, isRolldown) {
 	if (exposeModules.length === 0) return;
+	const deferredShareModules = collectDeferredShareModules(options, isRolldown);
 	const containerChunks = remoteEntryFileName ? collectStaticChunks(bundle, [remoteEntryFileName]) : [];
 	const bootstrapChunks = containerChunks.slice(1);
 	const seen = new Set(containerChunks.map((chunk) => chunk.fileName));
@@ -7721,11 +7904,13 @@ function expandExposeAssets(filesMap, exposeModules, bundle, remoteEntryFileName
 	for (const exposeModule of exposeModules) {
 		const assets = filesMap[exposeModule];
 		if (!assets) continue;
-		const syncChunks = collectStaticChunks(bundle, assets.js.sync);
+		const allSyncChunks = collectStaticChunks(bundle, assets.js.sync);
+		const syncChunks = allSyncChunks.filter((chunk) => !isDeferredShareChunk(chunk, deferredShareModules));
+		const deferredChunks = allSyncChunks.filter((chunk) => isDeferredShareChunk(chunk, deferredShareModules));
 		const sync = Array.from(/* @__PURE__ */ new Set([...bootstrapAssets, ...syncChunks.map((chunk) => chunk.fileName)]));
 		const syncSet = new Set(sync);
-		const asyncChunks = collectStaticChunks(bundle, assets.js.async);
-		const async = asyncChunks.map((chunk) => chunk.fileName).filter((fileName) => !syncSet.has(fileName));
+		const asyncChunks = [...collectStaticChunks(bundle, assets.js.async), ...deferredChunks];
+		const async = Array.from(new Set(asyncChunks.map((chunk) => chunk.fileName))).filter((fileName) => !syncSet.has(fileName));
 		assets.js.sync = sync;
 		assets.js.async = async;
 		const syncCss = Array.from(/* @__PURE__ */ new Set([
@@ -7901,7 +8086,7 @@ const Manifest = (providedOptions) => {
 					root,
 					stripKnownJsExtensions: true
 				});
-				expandExposeAssets(filesMap, exposesModules, bundle, foundRemoteEntryFile, mfOptions);
+				expandExposeAssets(filesMap, exposesModules, bundle, foundRemoteEntryFile, mfOptions, getIsRolldown(this));
 				const fileToShareKey = await buildFileToShareKeyMap(getUsedShares(mfOptions), this.resolve.bind(this), mfOptions);
 				processModuleAssets(Object.fromEntries(Object.entries(bundle).filter(([, file]) => !isTreeShakingProviderChunk(file))), filesMap, (modulePath) => fileToShareKey.get(modulePath));
 				for (const shareKey of getUsedShares(mfOptions)) {
@@ -8438,21 +8623,6 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 	};
 }
 //#endregion
-//#region src/utils/remoteConsumerTarget.ts
-function getPluginEnvironmentName(ctx) {
-	if (ctx == null || typeof ctx !== "object") return void 0;
-	const environment = ctx["environment"];
-	if (environment == null || typeof environment !== "object") return void 0;
-	const name = environment["name"];
-	return typeof name === "string" ? name : void 0;
-}
-function resolveRemoteConsumer(ctx, hasMultiEnvironment) {
-	if (!hasMultiEnvironment) return "unified";
-	const envName = getPluginEnvironmentName(ctx);
-	if (!envName || envName === "client") return "client";
-	return "server";
-}
-//#endregion
 //#region src/plugins/pluginProxyRemotes.ts
 function isNodeModulesImporter(importer) {
 	return importer?.includes("/node_modules/") || importer?.includes("\\node_modules\\");
@@ -8755,6 +8925,21 @@ function isSharedPackageDependency(sharedKey, dependency) {
 	}
 	return reachable.has(dependency);
 }
+function isConfiguredSharedPackage(pkg, shared) {
+	return Object.keys(shared).some((key) => getPackageName(key) === pkg);
+}
+function shouldKeepSharedImportLocal(source, importer, sharedKey, shared, importerPackage) {
+	if (!importer || shared[sharedKey]?.shareConfig.import === false) return false;
+	const prebuildImporter = importer.includes("__prebuild__") ? VirtualModule.findModule(PREBUILD_TAG, importer) : void 0;
+	const fallbackPackage = prebuildImporter ? getPackageName(prebuildImporter.name) : importerPackage;
+	if (!fallbackPackage || !isConfiguredSharedPackage(fallbackPackage, shared)) return false;
+	const sourcePackage = getPackageName(sharedKey);
+	if (fallbackPackage !== "react-dom" || sourcePackage !== "react") return false;
+	if (prebuildImporter && matchesSharedSource(source, prebuildImporter.name)) return false;
+	if (!isSharedPackageDependency(prebuildImporter?.name ?? fallbackPackage, sourcePackage)) return false;
+	if (isSharedPackageDependency(sharedKey, fallbackPackage)) return false;
+	return true;
+}
 const sharedRuntimeDependencyCache = /* @__PURE__ */ new Map();
 const SOURCE_FILE_RE = /\.(?:[cm]?js|[cm]?ts|jsx|tsx)$/;
 const NON_RUNTIME_SOURCE_RE = /(?:\.d\.[cm]?ts|\.(?:test|spec|stories)\.[cm]?[jt]sx?)$/;
@@ -9124,7 +9309,7 @@ function proxySharedModule(options) {
 				if (!key) return;
 				const importerPackage = getSharedPackageFromFile(importer, shared);
 				if (importerPackage === getPackageName(key)) return;
-				if (importerPackage) {
+				if (importerPackage && shared[key].shareConfig.import !== false) {
 					const importerIsUnsharedWorkspacePackage = !isNodeModulePath(importer) && !Object.keys(shared).some((sharedKey) => getPackageName(sharedKey) === importerPackage);
 					const runtimeDependencyRequest = key.endsWith("/") && matchesSharedSource(source, key) ? source : key;
 					if (importerIsUnsharedWorkspacePackage ? isSharedPackageRuntimeDependency(runtimeDependencyRequest, importerPackage, getRuntimeDependencyConditions(this, resolveOptions)) : isSharedPackageDependency(key, importerPackage)) return;
@@ -9138,6 +9323,10 @@ function proxySharedModule(options) {
 				if (shouldSkipTaggedImporterProxy(key, "__loadShare__")) return;
 				if (shouldSkipTaggedImporterProxy(key, "__prebuild__")) return;
 				const shareSource = key === "vue" && source.startsWith("vue/dist/") ? key : isNodeModulePath(source) ? getCommonSharedSubpathFromNodeModulePath(source, key) || key : source;
+				if (shouldKeepSharedImportLocal(source, importer, key, shared, importerPackage)) {
+					const localSource = getPrebuildResolutionSource(shareSource, shared[key]);
+					return tryResolveFromProjectRoot(localSource) || localSource;
+				}
 				const loadSharePath = getLoadShareModulePath(shareSource, useRolldown, federationOptions);
 				if (!materializedLoadShareSources.has(shareSource)) {
 					materializedLoadShareSources.add(shareSource);
@@ -9944,11 +10133,7 @@ var aliasToArrayPlugin_default = {
 };
 //#endregion
 //#region src/utils/controlChunkSanitizer.ts
-const FEDERATION_CONTROL_CHUNK_HINTS = [
-	"hostInit",
-	"virtualExposes",
-	"localSharedImportMap"
-];
+const FEDERATION_CONTROL_CHUNK_HINTS = ["hostInit", "localSharedImportMap"];
 function stripEmptyPreloadCalls(code) {
 	const helperImportRegex = /import\s*\{\s*_\s*as\s*([A-Za-z_$][\w$]*)\s*\}\s*from\s*["'][^"']+["']\s*;?/g;
 	const helperAliases = [];
@@ -10159,7 +10344,7 @@ function escapeUnsafeJsSourceChars(str) {
 }
 function isFederationHtmlPreloadDependency(dep, includeSharedRuntime = false) {
 	const file = path$1.basename(dep);
-	if (file.includes("__mfe_internal__") || file.includes("virtual_mf-") || file.includes("virtualExposes") || file.includes("localSharedImportMap") || file.includes("hostInit")) return true;
+	if (file.includes("__mfe_internal__") || file.includes("virtual_mf-") || file.includes("localSharedImportMap") || file.includes("hostInit")) return true;
 	return includeSharedRuntime && (file.includes("preload-helper") || file.includes("rolldown-runtime") || file.startsWith("dist-"));
 }
 function canResolveSharedSubpath(subpath, projectRoot) {
@@ -10568,9 +10753,7 @@ export default __mfShared.default ?? __mfShared;`
 				const automaticJsxRuntime = getAutomaticJsxRuntime(config);
 				if (automaticJsxRuntime && materializeAutomaticJsxRuntime(options, automaticJsxRuntime)) writeLocalSharedImportMap(options);
 			}
-			const viteMajor = parseInt(version, 10);
-			const hasRemotes = Object.keys(options.remotes).length > 0;
-			if (!getSsrCapabilities(viteMajor, config.command, hasRemotes).injectSsrEntryLoader) return;
+			if (!getSsrCapabilities(parseInt(version, 10), config.command, hasRemotes(options)).injectSsrEntryLoader) return;
 			if (options.runtimePlugins.some((p) => {
 				return (typeof p === "string" ? p : p[0]) === "@module-federation/vite/ssrEntryLoader";
 			})) return;
@@ -10597,7 +10780,10 @@ export default __mfShared.default ?? __mfShared;`
 			const ssrEntryLoaderSpecifier = SSR_ENTRY_LOADER_SPECIFIER;
 			try {
 				resolveImportPath(ssrEntryLoaderSpecifier);
-				options.runtimePlugins.push([ssrEntryLoaderSpecifier, { resolvedShared }]);
+				options.runtimePlugins.push([ssrEntryLoaderSpecifier, {
+					resolvedShared,
+					...options.ssrEntryLoader?.strategy ? { strategy: options.ssrEntryLoader.strategy } : {}
+				}]);
 			} catch {}
 		}
 	};
@@ -10613,7 +10799,7 @@ function applyBuildTimeRuntimeDefines(define, options, { target, isAstro, defaul
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-4sHIZPIi.js").then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-D7Faa4NJ.js").then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {
@@ -10638,7 +10824,6 @@ function resolveInjectExternalRuntimeCorePlugin() {
 function applyExternalRuntimeExperiments(options) {
 	const { experiments } = options;
 	if (experiments.provideExternalRuntime) {
-		if (Object.keys(options.exposes).length > 0) throw createModuleFederationError("You can only set provideExternalRuntime: true in pure consumer which not expose modules.");
 		if (!hasInjectExternalRuntimeCorePlugin(options.runtimePlugins)) options.runtimePlugins = options.runtimePlugins.concat(resolveInjectExternalRuntimeCorePlugin());
 	}
 }
@@ -10654,7 +10839,7 @@ function federation(mfUserOptions) {
 	const virtualExposesId = getVirtualExposesId(options);
 	const moduleParseController = createModuleParseController();
 	const moduleParsePlugins = pluginModuleParseEnd_default((id) => {
-		return id.includes(getHostAutoInitPath(options)) || id.includes(getPendingSharesPath(options)) || id.includes(remoteEntryId) || id.includes(virtualExposesId) || id.includes("virtual:mf-localSharedImportMap") || id.includes("__loadShare__") || id.includes("__prebuild__") || id.includes("__treeShakingProvider__") || id.includes("__mf_tree_shaking_graph__");
+		return id.includes(getHostAutoInitPath(options)) || id.includes(getPendingSharesPath(options)) || id.includes("virtual:mf-REMOTE_ENTRY_ID") || id.includes(virtualExposesId) || id.includes("virtual:mf-localSharedImportMap") || id.includes("__loadShare__") || id.includes("__prebuild__") || id.includes("__treeShakingProvider__") || id.includes("__mf_tree_shaking_graph__");
 	}, {
 		moduleParseTimeout: options.moduleParseTimeout,
 		moduleParseIdleTimeout: options.moduleParseIdleTimeout,
@@ -10829,11 +11014,6 @@ function federation(mfUserOptions) {
 			skipTransformFor: Object.values(options.exposes).map((expose) => expose.import),
 			federationOptions: options
 		}),
-		...addEntry({
-			entryName: "virtualExposes",
-			entryPath: virtualExposesId,
-			federationOptions: options
-		}),
 		pluginProxyRemoteEntry_default({
 			options,
 			remoteEntryId,
@@ -10857,6 +11037,10 @@ function federation(mfUserOptions) {
 				const runtimeInitId = getRuntimeInitStatusImportId(options);
 				config.build = config.build || {};
 				if (config.build.modulePreload !== false) {
+					const remoteEntryBasename = path$1.posix.basename(options.filename);
+					const hashParts = remoteEntryBasename.split(/\[hash(?::\d+)?\]/);
+					const remoteEntryFilePattern = new RegExp(`^${hashParts.map((part) => escapeRegExp(part)).join("[\\w-]+")}${hashParts.length > 1 && !/\.[^/.]+$/.test(remoteEntryBasename) ? "\\.js" : ""}$`);
+					const isRemoteEntryFile = (file) => file === remoteEntryBasename || remoteEntryFilePattern.test(file);
 					const currentModulePreload = config.build.modulePreload && typeof config.build.modulePreload === "object" ? config.build.modulePreload : {};
 					const existingResolveDependencies = currentModulePreload.resolveDependencies;
 					config.build.modulePreload = {
@@ -10864,7 +11048,7 @@ function federation(mfUserOptions) {
 						resolveDependencies(filename, deps, context) {
 							const resolvedDeps = existingResolveDependencies ? existingResolveDependencies(filename, deps, context) : deps;
 							const hostFile = path$1.basename(context.hostId);
-							if (context.hostType === "js" && (hostFile === options.filename || hostFile.includes("hostInit") || hostFile.includes("virtualExposes") || hostFile.includes("localSharedImportMap"))) return [];
+							if (context.hostType === "js" && (isRemoteEntryFile(hostFile) || hostFile.includes("hostInit") || hostFile.includes("localSharedImportMap"))) return [];
 							const hasFederationHtmlDeps = context.hostType === "html" && resolvedDeps.some((dep) => isFederationHtmlPreloadDependency(dep));
 							const hasFederationJsDeps = context.hostType === "js" && resolvedDeps.some((dep) => isFederationHtmlPreloadDependency(dep));
 							const treeShakingFallbackDeps = hasTreeShakingShared ? (dep) => dep.includes("__prebuild__") : () => false;
@@ -10903,6 +11087,10 @@ function federation(mfUserOptions) {
 					const mfChunkName = function(id) {
 						if (id.includes(runtimeInitId) || id.includes("__mf_v__runtimeInit__mf_v__")) return "runtimeInit";
 						if (id.includes("__loadShare__")) {
+							const pkg = getCachedLoadSharePkg(id);
+							const key = pkg && findSharedKey(pkg, shared);
+							if (useCodeSplitting && key && shared[key].shareConfig.eager === true) return "loadShare-eager";
+							if (key && shared[key].shareConfig.import === false) return null;
 							const match = id.match(/([^/\\]+__loadShare__[^/\\]+)/);
 							return match ? match[1] : "loadShare";
 						}
@@ -11011,8 +11199,8 @@ function federation(mfUserOptions) {
 					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);
+					const consumerTarget = resolveEnvironmentConsumerTarget(this);
+					if (consumerTarget === "server" || !consumerTarget && isSsrBuild) code = prependWorkspaceSingletonSsrImport(code);
 					code = code.replace(/import\s+["'][^"']*__prebuild__[^"']*["']\s*;?/g, "");
 					code = code.replace(/export\s+\*\s+from\s+["'][^"']*__prebuild__[^"']*["']\s*;?/g, "");
 					if (!(/\b(?:var|let|const)\s+__moduleExports\b/.test(code) || /\bexport\s+const\s+__moduleExports\b/.test(code) || /\bexport\s*\{[^}]*__moduleExports/.test(code))) {

package/lib/{pluginDts-4sHIZPIi.js → pluginDts-D7Faa4NJ.js}

@@ -1,5 +1,5 @@
 import { n as normalizePathForImport } from "./buildPaths-BoaQTkxt.js";
-import { _ as mfError, g as createModuleFederationError, l as hasPackageDependency, p as resolveImportPath } from "./dtsConstants-BsaLBaaK.js";
+import { _ as mfError, g as createModuleFederationError, l as hasPackageDependency, p as resolveImportPath } from "./dtsConstants-BEGrtvcw.js";
 import fs from "fs";
 import * as path$1 from "node:path";
 import os from "os";

package/lib/{ssrEntryLoader-BqzV2t-n.js → ssrEntryLoader-CMVCDSsG.js}

@@ -470,7 +470,10 @@ async function getSSREntry(remoteEntryUrl, maxAgeMs, fetchTimeoutMs, fetchMaxByt
 	manifestFetchCache.delete(makeUrlCacheKey(getManifestUrl(remoteEntryUrl), fetchTimeoutMs, fetchMaxBytes));
 	const record = setSsrEntryCache(remoteEntryUrl, fetchTimeoutMs, fetchMaxBytes);
 	const next = await record.promise.catch(() => null);
-	if (previous && next && previous.versionKey !== next.versionKey) dropRemoteCaches(remoteEntryUrl);
+	if (previous && next && previous.versionKey !== next.versionKey) {
+		dropRemoteCaches(remoteEntryUrl);
+		await clearRunnerCaches(remoteEntryUrl);
+	}
 	return record.promise;
 }
 /**
@@ -490,17 +493,18 @@ function dropRemoteCaches(remoteEntryUrl) {
 		tempFilePathCache.delete(key);
 	}
 }
-function clearRunnerCaches(remoteEntryUrl) {
+async function clearRunnerCaches(remoteEntryUrl) {
 	let remoteOrigin;
 	if (remoteEntryUrl) try {
 		remoteOrigin = new URL(remoteEntryUrl).origin;
 	} catch {
 		return;
 	}
-	for (const cached of runnerCache.values()) {
-		if (remoteOrigin && cached.remoteOrigin !== remoteOrigin) continue;
-		cached.promise.then((runner) => runner?.clearCache?.()).catch(() => {});
-	}
+	await Promise.all([...runnerCache.values()].filter((cached) => !remoteOrigin || cached.remoteOrigin === remoteOrigin).map(async (cached) => {
+		try {
+			(await cached.promise)?.clearCache?.();
+		} catch {}
+	}));
 }
 /**
 * Drop the loader's caches so the next `loadEntry` re-resolves and re-fetches
@@ -662,7 +666,7 @@ async function importTempModule(filePath, versionKey) {
 }
 let warnedVmUnavailable = false;
 async function tryVmStrategy(ssrEntry, options) {
-	const { loadViaVmStrategy, isVmStrategyAvailable } = await import("./ssrVmStrategy-CkmYR5_u.js");
+	const { loadViaVmStrategy, isVmStrategyAvailable } = await import("./ssrVmStrategy-Cx9WlTsx.js");
 	if (!await isVmStrategyAvailable()) {
 		if (!warnedVmUnavailable) {
 			warnedVmUnavailable = true;

package/lib/{ssrVmStrategy-CkmYR5_u.js → ssrVmStrategy-Cx9WlTsx.js}

@@ -1,5 +1,5 @@
 import { t as findSharedKey } from "./sharedKeyMatcher-DiUzRVH1.js";
-import { c as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, s as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-BqzV2t-n.js";
+import { c as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, s as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-CMVCDSsG.js";
 //#region src/utils/ssrVmStrategy.ts
 /**
 * vm.SourceTextModule strategy for loading remote SSR entries.

package/lib/utils/ssrEntryLoader.js

@@ -1,2 +1,2 @@
-import { i as ssrEntryLoaderPlugin, n as neutralizeBrowserPreloadHelpers, r as revalidate, t as SsrEntryHttpError } from "../ssrEntryLoader-BqzV2t-n.js";
+import { i as ssrEntryLoaderPlugin, n as neutralizeBrowserPreloadHelpers, r as revalidate, t as SsrEntryHttpError } from "../ssrEntryLoader-CMVCDSsG.js";
 export { SsrEntryHttpError, ssrEntryLoaderPlugin as default, neutralizeBrowserPreloadHelpers, revalidate };

package/package.json

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