@module-federation/vite 1.21.5 → 1.22.0

package/lib/index.js

@@ -1,5 +1,5 @@
-import { n as normalizePathForImport, r as rebaseImport } from "./buildPaths-BkaQHrd2.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 { 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-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";
@@ -14,13 +14,23 @@ 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";
 import { isIPv6 } from "node:net";
+//#region src/utils/regexEscape.ts
+const REGEXP_SPECIAL_CHARS_RE = /[.*+?^${}()|[\]\\]/g;
+/**
+* Escape `value` so it matches literally when interpolated into a regex source.
+*
+* Federation interpolates user-controlled strings — package names, chunk file
+* names, virtual module ids — into generated matchers. Those routinely contain
+* `.`, `+`, `[` and `\`, which would otherwise change what the pattern matches.
+*/
+function escapeRegExp(value) {
+	return value.replace(REGEXP_SPECIAL_CHARS_RE, "\\$&");
+}
+//#endregion
 //#region src/utils/bundleHelpers.ts
 function isOutputChunk$1(chunk) {
 	return chunk.type === "chunk";
 }
-function escapeRegExp$2(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 /**
 * Whether `code` references `name` as a whole identifier.
 *
@@ -30,7 +40,7 @@ function escapeRegExp$2(value) {
 * as "unused", which orphans a still-referenced import.
 */
 function isIdentifierReferenced(name, code) {
-	return new RegExp(`(?<![$\\w])${escapeRegExp$2(name)}(?![$\\w])`).test(code);
+	return new RegExp(`(?<![$\\w])${escapeRegExp(name)}(?![$\\w])`).test(code);
 }
 function getProxyBaseName(fileName) {
 	return fileName.replace(/^.*\//, "").replace(/\.js$/, "").replace(/-[A-Za-z0-9_-]+$/, "");
@@ -40,10 +50,10 @@ function getProxyBaseName(fileName) {
 * regex end-anchor, so the pattern would silently match nothing.
 */
 function functionDeclarationRegExp(name) {
-	return new RegExp(`function\\s+${escapeRegExp$2(name)}\\s*\\(`);
+	return new RegExp(`function\\s+${escapeRegExp(name)}\\s*\\(`);
 }
 function extractFunctionDeclaration(code, functionName) {
-	const funcRe = new RegExp(`function\\s+${escapeRegExp$2(functionName)}\\s*\\([^)]*\\)\\s*\\{`);
+	const funcRe = new RegExp(`function\\s+${escapeRegExp(functionName)}\\s*\\([^)]*\\)\\s*\\{`);
 	const funcStart = code.search(funcRe);
 	if (funcStart < 0) return;
 	let depth = 0;
@@ -127,7 +137,7 @@ function rewriteEsmProxyConsumers(code, proxyChunks) {
 	const claimedLocals = /* @__PURE__ */ new Set();
 	for (const [proxyFileName, proxyInfo] of Array.from(proxyChunks.entries())) {
 		const proxyBaseName = getProxyBaseName(proxyFileName);
-		const importMatch = new RegExp(`import\\s*\\{([^}]+)\\}\\s*from\\s*["']([^"']*${escapeRegExp$2(proxyBaseName)}[^"']*)["']\\s*;?`).exec(nextCode);
+		const importMatch = new RegExp(`import\\s*\\{([^}]+)\\}\\s*from\\s*["']([^"']*${escapeRegExp(proxyBaseName)}[^"']*)["']\\s*;?`).exec(nextCode);
 		if (!importMatch) continue;
 		const fullImport = importMatch[0];
 		const bindings = importMatch[1].split(",").map((s) => {
@@ -184,7 +194,7 @@ function rewriteSystemProxyConsumers(code, systemProxyInfo) {
 	let nextCode = code;
 	for (const [proxyFileName, proxyInfo] of Array.from(systemProxyInfo.entries())) {
 		const proxyBaseName = getProxyBaseName(proxyFileName);
-		const depMatch = new RegExp(`["']([^"']*${escapeRegExp$2(proxyBaseName)}[^"']*)["']`).exec(nextCode);
+		const depMatch = new RegExp(`["']([^"']*${escapeRegExp(proxyBaseName)}[^"']*)["']`).exec(nextCode);
 		if (!depMatch) continue;
 		let setterIndex = 0;
 		const depListMatch = nextCode.match(/System\.register\(\[([\s\S]*?)\]/);
@@ -363,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",
@@ -877,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();
@@ -895,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;
 }
@@ -935,12 +994,13 @@ 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,
 		experiments: normalizeExperiments(options.experiments)
 	};
-	if (normalized.experiments.ssrMode === "ISLAND" && Object.prototype.hasOwnProperty.call(normalized.shared, "react")) mfWarn("Island expose generation is disabled because experiments.ssrMode is \"ISLAND\" and React is configured as shared. Remove \"react\" from shared to generate island exposes, or remove ssrMode to use standard shared rendering.");
+	if (normalized.experiments.ssrMode === "ISLAND" && Object.hasOwn(normalized.shared, "react")) mfWarn("Island expose generation is disabled because experiments.ssrMode is \"ISLAND\" and React is configured as shared. Remove \"react\" from shared to generate island exposes, or remove ssrMode to use standard shared rendering.");
 	explicitSharedKeysByOptions.set(normalized, new Set(explicitSharedKeys));
 	return config = normalized;
 }
@@ -958,11 +1018,8 @@ const idCacheMap = {};
 const VITE_ID_PREFIX = "/@id/";
 const VITE_ENCODED_NULL_BYTE_PREFIX = `${VITE_ID_PREFIX}__x00__`;
 const MF_OWNER_INFIX = "__mf_owner__";
-function escapeRegExp$1(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function createViteEncodedIdPrefixRegExp(sourcePrefix = "") {
-	return new RegExp(`^(?:${escapeRegExp$1(VITE_ENCODED_NULL_BYTE_PREFIX)})?${sourcePrefix}`);
+	return new RegExp(`^(?:${escapeRegExp(VITE_ENCODED_NULL_BYTE_PREFIX)})?${sourcePrefix}`);
 }
 function toViteEncodedId(id) {
 	return `${VITE_ENCODED_NULL_BYTE_PREFIX}${id}`;
@@ -1015,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;
 	}
@@ -1103,7 +1163,7 @@ function serializeRuntimeOptions(options) {
 				if (val instanceof Map) return `new Map([${Array.from(val.entries()).map(([k, v]) => `[${valueToCode(k)}, ${valueToCode(v)}]`).join(", ")}])`;
 				if (val instanceof Set) return `new Set([${Array.from(val.values()).map(valueToCode).join(", ")}])`;
 				const properties = [];
-				for (const key in val) if (Object.prototype.hasOwnProperty.call(val, key)) properties.push(`${toSafeJsLiteral(key)}: ${valueToCode(val[key])}`);
+				for (const key in val) if (Object.hasOwn(val, key)) properties.push(`${toSafeJsLiteral(key)}: ${valueToCode(val[key])}`);
 				return `{${properties.join(", ")}}`;
 			} finally {
 				ancestors.delete(val);
@@ -1112,7 +1172,7 @@ function serializeRuntimeOptions(options) {
 		return toSafeJsLiteral(String(val));
 	}
 	const topLevelProps = [];
-	for (const key in options) if (Object.prototype.hasOwnProperty.call(options, key)) topLevelProps.push(`${toSafeJsLiteral(key)}: ${valueToCode(options[key])}`);
+	for (const key in options) if (Object.hasOwn(options, key)) topLevelProps.push(`${toSafeJsLiteral(key)}: ${valueToCode(options[key])}`);
 	return `{${topLevelProps.join(", ")}}`;
 }
 const NATIVE_FUNCTION_SOURCE = /\{\s*\[native code\]\s*\}\s*$/;
@@ -1223,7 +1283,7 @@ function isReactComponentFile(filePath, seen = /* @__PURE__ */ new Set()) {
 */
 function getReactIslandExposes(options, root) {
 	if (options.experiments.ssrMode !== "ISLAND") return /* @__PURE__ */ new Set();
-	if (Object.prototype.hasOwnProperty.call(options.shared, "react")) return /* @__PURE__ */ new Set();
+	if (Object.hasOwn(options.shared, "react")) return /* @__PURE__ */ new Set();
 	const islandExposes = /* @__PURE__ */ new Set();
 	for (const [key, expose] of Object.entries(options.exposes)) {
 		const sourceFile = resolveSourceFile(expose.import, root);
@@ -2184,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",
@@ -2271,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);
@@ -2286,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);
@@ -2602,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);
@@ -2845,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);
@@ -3371,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() : "";
@@ -3559,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) => {
@@ -3567,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;`}
         }
@@ -3583,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;
@@ -3602,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},
@@ -3707,6 +3847,7 @@ function getMaterializedShares(options) {
 	const pending = [...shares];
 	while (pending.length) {
 		const pkg = pending.pop();
+		const share = getNormalizeShareItem(pkg, resolvedOptions);
 		const packageName = getPackageName(pkg);
 		const packageJson = getInstalledPackageJson(pkg)?.packageJson ?? (pkg !== packageName ? getInstalledPackageJson(packageName)?.packageJson : void 0);
 		const dependencies = {
@@ -3716,7 +3857,8 @@ function getMaterializedShares(options) {
 		};
 		for (const dependency of Object.keys(dependencies)) {
 			const sharedDependency = configured.get(dependency);
-			if (sharedDependency && !shares.has(sharedDependency)) {
+			const dependencyShare = sharedDependency ? getNormalizeShareItem(sharedDependency, resolvedOptions) : void 0;
+			if (sharedDependency && !shares.has(sharedDependency) && dependencyShare?.scope === share?.scope) {
 				shares.add(sharedDependency);
 				pending.push(sharedDependency);
 			}
@@ -4045,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;
@@ -4333,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",
@@ -4388,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 = {}
@@ -4396,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 || '');
@@ -4430,17 +4588,12 @@ 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 = []) {
+  async function init(shared = {}, initScope = [], remoteEntryInitOptions = {}) {
     ${sharedCacheHelperCode}
-    const getShareScope = (scopeName) => ${hasMultipleShareScopes} ? (shared?.[scopeName] || {}) : shared;
+    const getShareScope = (scopeName) => remoteEntryInitOptions.shareScopeMap?.[scopeName] ?? (${hasMultipleShareScopes} ? (shared?.[scopeName] || {}) : shared);
     const getShareScopeNames = (share) => {
       const configuredScopes = Array.isArray(share?.scope) ? share.scope : [share?.scope || shareScopeName];
       if (!${hasMultipleShareScopes}) return configuredScopes;
@@ -4551,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) {
@@ -5272,9 +5429,9 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
     return (exposesMap[moduleName])().then(res => () => res)
   }
   ${guardHostAutoInit ? `let __mfInitPromise;
-  function __mfGuardedInit(shared, initScope) {
+  function __mfGuardedInit(shared, initScope, remoteEntryInitOptions) {
     if (shared === undefined && __mfInitPromise) return __mfInitPromise;
-    __mfInitPromise = init(shared, initScope);
+    __mfInitPromise = init(shared, initScope, remoteEntryInitOptions);
     return __mfInitPromise;
   }
   export { __mfGuardedInit as init, getExposes as get }` : `export { init, getExposes as get }`}
@@ -5324,6 +5481,12 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
           const {usedShared} = await import("${getLocalSharedImportMapPath(options)}");
           ${normalizeRuntimeShareCode}
           ${shouldPreloadShares ? `
+          const __mfHasAlternativeSharedVersion = (pkg, share) =>
+            (Array.isArray(share.scope) ? share.scope : [share.scope || 'default']).some(
+              (scopeName) => Object.keys(runtime.shareScopeMap?.[scopeName]?.[pkg] || {}).some(
+                (version) => version !== share.version
+              )
+            );
           const __mfHostInitShareBatches = ${hostInitShareBatches};
           for (const __mfHostInitShareBatch of __mfHostInitShareBatches) {
             await Promise.all(__mfHostInitShareBatch.map(async (pkg) => {
@@ -5336,7 +5499,10 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
               const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
               if (
                 __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined &&
-                __mfReadSharedCacheOwner(__mfModuleCache.share, cacheDescriptor) ${_command === "serve" ? "!== undefined" : `=== ${cacheOwner}`}
+                ${_command === "serve" ? `__mfReadSharedCacheOwner(__mfModuleCache.share, cacheDescriptor) !== undefined` : `(
+                        (!share.shareConfig?.singleton && __mfReadSharedCacheOwner(__mfModuleCache.share, cacheDescriptor) === ${cacheOwner}) ||
+                        (share.shareConfig?.singleton && !__mfHasAlternativeSharedVersion(pkg, share))
+                      )`}
               ) return;
               // An import:false share has nothing to load until a foreign provider
               // registers: its own stub getter throws by construction.
@@ -5431,8 +5597,10 @@ function getPendingSharesState(options) {
 function generatePendingSharesCode(command = "build", options) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const pendingShareImports = command === "build" ? getMaterializedShares(options).filter((pkg) => {
-		const shareItem = resolvedOptions.shared?.[pkg];
-		return Boolean(shareItem) && !pkg.endsWith("/") && shareItem.shareConfig.import !== false && !shareItem.shareConfig.treeShaking;
+		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 `
     ${getRuntimeModuleCacheBootstrapCode()}
@@ -5525,8 +5693,15 @@ function getScopedUsedRemotesMap(options) {
 	return scoped;
 }
 function recordUsedRemote(map, remoteKey, remoteModule) {
+	ensureUsedRemoteKey(map, remoteKey).add(remoteModule);
+}
+function ensureUsedRemoteKey(map, remoteKey) {
 	if (!map[remoteKey]) map[remoteKey] = /* @__PURE__ */ new Set();
-	map[remoteKey].add(remoteModule);
+	return map[remoteKey];
+}
+function ensureUsedRemote(remoteKey, options) {
+	ensureUsedRemoteKey(usedRemotesMap, remoteKey);
+	if (options) ensureUsedRemoteKey(getScopedUsedRemotesMap(options), remoteKey);
 }
 function addUsedRemote(remoteKey, remoteModule, options) {
 	recordUsedRemote(usedRemotesMap, remoteKey, remoteModule);
@@ -5767,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];
@@ -5833,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__");
+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];
@@ -5935,12 +6106,6 @@ function stripQueryAndHash$1(file) {
 function isReactRouterClientRouteInput(file) {
 	return /[?&]__react-router-build-client-route(?:[=&]|$)/.test(file);
 }
-function resolveDevHashEntryFileName$1(fileName) {
-	if (!fileName.includes("[hash")) return fileName;
-	const normalized = fileName.replace(/(?:[._-]?\[hash(?::\d+)?\])/g, "");
-	const baseName = path$1.basename(normalized);
-	return path$1.extname(baseName) ? normalized : `${normalized}.js`;
-}
 function getBuildInput(config) {
 	return config.build?.rollupOptions?.input ?? config.build?.rolldownOptions?.input;
 }
@@ -6058,10 +6223,10 @@ const __mfCurrentScript = document.currentScript;
 		const normalizedOptions = federationOptions ?? getNormalizeModuleFederationOptions();
 		const isLoadedFirstClientBuild = (_command === "build" || viteConfig?.command === "build") && waitsForInit && !viteConfig?.build?.ssr && normalizedOptions.shareStrategy === "loaded-first";
 		if (normalizedOptions.shareStrategy === "loaded-first" && !isLoadedFirstClientBuild) return [];
-		const remoteSources = isLoadedFirstClientBuild ? Array.from(getPreloadRemotes(normalizedOptions)) : Object.entries(getUsedRemotesMap(federationOptions)).flatMap(([, remotes]) => Array.from(remotes)).filter((remote) => !federationOptions || !isDynamicOnlyRemote(remote, federationOptions));
+		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) {
@@ -6089,9 +6254,9 @@ 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.prototype.hasOwnProperty.call(federationOptions.shared, pkg);
+			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)));
 		}).map((pkg) => toViteEncodedId(getLoadShareModulePath(pkg, false, federationOptions))) : [];
 		const sharedPreloadBlock = sharedPreloadSources.length > 0 ? `
@@ -6175,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));
@@ -6256,7 +6421,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 					next();
 					return;
 				}
-				const devFileName = resolveDevHashEntryFileName$1(fileName);
+				const devFileName = resolveHashPlaceholderFileName(fileName);
 				if (devFileName !== fileName && req.url?.startsWith((viteConfig.base + devFileName).replace(/^\/?/, "/"))) req.url = req.url.replace(devFileName, fileName);
 				if (req.url && req.url.startsWith((viteConfig.base + fileName).replace(/^\/?/, "/"))) {
 					req.url = devEntryPath;
@@ -6314,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;
@@ -6437,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';`;
@@ -7231,6 +7404,9 @@ function pluginExternalRuntimeCore() {
 	};
 }
 //#endregion
+//#region package.json
+var version$1 = "1.22.0";
+//#endregion
 //#region src/virtualModules/index.ts
 function initVirtualModules(command, remoteEntryId, enableSsrInit = false, options) {
 	writeLocalSharedImportMap(options);
@@ -7458,21 +7634,22 @@ const REMOTE_ENTRY_SSR_ID = "virtual:mf-REMOTE_ENTRY_SSR_ID";
 function getRemoteEntrySSRId(options) {
 	return `${REMOTE_ENTRY_SSR_ID}:${getVirtualModuleScopeKey(options)}`;
 }
-function stripSsrFilenameHashPlaceholder(filename) {
-	if (!filename.includes("[hash")) return filename;
-	filename = filename.replace(/(?:[._-]?\[hash(?::\d+)?\])/g, "");
-	if (!/\.[^.]+$/.test(filename)) filename = `${filename}.js`;
-	return filename;
+const FILE_EXTENSION_RE = /\.[^.]+$/;
+function getSsrFileNameParts(browserFilename) {
+	const filename = resolveHashPlaceholderFileName(browserFilename);
+	const ext = FILE_EXTENSION_RE.exec(filename)?.[0];
+	return {
+		base: ext ? filename.slice(0, filename.length - ext.length) : filename,
+		ext
+	};
 }
 function getSsrRemoteEntryFileName(browserFilename) {
-	const filename = stripSsrFilenameHashPlaceholder(browserFilename);
-	const ext = filename.match(/\.[^.]+$/)?.[0] || ".js";
-	return `${filename.slice(0, filename.length - ext.length)}.ssr${ext}`;
+	const { base, ext } = getSsrFileNameParts(browserFilename);
+	return `${base}.ssr${ext ?? ".js"}`;
 }
 function getSsrExposesFileName(browserFilename) {
-	const filename = stripSsrFilenameHashPlaceholder(browserFilename);
-	const ext = filename.match(/\.[^.]+$/)?.[0];
-	return `${ext ? filename.slice(0, filename.length - ext.length) : filename}.exposes.js`;
+	const { base } = getSsrFileNameParts(browserFilename);
+	return `${base}.exposes.js`;
 }
 /** Singleton map for SSR loadShare: expand `pkg/` via usedShares; never serialize the prefix. */
 function getSsrSharedSingletons(options) {
@@ -7650,12 +7827,6 @@ function resolveTypesMeta(dts) {
 		api: `${typesFolder}.d.ts`
 	};
 }
-function resolveDevRemoteEntryFileName(fileName) {
-	if (!fileName.includes("[hash")) return fileName;
-	const normalized = fileName.replace(/(?:[._-]?\[hash(?::\d+)?\])/g, "");
-	const baseName = path$1.basename(normalized);
-	return path$1.extname(baseName) ? normalized : `${normalized}.js`;
-}
 function createRemoteEntryAssetMap(fileName) {
 	return {
 		js: {
@@ -7681,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));
@@ -7703,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([
@@ -7741,10 +7944,10 @@ const Manifest = (providedOptions) => {
 	let mfManifestStatsName = mfManifestName ? getStatsFileName(mfManifestName) : void 0;
 	const isConsumerProject = Object.keys(mfOptions.exposes).length === 0;
 	let disableAssetsAnalyze = false;
-	const getDefaultDisableAssetsAnalyze = (command) => command === "serve" && isConsumerProject && (typeof manifestOptions !== "object" || !Object.prototype.hasOwnProperty.call(manifestOptions, "disableAssetsAnalyze"));
+	const getDefaultDisableAssetsAnalyze = (command) => command === "serve" && isConsumerProject && (typeof manifestOptions !== "object" || !Object.hasOwn(manifestOptions, "disableAssetsAnalyze"));
 	const getConfiguredDisableAssetsAnalyze = (command) => {
 		if (typeof manifestOptions === "object" && manifestOptions !== null) {
-			if (Object.prototype.hasOwnProperty.call(manifestOptions, "disableAssetsAnalyze")) return manifestOptions.disableAssetsAnalyze === true;
+			if (Object.hasOwn(manifestOptions, "disableAssetsAnalyze")) return manifestOptions.disableAssetsAnalyze === true;
 		}
 		return getDefaultDisableAssetsAnalyze(command);
 	};
@@ -7774,7 +7977,7 @@ const Manifest = (providedOptions) => {
 		*/
 		configureServer(server) {
 			server.middlewares.use((req, res, next) => {
-				const devRemoteEntryFile = resolveDevRemoteEntryFileName(filename);
+				const devRemoteEntryFile = resolveHashPlaceholderFileName(filename);
 				if (devRemoteEntryFile !== filename && Object.keys(mfOptions.exposes).length > 0 && req.url?.startsWith((viteConfig.base + devRemoteEntryFile).replace(/^\/?/, "/"))) {
 					req.url = req.url.replace(devRemoteEntryFile, filename);
 					next();
@@ -7817,7 +8020,7 @@ const Manifest = (providedOptions) => {
 								} : void 0,
 								types: resolveTypesMeta(mfOptions.dts),
 								globalName: name,
-								pluginVersion: "0.2.5",
+								pluginVersion: version$1,
 								publicPath
 							}
 						});
@@ -7861,7 +8064,7 @@ const Manifest = (providedOptions) => {
 			const expectedSsrRemoteEntryFile = getSsrRemoteEntryFileName(mfOptions.filename);
 			const foundSsrRemoteEntryFile = Object.values(bundle).find((file) => file.fileName === expectedSsrRemoteEntryFile)?.fileName;
 			if (foundRemoteEntryFile) remoteEntryFile = foundRemoteEntryFile;
-			ssrRemoteEntryFile = foundSsrRemoteEntryFile || (_command === "serve" ? getSsrRemoteEntryFileName(resolveDevRemoteEntryFileName(mfOptions.filename)) : expectedSsrRemoteEntryFile);
+			ssrRemoteEntryFile = foundSsrRemoteEntryFile || (_command === "serve" ? getSsrRemoteEntryFileName(resolveHashPlaceholderFileName(mfOptions.filename)) : expectedSsrRemoteEntryFile);
 			const allCssAssets = mfOptions.bundleAllCSS && !disableAssetsAnalyze ? collectCssAssets(bundle) : /* @__PURE__ */ new Set();
 			if (allCssAssets.size > 0) {
 				const secondaryCss = /* @__PURE__ */ new Set();
@@ -7883,9 +8086,16 @@ 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)) {
+					const shareItem = getNormalizeShareItem(shareKey, mfOptions);
+					const assets = filesMap[shareKey];
+					if (!assets || shareItem?.shareConfig.eager === true) continue;
+					assets.js.async.push(...assets.js.sync.splice(0));
+					assets.css.async.push(...assets.css.sync.splice(0));
+				}
 				if (mfOptions.bundleAllCSS) addCssAssetsToAllExports(filesMap, allCssAssets);
 				filesMap = deduplicateAssets(filesMap);
 			}
@@ -7913,14 +8123,14 @@ const Manifest = (providedOptions) => {
 	function generateMFManifest(preloadMap, disableAssetsAnalyze = false) {
 		const options = mfOptions;
 		const { name, varFilename } = options;
-		const resolvedRemoteEntryFile = _command === "serve" ? remoteEntryFile || resolveDevRemoteEntryFileName(filename) : remoteEntryFile;
+		const resolvedRemoteEntryFile = _command === "serve" ? remoteEntryFile || resolveHashPlaceholderFileName(filename) : remoteEntryFile;
 		const remoteEntry = {
 			name: resolvedRemoteEntryFile,
 			path: "",
 			type: "module"
 		};
 		const ssrRemoteEntry = {
-			name: ssrRemoteEntryFile || getSsrRemoteEntryFileName(_command === "serve" ? resolveDevRemoteEntryFileName(filename) : filename),
+			name: ssrRemoteEntryFile || getSsrRemoteEntryFileName(_command === "serve" ? resolveHashPlaceholderFileName(filename) : filename),
 			path: _command === "serve" ? "/__mf_ssr__/" : "",
 			type: "module"
 		};
@@ -8007,7 +8217,7 @@ const Manifest = (providedOptions) => {
 				varRemoteEntry,
 				types: resolveTypesMeta(options.dts),
 				globalName: name,
-				pluginVersion: "0.2.5",
+				pluginVersion: version$1,
 				...!!getPublicPath ? { getPublicPath } : { publicPath }
 			},
 			...disableAssetsAnalyze ? {} : { shared },
@@ -8220,12 +8430,6 @@ function pluginModuleParseEnd_default(excludeFn, options, controller = createMod
 }
 //#endregion
 //#region src/plugins/pluginProxyRemoteEntry.ts
-function resolveDevHashEntryFileName(fileName) {
-	if (!fileName.includes("[hash")) return fileName;
-	const normalized = fileName.replace(/(?:[._-]?\[hash(?::\d+)?\])/g, "");
-	const baseName = path$1.basename(normalized);
-	return path$1.extname(baseName) ? normalized : `${normalized}.js`;
-}
 function resolveAbsoluteDevRemoteEntryUrl(publicPath, fileName) {
 	const base = new URL(publicPath);
 	base.pathname = ensureTrailingSlash(base.pathname);
@@ -8366,7 +8570,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 						const host = formatDevServerHostForOrigin(viteConfig.server?.host);
 						const resolvedPublicPath = resolvePublicPath(options, viteConfig.base, originalConfigBase);
 						const devPublicPath = resolvedPublicPath === "auto" ? "/" : resolvedPublicPath;
-						const remoteEntryFileName = resolveDevHashEntryFileName(options.filename);
+						const remoteEntryFileName = resolveHashPlaceholderFileName(options.filename);
 						const isAbsolutePublicPath = /^https?:\/\//i.test(devPublicPath);
 						const remoteEntryUrl = JSON.stringify(isAbsolutePublicPath ? resolveAbsoluteDevRemoteEntryUrl(devPublicPath, remoteEntryFileName) : `${ensureTrailingSlash(devPublicPath)}${remoteEntryFileName}`);
 						const fallbackOrigin = `//${host}:${viteConfig.server?.port}`;
@@ -8419,28 +8623,10 @@ 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\\");
 }
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function appendAlias(config, alias) {
 	config.resolve ??= {};
 	const existingAlias = config.resolve.alias;
@@ -8739,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?)$/;
@@ -8748,7 +8949,7 @@ const NON_RUNTIME_DIRS = /* @__PURE__ */ new Set([
 	"dist",
 	"build"
 ]);
-/** Bundled artifacts of a published package never import workspace packages; skip them instead of scanning megabytes. */
+/** Keep local runtime walks bounded without skipping the package entry itself. */
 const MAX_SCANNED_SOURCE_BYTES = 256 * 1024;
 const BARE_PACKAGE_SPECIFIER_RE = /^(?:@[^\s'"`()\/]+\/)?[^\s'"`()\/.@][^\s'"`()\/]*(?:\/[^\s'"`()]*)?$/;
 /** Module specifiers evaluated by a source file. */
@@ -8764,24 +8965,30 @@ function collectAllRuntimeImports(dir, into) {
 	try {
 		entries = readdirSync(dir, { withFileTypes: true });
 	} catch {
-		return;
+		return false;
 	}
+	let complete = true;
 	for (const entry of entries) {
 		if (entry.isDirectory()) {
-			if (!NON_RUNTIME_DIRS.has(entry.name)) collectAllRuntimeImports(path$1.join(dir, entry.name), into);
+			if (!NON_RUNTIME_DIRS.has(entry.name) && !collectAllRuntimeImports(path$1.join(dir, entry.name), into)) complete = false;
 			continue;
 		}
 		if (!SOURCE_FILE_RE.test(entry.name) || NON_RUNTIME_SOURCE_RE.test(entry.name)) continue;
 		const file = path$1.join(dir, entry.name);
 		let code;
 		try {
-			if (statSync(file).size > MAX_SCANNED_SOURCE_BYTES) continue;
+			if (statSync(file).size > MAX_SCANNED_SOURCE_BYTES) {
+				complete = false;
+				continue;
+			}
 			code = readFileSync(file, "utf-8");
 		} catch {
+			complete = false;
 			continue;
 		}
 		for (const specifier of getRuntimeImportSpecifiers(code)) into.add(specifier);
 	}
+	return complete;
 }
 const SOURCE_EXTENSIONS = [
 	"",
@@ -8807,19 +9014,27 @@ function resolveLocalRuntimeImport(importer, specifier) {
 }
 function collectReachableRuntimeImports(entry, dir, into) {
 	const visited = /* @__PURE__ */ new Set();
-	const queue = [entry];
+	const queue = [{
+		file: entry,
+		isEntry: true
+	}];
 	let scanned = false;
+	let complete = true;
 	while (queue.length) {
-		const file = queue.shift();
+		const { file, isEntry } = queue.shift();
 		const relative = path$1.relative(dir, file);
 		if (relative.startsWith("..") || path$1.isAbsolute(relative) || visited.has(file)) continue;
 		visited.add(file);
 		let code;
 		try {
-			if (statSync(file).size > MAX_SCANNED_SOURCE_BYTES) continue;
+			if (!isEntry && statSync(file).size > MAX_SCANNED_SOURCE_BYTES) {
+				complete = false;
+				continue;
+			}
 			code = readFileSync(file, "utf-8");
 			scanned = true;
 		} catch {
+			complete = false;
 			continue;
 		}
 		for (const specifier of getRuntimeModuleSpecifiers(code)) {
@@ -8828,10 +9043,13 @@ function collectReachableRuntimeImports(entry, dir, into) {
 				continue;
 			}
 			const local = resolveLocalRuntimeImport(file, specifier);
-			if (local) queue.push(local);
+			if (local) queue.push({
+				file: local,
+				isEntry: false
+			});
 		}
 	}
-	return scanned;
+	return scanned && complete;
 }
 /**
 * Whether `dependency` is reachable from the shared package through the imports its source files
@@ -8840,11 +9058,13 @@ function collectReachableRuntimeImports(entry, dir, into) {
 * the fallback's evaluation graph rather than the package's declared closure — in a monorepo the
 * latter covers far more than the module graph ever does.
 */
-function isSharedPackageRuntimeDependency(sharedKey, dependency) {
+function isSharedPackageRuntimeDependency(sharedKey, dependency, conditions) {
 	const sharedPackage = getPackageName(sharedKey);
-	let reachable = sharedRuntimeDependencyCache.get(sharedKey);
-	if (!reachable) {
-		reachable = /* @__PURE__ */ new Set();
+	const cacheKey = `${sharedKey}\0${JSON.stringify(conditions ?? null)}`;
+	let result = sharedRuntimeDependencyCache.get(cacheKey);
+	if (!result) {
+		const reachable = /* @__PURE__ */ new Set();
+		let complete = true;
 		const visited = /* @__PURE__ */ new Set();
 		const queue = [{
 			request: sharedKey,
@@ -8852,16 +9072,26 @@ function isSharedPackageRuntimeDependency(sharedKey, dependency) {
 		}];
 		while (queue.length) {
 			const { request, installed } = queue.shift();
-			if (!installed) continue;
+			if (!installed) {
+				complete = false;
+				continue;
+			}
 			const visitKey = `${installed.dir}\0${request}`;
 			if (visited.has(visitKey)) continue;
 			visited.add(visitKey);
 			const specifiers = /* @__PURE__ */ new Set();
 			const entry = getInstalledPackageEntry(request, {
 				cwd: installed.dir,
-				packageName: getPackageName(request)
+				packageName: getPackageName(request),
+				resolveSubpathWithRequire: false,
+				...conditions !== void 0 ? { conditions: [...conditions] } : {}
 			});
-			if (!entry || !collectReachableRuntimeImports(entry, installed.dir, specifiers)) collectAllRuntimeImports(installed.dir, specifiers);
+			if (!entry) {
+				if (!collectAllRuntimeImports(installed.dir, specifiers)) complete = false;
+			} else if (!collectReachableRuntimeImports(entry, installed.dir, specifiers)) {
+				complete = false;
+				collectAllRuntimeImports(installed.dir, specifiers);
+			}
 			for (const specifier of specifiers) {
 				const dep = getPackageName(specifier);
 				if (dep === sharedPackage) continue;
@@ -8873,9 +9103,13 @@ function isSharedPackageRuntimeDependency(sharedKey, dependency) {
 				});
 			}
 		}
-		sharedRuntimeDependencyCache.set(sharedKey, reachable);
+		result = {
+			dependencies: reachable,
+			complete
+		};
+		sharedRuntimeDependencyCache.set(cacheKey, result);
 	}
-	return reachable.has(dependency);
+	return result.dependencies.has(dependency) || !result.complete && isSharedPackageDependency(sharedKey, dependency);
 }
 function proxySharedModule(options) {
 	const { shared = {}, federationOptions, getParsePromise = () => Promise.resolve() } = options;
@@ -8883,12 +9117,30 @@ function proxySharedModule(options) {
 	let _command = "serve";
 	let useDirectReactImport = false;
 	let useRolldown = false;
+	let isProduction = false;
+	let rootResolveConditions;
+	let ssrResolveConditions;
+	let ssrTarget = "node";
 	const savePrebuild = new PromiseStore();
 	let devServer;
 	const materializedLoadShareSources = /* @__PURE__ */ new Set();
 	const emittedTreeShakingProviders = /* @__PURE__ */ new Set();
 	const hasAnalyzableShares = Object.values(shared).some((share) => shouldAnalyzeSharedExports(share));
-	const getEnvironmentConditions = (context) => context.environment?.config?.resolve?.conditions;
+	const getEnvironmentConfig = (context) => context.environment?.config;
+	const getEnvironmentConditions = (context) => getEnvironmentConfig(context)?.resolve?.conditions;
+	const getRuntimeDependencyConditions = (context, resolveOptions) => {
+		const environment = context.environment;
+		const environmentConfig = environment?.config;
+		const isSsr = resolveOptions.ssr === true || Boolean(_config?.build?.ssr) || environmentConfig?.consumer === "server" || Boolean(environmentConfig?.build?.ssr) || environment?.name === "ssr" || environment?.name === "server";
+		return getSharedExportConditions({
+			environmentConditions: environmentConfig?.resolve?.conditions,
+			isProduction: environmentConfig?.isProduction ?? isProduction,
+			isSsr,
+			rootConditions: rootResolveConditions,
+			ssrConditions: ssrResolveConditions,
+			ssrTarget
+		});
+	};
 	const refreshTreeShakingForEnvironment = (context) => refreshTreeShakingModules(federationOptions, _command, getIsRolldown(context), getEnvironmentConditions(context));
 	const normalizeTreeShakingOutputPath = (value) => {
 		const normalized = normalizePathForImport(value);
@@ -8972,8 +9224,13 @@ function proxySharedModule(options) {
 			},
 			configResolved(config) {
 				_config = config;
+				isProduction = config.isProduction;
+				rootResolveConditions = config.resolve?.conditions ? [...config.resolve.conditions] : void 0;
+				ssrResolveConditions = config.ssr?.resolve?.conditions ? [...config.ssr.resolve.conditions] : void 0;
+				ssrTarget = config.ssr?.target ?? "node";
 				const isRolldown = getIsRolldown(this);
-				const registerConfiguredShare = _command === "serve" ? addConfiguredShare : addUsedShares;
+				const resolvedOptions = federationOptions ?? getNormalizeModuleFederationOptions();
+				const registerConfiguredShare = _command === "build" && Object.keys(resolvedOptions.exposes).length > 0 ? addUsedShares : addConfiguredShare;
 				Object.keys(shared).forEach((key) => {
 					if (key.endsWith("/")) return;
 					if (useDirectReactImport && key === "react") {
@@ -9052,8 +9309,10 @@ function proxySharedModule(options) {
 				if (!key) return;
 				const importerPackage = getSharedPackageFromFile(importer, shared);
 				if (importerPackage === getPackageName(key)) return;
-				if (importerPackage) {
-					if (!isNodeModulePath(importer) && !Object.keys(shared).some((sharedKey) => getPackageName(sharedKey) === importerPackage) ? isSharedPackageRuntimeDependency(key, importerPackage) : isSharedPackageDependency(key, importerPackage)) return;
+				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;
 				}
 				if (useDirectReactImport && key === "react") return;
 				if (isAssetLikeImport(source)) return;
@@ -9064,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);
@@ -9870,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 = [];
@@ -9922,7 +10181,7 @@ function isFederationControlChunk(fileName, filename) {
 function sanitizeFederationControlChunk(code, fileName, filename) {
 	let nextCode = stripEmptyPreloadCalls(code);
 	if (fileName.includes("localSharedImportMap")) {
-		const remoteEntryImportRegex = new RegExp(`import\\s*["'][^"']*${filename.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*;?`, "g");
+		const remoteEntryImportRegex = new RegExp(`import\\s*["'][^"']*${escapeRegExp(filename)}["']\\s*;?`, "g");
 		nextCode = nextCode.replace(remoteEntryImportRegex, "");
 	}
 	return nextCode;
@@ -10054,13 +10313,15 @@ function appendResolveAlias(config, alias) {
 		replacement
 	})), alias];
 }
+const RUNTIME_INDEX_ENTRY_RE = /^(.*[\\/])index(\.[cm]?js)$/;
+const TRAILING_SLASH_RE = /\/$/;
 function getRuntimeHelpersImplementation(runtimeImplementation) {
-	const indexEntryMatch = runtimeImplementation.match(/^(.*[\\/])index(\.[cm]?js)$/);
+	const indexEntryMatch = RUNTIME_INDEX_ENTRY_RE.exec(runtimeImplementation);
 	if (indexEntryMatch) return normalizePathForImport(`${indexEntryMatch[1]}helpers${indexEntryMatch[2]}`);
 	const extension = path$1.extname(runtimeImplementation);
 	if (extension) return normalizePathForImport(path$1.join(path$1.dirname(runtimeImplementation), `helpers${extension}`));
 	if (path$1.isAbsolute(runtimeImplementation) || runtimeImplementation.startsWith(".")) return normalizePathForImport(path$1.join(runtimeImplementation, "helpers"));
-	return `${runtimeImplementation.replace(/\/$/, "")}/helpers`;
+	return `${runtimeImplementation.replace(TRAILING_SLASH_RE, "")}/helpers`;
 }
 const UNSAFE_JS_SOURCE_CHAR_MAP = {
 	"<": "\\u003C",
@@ -10083,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) {
@@ -10307,7 +10568,7 @@ function createEarlyVirtualModulesPlugin(options) {
 			initVirtualModules(_command, getRemoteEntryId(options), false, options);
 			const isRolldown = getIsRolldown(this);
 			if (remotes && Object.keys(remotes).length > 0) {
-				for (const key of Object.keys(remotes)) addUsedRemote(key, key, options);
+				for (const key of Object.keys(remotes)) ensureUsedRemote(key, options);
 				if (_command === "serve") {
 					config.optimizeDeps = config.optimizeDeps || {};
 					config.optimizeDeps.exclude = config.optimizeDeps.exclude || [];
@@ -10492,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;
@@ -10521,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 {}
 		}
 	};
@@ -10537,7 +10799,7 @@ function applyBuildTimeRuntimeDefines(define, options, { target, isAstro, defaul
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-BhONN9dR.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) {
@@ -10562,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());
 	}
 }
@@ -10578,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,
@@ -10753,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,
@@ -10781,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 = {
@@ -10788,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;
@@ -10827,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";
 						}
@@ -10935,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))) {
@@ -11109,10 +11373,10 @@ function federation(mfUserOptions) {
 				apply: "build",
 				config(_config, { command }) {
 					const manifest = options.manifest;
-					const getDefaultDisableAssetsAnalyze = (cfgCommand) => cfgCommand === "serve" && (typeof manifest !== "object" || !Object.prototype.hasOwnProperty.call(manifest, "disableAssetsAnalyze"));
+					const getDefaultDisableAssetsAnalyze = (cfgCommand) => cfgCommand === "serve" && (typeof manifest !== "object" || !Object.hasOwn(manifest, "disableAssetsAnalyze"));
 					const getConfiguredDisableAssetsAnalyze = (cfgCommand) => {
 						if (typeof manifest === "object" && manifest !== null) {
-							if (Object.prototype.hasOwnProperty.call(manifest, "disableAssetsAnalyze")) return manifest.disableAssetsAnalyze === true;
+							if (Object.hasOwn(manifest, "disableAssetsAnalyze")) return manifest.disableAssetsAnalyze === true;
 						}
 						return getDefaultDisableAssetsAnalyze(cfgCommand);
 					};