@module-federation/vite 1.23.0 → 1.23.2

package/lib/index.js

@@ -1,6 +1,6 @@
 import { _ as resolvePublicPath, a as matchesSharedSource, c as filterId, d as getNodeModulesSuffix, f as isAssetLikeImport, g as normalizeNodeModulePath, h as isViteOptimizableEntry, i as invalidateSharedKeyMatcher, l as getBasePath$1, m as isNuxtClientBase, n as getSharedRequest, p as isNodeModulePath, r as getSharedRuntimeKey, s as ensureTrailingSlash, t as findSharedKey, u as getCommonSharedSubpaths, v as stripQueryAndHash, y as stripViteFsPrefix } from "./sharedKeyMatcher-Od_nYxJA.js";
-import { i as resolveHashPlaceholderFileName, n as normalizePathForImport, r as rebaseImport } from "./buildPaths-BoaQTkxt.js";
-import { C as isReactCoreShare, E as mfWarn, S as REACT_DOM_CLIENT_SHARE, _ as resolveModulePath, a as getIsRolldown, b as supportsCodeSplittingGroupDebugName, c as getPackageNameFromNodeModulePath, d as isNuxtProjectRoot, f as isPackageExportAvailable, g as resolveImportPath, h as packageNameEncode, i as getInstalledPackageJson, l as getSharedCacheDescriptor, m as packageNameDecode, n as getDependencyNames, o as getPackageDetectionCwd, p as isPackageInstalled, r as getInstalledPackageEntry, s as getPackageName, u as hasPackageDependency, v as setPackageDetectionCwd, w as createModuleFederationError, x as REACT_CLIENT_INTERNALS_KEY, y as sharedCacheHelperCode } from "./dtsConstants-DEMpRfBz.js";
+import { a as CodeRewriter, c as isAbsoluteUrl, d as resolveHashPlaceholderFileName, i as createCodePositionMap, l as normalizePathForImport, o as createSourceMap, r as mfWarn, t as createModuleFederationError, u as rebaseImport } from "./logger-DOwfTlw5.js";
+import { C as isReactCoreShare, S as REACT_DOM_CLIENT_SHARE, _ as resolveModulePath, a as getIsRolldown, b as supportsCodeSplittingGroupDebugName, c as getPackageNameFromNodeModulePath, d as isNuxtProjectRoot, f as isPackageExportAvailable, g as resolveImportPath, h as packageNameEncode, i as getInstalledPackageJson, l as getSharedCacheDescriptor, m as packageNameDecode, n as getDependencyNames, o as getPackageDetectionCwd, p as isPackageInstalled, r as getInstalledPackageEntry, s as getPackageName, u as hasPackageDependency, v as setPackageDetectionCwd, x as REACT_CLIENT_INTERNALS_KEY, y as sharedCacheHelperCode } from "./dtsConstants-r5OfegUr.js";
 import { createRequire } from "node:module";
 import * as fs$2 from "fs";
 import { existsSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "fs";
@@ -15,6 +15,8 @@ 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";
+import { inferAutoPublicPath } from "@module-federation/sdk";
+import { readFile } from "node:fs/promises";
 //#region src/utils/regexEscape.ts
 const REGEXP_SPECIAL_CHARS_RE = /[.*+?^${}()|[\]\\]/g;
 /**
@@ -236,134 +238,6 @@ function findRemoteEntryFile(filename, bundle) {
 	return fallback;
 }
 //#endregion
-//#region src/utils/codeRewriter.ts
-const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-var CodeRewriter = class {
-	original;
-	replacements = [];
-	constructor(original) {
-		this.original = original;
-	}
-	overwrite(start, end, content) {
-		if (start < 0 || end < start || end > this.original.length) throw new Error(`Invalid overwrite range: ${start}-${end}`);
-		this.replacements.push({
-			start,
-			end,
-			content
-		});
-	}
-	toString() {
-		return applyReplacements(this.original, this.getSortedReplacements()).code;
-	}
-	generateMap(source = "") {
-		const { code, replacements } = applyReplacements(this.original, this.getSortedReplacements());
-		return {
-			version: 3,
-			sources: [source],
-			sourcesContent: [this.original],
-			names: [],
-			mappings: generateLineMappings(code, this.original, replacements)
-		};
-	}
-	getSortedReplacements() {
-		return [...this.replacements].sort((a, b) => a.start - b.start || a.end - b.end);
-	}
-};
-function createSourceMap(code, source = "") {
-	return {
-		version: 3,
-		sources: [source],
-		sourcesContent: [code],
-		names: [],
-		mappings: generateLineMappings(code, code, [])
-	};
-}
-function applyReplacements(original, replacements) {
-	let code = "";
-	let cursor = 0;
-	let delta = 0;
-	const applied = [];
-	for (const replacement of replacements) {
-		if (replacement.start < cursor) throw new Error("Overlapping overwrite ranges are not supported");
-		code += original.slice(cursor, replacement.start);
-		const generatedStart = replacement.start + delta;
-		code += replacement.content;
-		const generatedEnd = generatedStart + replacement.content.length;
-		applied.push({
-			...replacement,
-			generatedStart,
-			generatedEnd
-		});
-		cursor = replacement.end;
-		delta += replacement.content.length - (replacement.end - replacement.start);
-	}
-	code += original.slice(cursor);
-	return {
-		code,
-		replacements: applied
-	};
-}
-function generateLineMappings(generated, original, replacements) {
-	const generatedLineStarts = getLineStarts(generated);
-	const originalLineStarts = getLineStarts(original);
-	let previousOriginalLine = 0;
-	let previousOriginalColumn = 0;
-	let mappings = "";
-	generatedLineStarts.forEach((generatedOffset, lineIndex) => {
-		if (lineIndex > 0) mappings += ";";
-		const originalOffset = generatedOffsetToOriginalOffset(generatedOffset, replacements);
-		const originalLine = findLine(originalLineStarts, originalOffset);
-		const originalColumn = originalOffset - originalLineStarts[originalLine];
-		mappings += encodeSegment([
-			0,
-			0,
-			originalLine - previousOriginalLine,
-			originalColumn - previousOriginalColumn
-		]);
-		previousOriginalLine = originalLine;
-		previousOriginalColumn = originalColumn;
-	});
-	return mappings;
-}
-function generatedOffsetToOriginalOffset(offset, replacements) {
-	let delta = 0;
-	for (const replacement of replacements) {
-		if (offset < replacement.generatedStart) break;
-		if (offset < replacement.generatedEnd) return replacement.start;
-		delta += replacement.content.length - (replacement.end - replacement.start);
-	}
-	return offset - delta;
-}
-function getLineStarts(code) {
-	const starts = [0];
-	for (let i = 0; i < code.length; i++) if (code.charCodeAt(i) === 10) starts.push(i + 1);
-	return starts;
-}
-function findLine(lineStarts, offset) {
-	let low = 0;
-	let high = lineStarts.length - 1;
-	while (low <= high) {
-		const mid = low + high >> 1;
-		if (lineStarts[mid] <= offset) low = mid + 1;
-		else high = mid - 1;
-	}
-	return Math.max(0, high);
-}
-function encodeSegment(values) {
-	return values.map(encodeVlq).join("");
-}
-function encodeVlq(value) {
-	let vlq = value < 0 ? (-value << 1) + 1 : value << 1;
-	let encoded = "";
-	do {
-		let digit = vlq & 31;
-		vlq >>>= 5;
-		if (vlq > 0) digit |= 32;
-		encoded += BASE64_CHARS[digit];
-	} while (vlq > 0);
-	return encoded;
-}
-//#endregion
 //#region src/utils/mapCodeToCodeWithSourcemap.ts
 async function mapCodeToCodeWithSourcemap(code) {
 	const resolvedCode = await code;
@@ -416,147 +290,6 @@ function resolveRemoteConsumer(ctx, hasMultiEnvironment) {
 	return resolveEnvironmentConsumerTarget(ctx) ?? "client";
 }
 //#endregion
-//#region src/utils/codePositionMap.ts
-const REGEX_PREFIX_KEYWORDS = /* @__PURE__ */ new Set([
-	"await",
-	"case",
-	"delete",
-	"in",
-	"instanceof",
-	"new",
-	"return",
-	"throw",
-	"typeof",
-	"void",
-	"yield"
-]);
-function isJsxClosingTagSlash(code, slashIndex) {
-	if (code[slashIndex - 1] !== "<") return false;
-	let cursor = slashIndex + 1;
-	while (/\s/.test(code[cursor] || "")) cursor++;
-	if (code[cursor] === ">") return true;
-	const tagStart = cursor;
-	while (/[-:.$_\u200C\u200D\p{ID_Continue}]/u.test(code[cursor] || "")) cursor++;
-	if (cursor === tagStart) return false;
-	while (/\s/.test(code[cursor] || "")) cursor++;
-	return code[cursor] === ">";
-}
-/** Mark comments, string/template literals, and regular expressions as non-code. */
-function createCodePositionMap(code, onComment) {
-	const positions = Array(code.length).fill(true);
-	const mask = (start, end) => {
-		for (let index = start; index < end; index++) positions[index] = false;
-	};
-	let canStartRegex = true;
-	for (let index = 0; index < code.length;) {
-		const char = code[index];
-		const next = code[index + 1];
-		if (/\s/.test(char)) {
-			index++;
-			continue;
-		}
-		if (char === "/" && next === "/") {
-			const start = index;
-			index += 2;
-			while (index < code.length && code[index] !== "\n" && code[index] !== "\r") index++;
-			mask(start, index);
-			onComment?.(start, index);
-			continue;
-		}
-		if (char === "/" && next === "*") {
-			const start = index;
-			index += 2;
-			while (index < code.length && !(code[index] === "*" && code[index + 1] === "/")) index++;
-			index = Math.min(code.length, index + 2);
-			mask(start, index);
-			onComment?.(start, index);
-			continue;
-		}
-		if (char === "\"" || char === "'" || char === "`") {
-			const quote = char;
-			const start = index++;
-			while (index < code.length) {
-				if (code[index] === "\\") {
-					index += 2;
-					continue;
-				}
-				if (code[index] === quote) {
-					index++;
-					break;
-				}
-				index++;
-			}
-			mask(start, index);
-			canStartRegex = false;
-			continue;
-		}
-		const closesJsxTag = isJsxClosingTagSlash(code, index);
-		if (char === "/" && canStartRegex && !closesJsxTag) {
-			const start = index;
-			let cursor = index + 1;
-			let escaped = false;
-			let inCharacterClass = false;
-			let closed = false;
-			for (; cursor < code.length; cursor++) {
-				const regexChar = code[cursor];
-				if (regexChar === "\n" || regexChar === "\r") break;
-				if (escaped) {
-					escaped = false;
-					continue;
-				}
-				if (regexChar === "\\") {
-					escaped = true;
-					continue;
-				}
-				if (regexChar === "[") {
-					inCharacterClass = true;
-					continue;
-				}
-				if (regexChar === "]" && inCharacterClass) {
-					inCharacterClass = false;
-					continue;
-				}
-				if (regexChar === "/" && !inCharacterClass) {
-					cursor++;
-					while (/[$_\p{ID_Continue}]/u.test(code[cursor] || "")) cursor++;
-					closed = true;
-					break;
-				}
-			}
-			if (closed) {
-				mask(start, cursor);
-				index = cursor;
-				canStartRegex = false;
-				continue;
-			}
-		}
-		if (/[$_\p{ID_Start}]/u.test(char)) {
-			const start = index++;
-			while (/[$_\u200C\u200D\p{ID_Continue}]/u.test(code[index] || "")) index++;
-			canStartRegex = REGEX_PREFIX_KEYWORDS.has(code.slice(start, index));
-			continue;
-		}
-		if (/\d/.test(char)) {
-			index++;
-			while (/[\w.]/.test(code[index] || "")) index++;
-			canStartRegex = false;
-			continue;
-		}
-		if ((char === "+" || char === "-") && next === char) {
-			index += 2;
-			continue;
-		}
-		if (char === "!" && next !== "=") {
-			index++;
-			continue;
-		}
-		if (char === ")" || char === "]" || char === "}") canStartRegex = false;
-		else if (char !== ".") canStartRegex = true;
-		index++;
-	}
-	return positions;
-}
-//#endregion
 //#region src/utils/htmlEntryUtils.ts
 const IDENTIFIER = String.raw`[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}]*`;
 const NAMED_SPECIFIERS = String.raw`\{[^{}]*\}`;
@@ -722,18 +455,18 @@ function normalizeExposes(exposes) {
 	});
 	return res;
 }
-function normalizeRemotes(remotes) {
+function normalizeRemotes(remotes, defaultShareScope = "default") {
 	if (!remotes) return {};
 	const result = {};
 	if (typeof remotes === "object") Object.keys(remotes).forEach((key) => {
-		result[key] = normalizeRemoteItem(key, remotes[key]);
+		result[key] = normalizeRemoteItem(key, remotes[key], defaultShareScope);
 	});
 	return result;
 }
 function warnOmittedObjectRemoteType(remoteKey) {
 	mfWarn(`Remote "${remoteKey}" omits type and defaults to 'var'. Set type: 'module' for Vite ESM remotes, or type: 'var' explicitly to silence this warning.`);
 }
-function normalizeRemoteItem(key, remote) {
+function normalizeRemoteItem(key, remote, defaultShareScope) {
 	warnOnReservedInternalNamePrefix(key, "remoteAlias");
 	if (typeof remote === "string") {
 		const separatorIndex = remote.startsWith("@") ? remote.indexOf("@", 1) : remote.indexOf("@");
@@ -752,7 +485,7 @@ function normalizeRemoteItem(key, remote) {
 			internalName: toInternalModuleFederationName(key),
 			entry,
 			entryGlobalName,
-			shareScope: "default"
+			shareScope: defaultShareScope
 		};
 	}
 	const typeOmitted = remote.type === void 0 || remote.type === null || remote.type === "";
@@ -761,7 +494,7 @@ function normalizeRemoteItem(key, remote) {
 		type: "var",
 		name: key,
 		internalName: toInternalModuleFederationName(key),
-		shareScope: "default",
+		shareScope: defaultShareScope,
 		entryGlobalName: key
 	}, {
 		...remote,
@@ -869,7 +602,7 @@ function resolveSharedVersions(shared, root) {
 		item.shareConfig.requiredVersion = requiredVersion;
 	}
 }
-function normalizeShareItem(key, shareItem) {
+function normalizeShareItem(key, shareItem, defaultShareScope) {
 	const treeShaking = typeof shareItem === "object" ? shareItem.treeShaking : void 0;
 	if (treeShaking && treeShaking.mode !== "server-calc" && treeShaking.mode !== "runtime-infer") throw createModuleFederationError(`Invalid shared config for "${key}": treeShaking.mode must be either "server-calc" or "runtime-infer".`);
 	if (treeShaking && typeof shareItem === "object" && shareItem.eager) throw createModuleFederationError(`Invalid shared config for "${key}": cannot use both "eager: true" and "treeShaking.mode" simultaneously. Choose one strategy.`);
@@ -885,7 +618,7 @@ function normalizeShareItem(key, shareItem) {
 		const result = {
 			name: shareItem,
 			version,
-			scope: "default",
+			scope: defaultShareScope,
 			from: "",
 			shareConfig: {
 				import: void 0,
@@ -901,7 +634,7 @@ function normalizeShareItem(key, shareItem) {
 		name: key,
 		from: "",
 		version,
-		scope: shareItem.shareScope || "default",
+		scope: shareItem.shareScope || defaultShareScope,
 		shareConfig: {
 			import: shareItem.import,
 			singleton: shareItem.singleton || false,
@@ -940,7 +673,7 @@ function normalizeSharedKey(key) {
 	if (baseKey === "react") return key;
 	return getCommonSharedSubpaths(baseKey).length > 0 ? baseKey : key;
 }
-function normalizeShared(shared) {
+function normalizeShared(shared, defaultShareScope = "default") {
 	explicitSharedKeys = /* @__PURE__ */ new Set();
 	if (!shared) return {};
 	const result = {};
@@ -949,7 +682,7 @@ function normalizeShared(shared) {
 		if (isModuleFederationRuntimePackage(key)) return;
 		const normalizedKey = normalizeSharedKey(key);
 		const hadConfiguredPackageSubpath = (result[normalizedKey]?.shareConfig)?.__mfConfiguredPackageSubpath === true;
-		result[normalizedKey] = normalizeShareItem(normalizedKey, normalizedKey);
+		result[normalizedKey] = normalizeShareItem(normalizedKey, normalizedKey, defaultShareScope);
 		if (key.endsWith("/") || hadConfiguredPackageSubpath) result[normalizedKey].shareConfig.__mfConfiguredPackageSubpath = true;
 		explicitSharedKeys.add(normalizedKey);
 		sourceEntries.push([normalizedKey, normalizedKey]);
@@ -959,7 +692,7 @@ function normalizeShared(shared) {
 		const normalizedKey = normalizeSharedKey(key);
 		const value = shared[key];
 		const hadConfiguredPackageSubpath = (result[normalizedKey]?.shareConfig)?.__mfConfiguredPackageSubpath === true;
-		result[normalizedKey] = normalizeShareItem(normalizedKey, value);
+		result[normalizedKey] = normalizeShareItem(normalizedKey, value, defaultShareScope);
 		const requestIsPrefix = typeof value?.request === "string" && value.request.endsWith("/");
 		if (key.endsWith("/") || requestIsPrefix || hadConfiguredPackageSubpath) result[normalizedKey].shareConfig.__mfConfiguredPackageSubpath = true;
 		explicitSharedKeys.add(normalizedKey);
@@ -968,7 +701,7 @@ function normalizeShared(shared) {
 	sourceEntries.forEach(([key, value]) => {
 		for (const subpathShare of getLitExportSubpathShares(key)) {
 			if (result[subpathShare]) continue;
-			result[subpathShare] = normalizeShareItem(subpathShare, value);
+			result[subpathShare] = normalizeShareItem(subpathShare, value, defaultShareScope);
 		}
 	});
 	return result;
@@ -992,7 +725,8 @@ function normalizeExperiments(experiments) {
 	return {
 		externalRuntime: experiments?.externalRuntime === true,
 		provideExternalRuntime: experiments?.provideExternalRuntime === true,
-		ssrMode: experiments?.ssrMode === "ISLAND" ? "ISLAND" : void 0
+		ssrMode: experiments?.ssrMode === "ISLAND" ? "ISLAND" : void 0,
+		hostProvidesAllShared: experiments?.hostProvidesAllShared === true
 	};
 }
 function normalizeSsrEntryLoader(ssrEntryLoader) {
@@ -1048,6 +782,7 @@ function getNormalizeShareItem(key, options = getNormalizeModuleFederationOption
 function normalizeModuleFederationOptions(options) {
 	warnOnReservedInternalNamePrefix(options.name, "containerName");
 	if (options.virtualModuleDir && options.virtualModuleDir.includes("/")) throw createModuleFederationError(`Invalid virtualModuleDir: "${options.virtualModuleDir}". The virtualModuleDir option cannot contain slashes (/). Please use a single directory name like '__mf__virtual__your_app_name'.`);
+	const defaultShareScope = typeof options.shareScope === "string" ? options.shareScope : "default";
 	const normalized = {
 		exposes: normalizeExposes(options.exposes),
 		filename: options.filename || "remoteEntry-[hash]",
@@ -1055,10 +790,10 @@ function normalizeModuleFederationOptions(options) {
 		internalName: toInternalModuleFederationName(options.name),
 		library: normalizeLibrary(options.library),
 		name: options.name,
-		remotes: normalizeRemotes(options.remotes),
+		remotes: normalizeRemotes(options.remotes, defaultShareScope),
 		runtime: options.runtime,
 		shareScope: options.shareScope || "default",
-		shared: normalizeShared(options.shared),
+		shared: normalizeShared(options.shared, defaultShareScope),
 		runtimePlugins: options.runtimePlugins || [],
 		implementation: normalizePathForImport(options.implementation || resolveRuntimeImplementation()),
 		manifest: normalizeManifest(options.manifest),
@@ -2671,6 +2406,11 @@ function resolveRelativeModule(filePath, specifier) {
 	const dir = path$1.dirname(filePath);
 	const exact = path$1.resolve(dir, specifier);
 	if (existsSync(exact) && !statSync(exact).isDirectory()) return exact;
+	const sourceExtensions = specifier.endsWith(".mjs") ? [".mts"] : specifier.endsWith(".cjs") ? [".cts"] : /\.jsx?$/.test(specifier) ? [".ts", ".tsx"] : [];
+	for (const ext of sourceExtensions) {
+		const candidate = exact.replace(/\.[cm]?jsx?$/, ext);
+		if (existsSync(candidate) && !statSync(candidate).isDirectory()) return candidate;
+	}
 	const extensions = [
 		".ts",
 		".tsx",
@@ -4001,16 +3741,22 @@ function generateLocalSharedImportMap(options) {
     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;
-      }
+      const isOlder = (version) => {
+        const actual = String(version || '').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 true;
+          if ((actual[index] || 0) > (expected[index] || 0)) return false;
+        }
+        return false;
+      };
+      if (isOlder(react?.version ?? react?.default?.version)) return undefined;
       for (const key of keys) {
         const cached = cache?.[key];
         if (cached === undefined) continue;
+        // A host seed from an older React family is not coherent with the newer cached react
+        const cachedVersion = cached?.version ?? cached?.default?.version;
+        if (cachedVersion !== undefined && isOlder(cachedVersion)) continue;
         if (!requiredExport || typeof cached?.[requiredExport] === 'function' || typeof cached?.default?.[requiredExport] === 'function') return cached;
       }
       return undefined;
@@ -4385,6 +4131,9 @@ const normalizeRuntimeShareCode = `const __mfNormalizeRuntimeShare = (mod) => {
             for (let i = 0; i < 5; i++) {
               const defaultExport = current?.default;
               if (!defaultExport || typeof defaultExport !== "object" || Object.keys(defaultExport).length === 0) break;
+              // Only unwrap plain CJS namespaces; spreading a class instance would drop its prototype.
+              const proto = Object.getPrototypeOf(defaultExport);
+              if (proto !== null && proto !== Object.prototype) break;
               const namedValues = Object.keys(current).filter((key) => key !== "default").map((key) => current[key]);
               if (namedValues.length > 0 && namedValues.some((value) => value !== undefined)) break;
               current = defaultExport;
@@ -4645,8 +4394,9 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy, options, command = "b
               __mfNormalizeRuntimeShare(externalResolved),
               externalProvider.from
             );
+            return;
           }
-          return;
+          if (typeof isWebpackProvider === 'function' && isWebpackProvider(externalProvider)) return;
         }
         const providerKey = cacheDescriptor.canonical;
         const resolved = await __mfInitializeProviderOnce(providerKey, async () => {
@@ -6089,6 +5839,22 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
             }));
           }
           ` : ""}
+          // The seed called this container's get() directly, so the Runtime's
+          // provider never learned it is in use and a remote could load its own
+          // copy (#1396). Mark it once the host is bound to the local copy.
+          for (const [pkg, share] of Object.entries(usedShared)) {
+            if (!share.lib || share.treeShaking || share.shareConfig?.import === false) continue;
+            const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
+            if (__mfReadSharedCacheOwner(__mfModuleCache.share, cacheDescriptor) !== ${cacheOwner}) continue;
+            for (const scopeName of Array.isArray(share.scope) ? share.scope : [share.scope || "default"]) {
+              const versions = runtime.shareScopeMap?.[scopeName]?.[pkg];
+              const provider = versions?.[share.version];
+              if (!provider || provider.get !== share.get || provider.lib) continue;
+              if (Object.values(versions).some((other) => other !== provider && (other?.lib || other?.loaded))) continue;
+              provider.lib = share.lib;
+              provider.loaded = true;
+            }
+          }
           return runtime;
         })();
       }
@@ -6967,6 +6733,19 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 		apply: "serve",
 		config(_config, { command }) {
 			_command = command;
+			const isRemoteEntry = entryName === "remoteEntry" && federationOptions !== void 0 && isRemoteContainer(federationOptions);
+			if (command === "serve" && _config.experimental?.bundledDev && isRemoteEntry) {
+				_config.experimental = {
+					..._config.experimental,
+					bundledDev: false
+				};
+				_config.environments ??= {};
+				_config.environments.client ??= {};
+				if (_config.environments.client.isBundled !== false) {
+					_config.environments.client.isBundled = false;
+					mfWarn("Vite bundledDev is disabled for the client environment of a Module Federation remote container so its remoteEntry keeps the standard init/get contract.");
+				}
+			}
 		},
 		configResolved(config) {
 			viteConfig = config;
@@ -8263,7 +8042,8 @@ function pluginLazyConsumeOnlyShares(options) {
 			const rewriter = new CodeRewriter(code);
 			let edited = false;
 			const importMapId = normalizeVirtualModuleId(getLocalSharedImportMapPath(options));
-			if (chunkModuleIds(renderedChunk).some((id) => normalizeVirtualModuleId(id) === importMapId)) for (const quote of QUOTES) {
+			const isImportMapChunk = chunkModuleIds(renderedChunk).some((id) => normalizeVirtualModuleId(id) === importMapId);
+			if (isImportMapChunk) for (const quote of QUOTES) {
 				const literal = `${quote}${LAZY_CONSUME_ONLY_SHARES_PLACEHOLDER}${quote}`;
 				const start = code.indexOf(literal);
 				if (start === -1) continue;
@@ -8274,7 +8054,7 @@ function pluginLazyConsumeOnlyShares(options) {
 			const chunkDir = path$1.posix.dirname(renderedChunk.fileName);
 			const codePositions = createCodePositionMap(code);
 			let usesHelper = false;
-			for (const match of code.matchAll(DYNAMIC_IMPORT_REGEX)) {
+			for (const match of isImportMapChunk ? [] : code.matchAll(DYNAMIC_IMPORT_REGEX)) {
 				const [expression, , specifier] = match;
 				const start = match.index;
 				if (!codePositions[start]) continue;
@@ -8303,7 +8083,7 @@ function ${helperName}(names) {
 }
 //#endregion
 //#region package.json
-var version$1 = "1.23.0";
+var version$1 = "1.23.2";
 //#endregion
 //#region src/virtualModules/virtualExposesSSR.ts
 /**
@@ -8405,6 +8185,8 @@ function generateRemoteEntrySSR(options) {
   const sharedSingletons = ${JSON.stringify(sharedSingletons)};
   const moduleCacheKey = Symbol.for(${JSON.stringify(MODULE_CACHE_SHARE_SCOPE_KEY)});
   let exposesMapPromise;
+  // One identity per container, so a re-entrant init with the same initScope finds it.
+  const initToken = { from: ${JSON.stringify(options.name)} };
 
   function createShareInitError(errors) {
     const details = errors.map(({ scopeName, pkg, error }) => {
@@ -8433,7 +8215,6 @@ function generateRemoteEntrySSR(options) {
       remotes: [],
       shared: {},
     });
-    const initToken = { from: ${JSON.stringify(options.name)} };
     if (initScope.indexOf(initToken) >= 0) return;
     initScope.push(initToken);
     const shareScopeNames = Array.isArray(${JSON.stringify(options.shareScope)})
@@ -8770,18 +8551,21 @@ const Manifest = (providedOptions) => {
 			publicPath = mfOptions.publicPath === "auto" ? "auto" : resolvePublicPath(mfOptions, base, _originalConfigBase);
 		},
 		/**
-		* A standalone `vite build --ssr` may run with its own `filename`, e.g.
-		* `defineConfig(({ isSsrBuild }) => ...)`. The manifest written by the
-		* earlier client build then advertises an SSR entry derived from the
-		* browser filename, which is not the file this build emitted. Point the
-		* manifest and stats on disk at the emitted SSR entry.
+		* The client manifest only advertises an SSR entry its own bundle
+		* emitted. The SSR entry usually lands in a separate build: a standalone
+		* `vite build --ssr` (possibly with its own `filename`, e.g.
+		* `defineConfig(({ isSsrBuild }) => ...)`) or the `ssr` environment,
+		* which the builder may run before or after `client`. Whichever build
+		* finishes with the SSR entry on disk points the manifest and stats at it.
 		*/
 		writeBundle(outputOptions) {
 			if (!mfManifestName || _command !== "build" || isConsumerProject) return;
-			const environment = this.environment;
-			if (!(environment ? environment.name === "ssr" : Boolean(viteConfig?.build?.ssr))) return;
 			const ssrEntryName = getSsrRemoteEntryFileName(mfOptions);
-			const outDirs = [...new Set([outputOptions.dir, viteConfig?.environments?.client?.build?.outDir].filter((dir) => typeof dir === "string").map((dir) => path$1.resolve(root, dir)))];
+			const outDirs = [...new Set([
+				outputOptions.dir,
+				viteConfig?.environments?.client?.build?.outDir,
+				viteConfig?.environments?.ssr?.build?.outDir
+			].filter((dir) => typeof dir === "string").map((dir) => path$1.resolve(root, dir)))];
 			if (!outDirs.some((dir) => fs$1.existsSync(path$1.resolve(dir, ssrEntryName)))) return;
 			for (const dir of outDirs) for (const fileName of [mfManifestName, mfManifestStatsName]) {
 				if (!fileName) continue;
@@ -8790,8 +8574,12 @@ const Manifest = (providedOptions) => {
 				try {
 					const data = JSON.parse(fs$1.readFileSync(file, "utf8"));
 					const entry = data?.metaData?.ssrRemoteEntry;
-					if (!entry || typeof entry !== "object" || entry.name === ssrEntryName) continue;
-					entry.name = ssrEntryName;
+					if (!data?.metaData || entry?.name === ssrEntryName) continue;
+					data.metaData.ssrRemoteEntry = Object.assign({
+						name: ssrEntryName,
+						path: "",
+						type: "module"
+					}, typeof entry === "object" ? entry : null, { name: ssrEntryName });
 					fs$1.writeFileSync(file, JSON.stringify(data));
 				} catch {}
 			}
@@ -8809,7 +8597,7 @@ const Manifest = (providedOptions) => {
 			const expectedSsrRemoteEntryFile = getSsrRemoteEntryFileName(mfOptions);
 			const foundSsrRemoteEntryFile = Object.values(bundle).find((file) => file.fileName === expectedSsrRemoteEntryFile)?.fileName;
 			if (foundRemoteEntryFile) remoteEntryFile = foundRemoteEntryFile;
-			ssrRemoteEntryFile = foundSsrRemoteEntryFile || (_command === "serve" ? getSsrRemoteEntryFileName(mfOptions, resolveHashPlaceholderFileName(mfOptions.filename)) : expectedSsrRemoteEntryFile);
+			ssrRemoteEntryFile = foundSsrRemoteEntryFile || (_command === "serve" ? getSsrRemoteEntryFileName(mfOptions, resolveHashPlaceholderFileName(mfOptions.filename)) : void 0);
 			const allCssAssets = mfOptions.bundleAllCSS && !disableAssetsAnalyze ? collectCssAssets(bundle) : /* @__PURE__ */ new Set();
 			if (allCssAssets.size > 0) {
 				const secondaryCss = /* @__PURE__ */ new Set();
@@ -8885,11 +8673,12 @@ const Manifest = (providedOptions) => {
 			path: "",
 			type: "module"
 		};
-		const ssrRemoteEntry = {
-			name: ssrRemoteEntryFile || getSsrRemoteEntryFileName(mfOptions, _command === "serve" ? resolveHashPlaceholderFileName(filename) : filename),
+		const resolvedSsrRemoteEntryFile = _command === "serve" ? ssrRemoteEntryFile || getSsrRemoteEntryFileName(mfOptions, resolveHashPlaceholderFileName(filename)) : ssrRemoteEntryFile;
+		const ssrRemoteEntry = resolvedSsrRemoteEntryFile ? {
+			name: resolvedSsrRemoteEntryFile,
 			path: _command === "serve" ? "/__mf_ssr__/" : "",
 			type: "module"
-		};
+		} : void 0;
 		const varRemoteEntry = varFilename ? {
 			name: varFilename,
 			path: "",
@@ -9014,6 +8803,106 @@ function getStatsFileName(manifestFileName) {
 	return parsed.dir ? normalizePathForImport(path$1.join(parsed.dir, fileName)) : fileName;
 }
 //#endregion
+//#region src/utils/sharedSource.ts
+const pendingEntryLookups = /* @__PURE__ */ new Map();
+const getEntryLookupKey = (source, importer) => `${source}\0${importer}`;
+/** Whether a resolveId call is one of the shared source resolver's own entry lookups. */
+function isSharedEntryLookup(source, importer, options) {
+	return options.custom?.__mfSharedEntryLookup === true || pendingEntryLookups.has(getEntryLookupKey(source, importer));
+}
+/**
+* Runs one of the plugin's own `this.resolve()` calls (a shared entry lookup, a
+* parse-barrier external probe), marked so `isSharedEntryLookup` recognizes it
+* and the share hooks neither proxy it nor register a used share for it.
+*/
+async function resolveInternally(context, source, importer, options = {}) {
+	const lookupKey = getEntryLookupKey(source, importer);
+	pendingEntryLookups.set(lookupKey, (pendingEntryLookups.get(lookupKey) ?? 0) + 1);
+	try {
+		return await context.resolve(source, importer, {
+			...options,
+			skipSelf: true,
+			custom: {
+				...options.custom,
+				__mfSharedEntryLookup: true
+			}
+		});
+	} finally {
+		const remaining = pendingEntryLookups.get(lookupKey) - 1;
+		if (remaining) pendingEntryLookups.set(lookupKey, remaining);
+		else pendingEntryLookups.delete(lookupKey);
+	}
+}
+/** Identify shared entries through Vite, with a cache scoped to this federation instance. */
+function createSharedSourceResolver(shared, getResolutionConfig) {
+	const caches = /* @__PURE__ */ new Map();
+	async function matchEntry(source, suffix, resolveEntry) {
+		const packageName = getPackageNameFromNodeModulePath(source);
+		if (!packageName) return;
+		const candidates = /* @__PURE__ */ new Set();
+		if (findSharedKey(packageName, shared)) candidates.add(packageName);
+		if (findSharedKey(suffix, shared)) candidates.add(suffix);
+		for (const key of Object.keys(shared)) {
+			const request = getSharedRequest(key, shared[key]);
+			if (getPackageName(request) !== packageName) continue;
+			if (!request.endsWith("/")) candidates.add(request);
+			for (const subpath of getCommonSharedSubpaths(request)) if (findSharedKey(subpath, shared)) candidates.add(subpath);
+		}
+		if (candidates.size === 0) return;
+		const resolvedSource = await resolveEntry(source);
+		if (!resolvedSource) return;
+		for (const candidate of candidates) {
+			const entry = await resolveEntry(candidate);
+			if (!entry) continue;
+			const allowNodeModulesSuffixMatch = shared[findSharedKey(candidate, shared) ?? candidate]?.shareConfig?.allowNodeModulesSuffixMatch === true;
+			if (normalizeNodeModulePath(entry) === normalizeNodeModulePath(resolvedSource) || allowNodeModulesSuffixMatch && getNodeModulesSuffix(entry) === suffix) return candidate;
+		}
+	}
+	return {
+		clear() {
+			caches.clear();
+		},
+		async resolve(context, source, options = {}) {
+			if (source.startsWith("\0") || source.includes("#")) return;
+			const queryIndex = source.indexOf("?");
+			const query = queryIndex === -1 ? "" : source.slice(queryIndex + 1);
+			if (query && [...new URLSearchParams(query).keys()].some((key) => ![
+				"v",
+				"t",
+				"import"
+			].includes(key))) return;
+			if (findSharedKey(source, shared)) return source;
+			const suffix = getNodeModulesSuffix(source);
+			if (!suffix) return;
+			const normalizedSource = stripViteFsPrefix(normalizeNodeModulePath(source));
+			const environment = context.environment ?? !!options.ssr;
+			const cacheable = !options.isEntry && !options.scan && (!options.kind || options.kind === "import-statement") && Object.keys(options.attributes ?? {}).length === 0 && Object.keys(options.custom ?? {}).length === 0;
+			let cache = cacheable ? caches.get(environment) : void 0;
+			if (cacheable && !cache) {
+				cache = /* @__PURE__ */ new Map();
+				caches.set(environment, cache);
+			}
+			if (cache?.has(normalizedSource)) return cache.get(normalizedSource);
+			const { root, conditions } = getResolutionConfig(context, options);
+			const result = await matchEntry(normalizedSource, suffix, async (request) => {
+				if (!path$1.isAbsolute(request) && !isPackageExportAvailable(request, {
+					cwd: root,
+					conditions
+				})) return void 0;
+				const importer = path$1.join(root, "package.json");
+				try {
+					const resolved = await resolveInternally(context, request, importer, options);
+					return resolved && !resolved.external ? resolved.id : void 0;
+				} catch {
+					return;
+				}
+			});
+			cache?.set(normalizedSource, result);
+			return result;
+		}
+	};
+}
+//#endregion
 //#region src/plugins/pluginModuleParseEnd.ts
 function createModuleParseController() {
 	return {
@@ -9155,7 +9044,7 @@ function pluginModuleParseEnd_default(excludeFn, options, controller = createMod
 				if (typeof this.resolve !== "function") return;
 				if (controller.resolutionProbed.has(pendingId)) return;
 				controller.resolutionProbed.add(pendingId);
-				this.resolve(pendingId, id, { skipSelf: true }).then((resolved) => {
+				resolveInternally(this, pendingId, id).then((resolved) => {
 					if (!resolved?.external) return;
 					controller.externalSet.add(pendingId);
 					controller.parseStartSet.delete(pendingId);
@@ -9164,7 +9053,7 @@ function pluginModuleParseEnd_default(excludeFn, options, controller = createMod
 			};
 			const addPendingIds = (ids) => {
 				for (const pendingId of ids || []) {
-					if (!this.getModuleInfo(pendingId) || controller.externalSet.has(pendingId) || matchesExternal(configuredExternal, pendingId, id) || excludeFn(pendingId)) continue;
+					if (controller.externalSet.has(pendingId) || matchesExternal(configuredExternal, pendingId, id) || excludeFn(pendingId)) continue;
 					controller.parseStartSet.add(pendingId);
 					if (!controller.parseEndSet.has(pendingId)) probeExternal(pendingId);
 				}
@@ -9239,7 +9128,12 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 				if (!dynamic) dependencies.add(source);
 				continue;
 			}
-			const resolved = await ctx.resolve(source, id);
+			let resolved;
+			try {
+				resolved = await ctx.resolve(source, id);
+			} catch {
+				continue;
+			}
 			if (!resolved?.id || !shouldScanResolvedImport(resolved.id)) continue;
 			for (const dependency of await collectRemoteDependencies(ctx, resolved.id, seen)) dependencies.add(dependency);
 		}
@@ -9459,96 +9353,6 @@ function pluginProxyRemotes_default(options) {
 	};
 }
 //#endregion
-//#region src/utils/sharedSource.ts
-const pendingEntryLookups = /* @__PURE__ */ new Map();
-const getEntryLookupKey = (source, importer) => `${source}\0${importer}`;
-/** Whether a resolveId call is one of the shared source resolver's own entry lookups. */
-function isSharedEntryLookup(source, importer, options) {
-	return options.custom?.__mfSharedEntryLookup === true || pendingEntryLookups.has(getEntryLookupKey(source, importer));
-}
-/** Identify shared entries through Vite, with a cache scoped to this federation instance. */
-function createSharedSourceResolver(shared, getResolutionConfig) {
-	const caches = /* @__PURE__ */ new Map();
-	async function matchEntry(source, suffix, resolveEntry) {
-		const packageName = getPackageNameFromNodeModulePath(source);
-		if (!packageName) return;
-		const candidates = /* @__PURE__ */ new Set();
-		if (findSharedKey(packageName, shared)) candidates.add(packageName);
-		if (findSharedKey(suffix, shared)) candidates.add(suffix);
-		for (const key of Object.keys(shared)) {
-			const request = getSharedRequest(key, shared[key]);
-			if (getPackageName(request) !== packageName) continue;
-			if (!request.endsWith("/")) candidates.add(request);
-			for (const subpath of getCommonSharedSubpaths(request)) if (findSharedKey(subpath, shared)) candidates.add(subpath);
-		}
-		if (candidates.size === 0) return;
-		const resolvedSource = await resolveEntry(source);
-		if (!resolvedSource) return;
-		for (const candidate of candidates) {
-			const entry = await resolveEntry(candidate);
-			if (!entry) continue;
-			const allowNodeModulesSuffixMatch = shared[findSharedKey(candidate, shared) ?? candidate]?.shareConfig?.allowNodeModulesSuffixMatch === true;
-			if (normalizeNodeModulePath(entry) === normalizeNodeModulePath(resolvedSource) || allowNodeModulesSuffixMatch && getNodeModulesSuffix(entry) === suffix) return candidate;
-		}
-	}
-	return {
-		clear() {
-			caches.clear();
-		},
-		async resolve(context, source, options = {}) {
-			if (source.startsWith("\0") || source.includes("#")) return;
-			const queryIndex = source.indexOf("?");
-			const query = queryIndex === -1 ? "" : source.slice(queryIndex + 1);
-			if (query && [...new URLSearchParams(query).keys()].some((key) => ![
-				"v",
-				"t",
-				"import"
-			].includes(key))) return;
-			if (findSharedKey(source, shared)) return source;
-			const suffix = getNodeModulesSuffix(source);
-			if (!suffix) return;
-			const normalizedSource = stripViteFsPrefix(normalizeNodeModulePath(source));
-			const environment = context.environment ?? !!options.ssr;
-			const cacheable = !options.isEntry && !options.scan && (!options.kind || options.kind === "import-statement") && Object.keys(options.attributes ?? {}).length === 0 && Object.keys(options.custom ?? {}).length === 0;
-			let cache = cacheable ? caches.get(environment) : void 0;
-			if (cacheable && !cache) {
-				cache = /* @__PURE__ */ new Map();
-				caches.set(environment, cache);
-			}
-			if (cache?.has(normalizedSource)) return cache.get(normalizedSource);
-			const { root, conditions } = getResolutionConfig(context, options);
-			const result = await matchEntry(normalizedSource, suffix, async (request) => {
-				if (!path$1.isAbsolute(request) && !isPackageExportAvailable(request, {
-					cwd: root,
-					conditions
-				})) return void 0;
-				const importer = path$1.join(root, "package.json");
-				const lookupKey = getEntryLookupKey(request, importer);
-				pendingEntryLookups.set(lookupKey, (pendingEntryLookups.get(lookupKey) ?? 0) + 1);
-				try {
-					const resolved = await context.resolve(request, importer, {
-						...options,
-						skipSelf: true,
-						custom: {
-							...options.custom,
-							__mfSharedEntryLookup: true
-						}
-					});
-					return resolved && !resolved.external ? resolved.id : void 0;
-				} catch {
-					return;
-				} finally {
-					const remaining = pendingEntryLookups.get(lookupKey) - 1;
-					if (remaining) pendingEntryLookups.set(lookupKey, remaining);
-					else pendingEntryLookups.delete(lookupKey);
-				}
-			});
-			cache?.set(normalizedSource, result);
-			return result;
-		}
-	};
-}
-//#endregion
 //#region src/utils/PromiseStore.ts
 /**
 * example:
@@ -9762,8 +9566,9 @@ function isSharedPackageDependency(sharedKey, dependency) {
 function isConfiguredSharedPackage(pkg, shared) {
 	return Object.keys(shared).some((key) => getPackageName(key) === pkg);
 }
-function shouldKeepSharedImportLocal(source, importer, sharedKey, shared, importerPackage) {
+function shouldKeepSharedImportLocal(source, importer, sharedKey, shared, importerPackage, federationOptions) {
 	if (!importer || shared[sharedKey]?.shareConfig.import === false) return false;
+	if (hasRemotes(federationOptions)) 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;
@@ -10181,7 +9986,7 @@ function proxySharedModule(options) {
 				if (shouldSkipTaggedImporterProxy(key, "__loadShare__")) return;
 				if (shouldSkipTaggedImporterProxy(key, "__prebuild__")) return;
 				const shareSource = key === "vue" && sharedSource.startsWith("vue/dist/") ? key : sharedSource;
-				if (shouldKeepSharedImportLocal(sharedSource, importer, key, shared, importerPackage)) {
+				if (shouldKeepSharedImportLocal(shareSource, importer, key, shared, importerPackage, federationOptions)) {
 					const localSource = getPrebuildResolutionSource(shareSource, shared[key]);
 					return tryResolveFromProjectRoot(localSource) || localSource;
 				}
@@ -11140,6 +10945,360 @@ function isTestEnv() {
 	return process.env.NODE_ENV === "test" || process.env.VITEST != null || process.env.JEST_WORKER_ID != null;
 }
 //#endregion
+//#region src/utils/hostProvidesAllShared.ts
+/** Virtual-module prefix of the host's per-share re-export entries. */
+const SHARE_MODULE_PREFIX = "\0mf-host-provided-share:";
+/** `./a/b` → `a/b`, `.` → `index`: the fixed entry name of an expose, without `.js`. */
+function exposeEntryName(exposeKey) {
+	return exposeKey === "." ? "index" : exposeKey.replace(/^\.\//, "");
+}
+/** Bare specifier a host uses for an expose: `remote` for `.`, `remote/a/b` otherwise. */
+function remoteSpecifier(remoteName, exposeKey) {
+	const entry = exposeEntryName(exposeKey);
+	return entry === "index" ? remoteName : `${remoteName}/${entry}`;
+}
+/** `id` is a remote alias or a subpath of one. */
+function isRemoteSpecifier(id, remoteKeys) {
+	return remoteKeys.some((key) => id === key || id.startsWith(`${key}/`));
+}
+/**
+* The shared key that owns `id`: an exact match, else the longest key `id` is a subpath
+* of (`lodash-es/debounce` → `lodash-es`). Used to spot an unshared subpath of a shared
+* package, which would bundle a private copy of that package into a remote.
+*/
+function sharedKeyOwning(id, sharedKeys) {
+	let owner;
+	for (const key of sharedKeys) {
+		if (id !== key && !id.startsWith(`${key}/`)) continue;
+		if (!owner || key.length > owner.length) owner = key;
+	}
+	return owner;
+}
+/** Chunk name of the host's re-export entry for a shared key. */
+function shareChunkName(key) {
+	return `shared/${key.replace(/^@/, "").replace(/[^\w-]+/g, "-")}`;
+}
+/** Reads a remote's `mf-manifest.json` from a URL or a path relative to `root`. */
+async function readHostProvidesAllSharedManifest(location, root) {
+	let source;
+	if (isAbsoluteUrl(location)) {
+		const response = await fetch(location);
+		if (!response.ok) throw new Error(`Failed to fetch ${location}: ${response.status} ${response.statusText}`);
+		source = await response.text();
+	} else source = await readFile(path$1.resolve(root, location), "utf8");
+	const manifest = JSON.parse(source);
+	if (!manifest.metaData || !Array.isArray(manifest.exposes)) throw new Error(`${location} is not a Module Federation manifest.`);
+	if (manifest.metaData.remoteEntry) throw new Error(`${location} describes a Module Federation runtime remote (it has a remoteEntry). Build the remote with \`experiments: { hostProvidesAllShared: true }\`.`);
+	return manifest;
+}
+/** URL prefix of a remote's files: `metaData.publicPath`, `auto` inferred from the manifest URL. */
+function remotePublicPath(manifest, location) {
+	const publicPath = manifest.metaData.publicPath ?? "auto";
+	if (publicPath !== "auto") return ensureTrailingSlash(publicPath);
+	if (!isAbsoluteUrl(location)) throw new Error(`${location}: publicPath is "auto", which can only be inferred from a manifest URL. Reference the manifest by URL or set \`base\` / \`publicPath\` in the remote build.`);
+	return ensureTrailingSlash(inferAutoPublicPath(location));
+}
+/** Import-map entries (`remote/Expose` → URL) for every expose of every remote. */
+async function collectRemoteImports(remotes, root) {
+	const imports = {};
+	for (const [alias, remote] of Object.entries(remotes)) {
+		const manifest = await readHostProvidesAllSharedManifest(remote.entry, root);
+		const publicPath = remotePublicPath(manifest, remote.entry);
+		for (const expose of manifest.exposes) {
+			const file = expose.assets.js.sync[0];
+			if (!expose.path || !file) continue;
+			imports[remoteSpecifier(alias, expose.path)] = isAbsoluteUrl(remote.entry) ? new URL(file, new URL(publicPath, remote.entry)).href : publicPath + file;
+		}
+	}
+	return imports;
+}
+/** Top-level options that only the Module Federation runtime or `remoteEntry.js` pipeline reads. */
+const IGNORED_OPTIONS = [
+	"filename",
+	"ssrFilename",
+	"varFilename",
+	"library",
+	"runtime",
+	"shareScope",
+	"shareStrategy",
+	"runtimePlugins",
+	"implementation",
+	"getPublicPath",
+	"ignoreOrigin",
+	"virtualModuleDir",
+	"hostInitInjectLocation",
+	"bundleAllCSS",
+	"treeShakingDir",
+	"injectTreeShakingUsedExports",
+	"treeShakingSharedPlugins",
+	"treeShakingSharedExcludePlugins",
+	"moduleParseTimeout",
+	"moduleParseIdleTimeout",
+	"target",
+	"ssrExternals",
+	"ssrEntryLoader",
+	"disableRemote",
+	"disableShared",
+	"disableSnapshot"
+];
+const IGNORED_EXPERIMENTS = [
+	"externalRuntime",
+	"provideExternalRuntime",
+	"ssrMode"
+];
+/** Per-share options: version negotiation, aliasing and fallbacks do not exist in this mode. */
+const IGNORED_SHARE_OPTIONS = [
+	"eager",
+	"requiredVersion",
+	"strictVersion",
+	"import",
+	"request",
+	"shareKey",
+	"name",
+	"version",
+	"shareScope",
+	"treeShaking",
+	"allowNodeModulesSuffixMatch",
+	"suppressMissingImportWarning"
+];
+const isSet = (value) => value !== void 0 && value !== false && !(Array.isArray(value) && value.length === 0);
+/** A single warning naming every option the user set that import-map mode ignores. */
+function getIgnoredOptionWarning(options) {
+	const shared = options.shared;
+	const ignored = [
+		...IGNORED_OPTIONS.filter((key) => isSet(options[key])).map((key) => `\`${key}\``),
+		...IGNORED_EXPERIMENTS.filter((key) => isSet(options.experiments?.[key])).map((key) => `\`experiments.${key}\``),
+		...shared && !Array.isArray(shared) ? Object.entries(shared).flatMap(([key, config]) => typeof config === "object" && config !== null ? IGNORED_SHARE_OPTIONS.filter((option) => option === "import" ? config.import !== void 0 : isSet(config[option])).map((option) => `\`shared.${key}.${option}\``) : []) : []
+	];
+	if (ignored.length === 0) return void 0;
+	return `experiments.hostProvidesAllShared: ${ignored.join(", ")} ignored. The Module Federation runtime is not used and the host provides the only copy of every shared key.`;
+}
+//#endregion
+//#region src/plugins/pluginHostProvidesAllSharedHost.ts
+const ESM_SYNTAX_RE = /(^|[\s;])(export|import)[\s{*]/m;
+const DEFAULT_EXPORT_RE = /export\s+default\b|export\s*\{[^}]*\bas\s+default\b/;
+const IDENTIFIER_RE = /^[A-Za-z_$][\w$]*$/;
+/**
+* Export names of a CommonJS package, read by loading it in Node from the project root
+* (what the bundler's interop exposes as named imports). Empty when it cannot be loaded
+* in Node, e.g. because it touches `window`.
+*/
+function cjsExportNames(key, root) {
+	try {
+		const exported = createRequire(path$1.join(root, "package.json"))(key);
+		return Object.keys(exported ?? {}).filter((name) => name !== "default" && name !== "__esModule" && IDENTIFIER_RE.test(name));
+	} catch {
+		return [];
+	}
+}
+/** Shape of a shared module, sniffed from its real package entry (never a pre-bundle). */
+function detectShareShape(key, entry, root) {
+	const source = entry && fs$1.existsSync(entry) ? fs$1.readFileSync(entry, "utf8") : "";
+	if (source !== "" && !ESM_SYNTAX_RE.test(source)) return {
+		kind: "cjs",
+		names: cjsExportNames(key, root)
+	};
+	return {
+		kind: "esm",
+		hasDefault: DEFAULT_EXPORT_RE.test(source)
+	};
+}
+/**
+* Body of the re-export entry for one shared key. `export *` never forwards `default` and
+* forwards nothing named from CommonJS, so an ESM module adds `default` only when it has
+* one, and a CommonJS module re-exports each key explicitly (`react/jsx-runtime` → `jsx`,
+* `jsxs`) so remotes can `import { jsxs }`.
+*/
+function shareModuleCode(key, shape) {
+	const spec = JSON.stringify(key);
+	if (shape.kind === "cjs") return `import __mf_cjs from ${spec};\nexport default __mf_cjs;\n${shape.names.length ? `export const { ${shape.names.join(", ")} } = __mf_cjs;\n` : ""}`;
+	return `export * from ${spec};\n${shape.hasDefault ? `export { default } from ${spec};\n` : ""}`;
+}
+/** BUILD: shared key → URL of its emitted entry chunk. */
+function bundledShareImports(bundle, base) {
+	const imports = {};
+	for (const chunk of Object.values(bundle)) if (chunk.type === "chunk" && chunk.facadeModuleId?.startsWith("\0mf-host-provided-share:")) imports[chunk.facadeModuleId.slice(24)] = `${base}${chunk.fileName}`;
+	return imports;
+}
+/**
+* DEV: shared key → dev-server URL of its virtual re-export module. Vite serves `\0` ids
+* at `/@id/__x00__<id>`; import analysis then rewrites the module's own `from '<key>'` to
+* the same pre-bundle URL the host's code gets, so host and remotes share one instance.
+*/
+function devShareImports(sharedKeys, base) {
+	const prefix = `${base}@id/__x00__${SHARE_MODULE_PREFIX.slice(1)}`;
+	return Object.fromEntries(sharedKeys.map((key) => [key, `${prefix}${key}`]));
+}
+function importMapTag(imports) {
+	return {
+		tag: "script",
+		attrs: { type: "importmap" },
+		children: JSON.stringify({ imports }, null, 2),
+		injectTo: "head-prepend"
+	};
+}
+/**
+* Host side of `experiments.hostProvidesAllShared`. The host provides every shared key:
+*
+* 1. one re-export module per shared key, emitted in a build as a `preserveSignature:
+*    'strict'` entry chunk that the bundler dedupes with the host's own imports, and served
+*    in dev as a virtual module; either way host and remotes land on one module instance;
+* 2. an import map in `index.html` pointing each shared key at that module and each remote
+*    expose at the entry listed in the remote's `mf-manifest.json`.
+*/
+function pluginHostProvidesAllSharedHost(options) {
+	const sharedKeys = Object.keys(options.shared);
+	const remoteKeys = Object.keys(options.remotes);
+	let isBuild = true;
+	let base = "/";
+	let root = process.cwd();
+	let remoteImports = {};
+	let resolveEntry;
+	return {
+		name: "module-federation:host-provides-all-shared-host",
+		enforce: "pre",
+		configResolved(config) {
+			isBuild = config.command === "build";
+			base = ensureTrailingSlash(config.base);
+			root = config.root;
+			resolveEntry = isBuild ? void 0 : config.createResolver();
+		},
+		async buildStart() {
+			remoteImports = await collectRemoteImports(options.remotes, root);
+			if (!isBuild) return;
+			for (const key of sharedKeys) this.emitFile({
+				type: "chunk",
+				id: `${SHARE_MODULE_PREFIX}${key}`,
+				name: shareChunkName(key),
+				preserveSignature: "strict"
+			});
+		},
+		resolveId(id) {
+			if (id.startsWith("\0mf-host-provided-share:")) return id;
+			if (!isRemoteSpecifier(id, remoteKeys)) return null;
+			return {
+				id: isBuild ? id : remoteImports[id] ?? id,
+				external: true
+			};
+		},
+		async load(id) {
+			if (!id.startsWith("\0mf-host-provided-share:")) return null;
+			const key = id.slice(24);
+			const entry = resolveEntry ? await resolveEntry(key) : (await this.resolve(key, void 0, { skipSelf: true }))?.id;
+			return shareModuleCode(key, detectShareShape(key, entry && stripQueryAndHash(entry), root));
+		},
+		transformIndexHtml: {
+			order: "post",
+			handler(html, context) {
+				const shares = context.bundle ? bundledShareImports(context.bundle, base) : devShareImports(sharedKeys, base);
+				return {
+					html,
+					tags: [importMapTag({
+						...remoteImports,
+						...shares
+					})]
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region src/plugins/pluginHostProvidesAllSharedRemote.ts
+/**
+* Remote side of `experiments.hostProvidesAllShared`. The remote ships only its own code:
+*
+* - one fixed-name, signature-preserving entry per expose (`./Button` → `Button.js`), so
+*   the host can map `<remote>/Button` to a stable URL;
+* - every shared key, and every configured remote, stays an external bare import that the
+*   host's import map resolves at runtime;
+* - a standard `mf-manifest.json` without `remoteEntry`, listing each expose's entry file.
+*/
+function pluginHostProvidesAllSharedRemote(options) {
+	const sharedKeys = Object.keys(options.shared);
+	const remoteKeys = Object.keys(options.remotes);
+	const isExternal = (id) => sharedKeys.includes(id) || isRemoteSpecifier(id, remoteKeys);
+	const unsharedSubpaths = /* @__PURE__ */ new Map();
+	let publicPath = "/";
+	return {
+		name: "module-federation:host-provides-all-shared-remote",
+		enforce: "pre",
+		apply: "build",
+		config(config) {
+			const root = path$1.resolve(config.root ?? process.cwd());
+			return { build: { rollupOptions: {
+				input: Object.fromEntries(Object.entries(options.exposes).map(([key, expose]) => [exposeEntryName(key), path$1.resolve(root, expose.import)])),
+				external: isExternal,
+				preserveEntrySignatures: "strict",
+				output: {
+					entryFileNames: "[name].js",
+					chunkFileNames: "assets/[name]-[hash].js"
+				}
+			} } };
+		},
+		configResolved(config) {
+			publicPath = options.publicPath ?? config.base;
+		},
+		buildStart() {
+			unsharedSubpaths.clear();
+		},
+		resolveId(id, importer) {
+			if (importer && !isExternal(id) && sharedKeyOwning(id, sharedKeys)) unsharedSubpaths.set(id, importer);
+			return null;
+		},
+		buildEnd() {
+			for (const [id, importer] of unsharedSubpaths) this.warn(`"${id}" (imported by ${importer}) is a subpath of a shared package but is not shared itself, so a private copy is bundled into this remote. Add it to \`shared\`.`);
+		},
+		generateBundle(_outputOptions, bundle) {
+			const { name } = options;
+			const exposes = [];
+			for (const key of Object.keys(options.exposes)) {
+				const entryName = exposeEntryName(key);
+				const chunk = Object.values(bundle).find((item) => item.type === "chunk" && item.isEntry && item.name === entryName);
+				if (!chunk) continue;
+				exposes.push({
+					id: `${name}:${entryName}`,
+					name: entryName,
+					path: key,
+					assets: {
+						js: {
+							sync: [chunk.fileName],
+							async: []
+						},
+						css: {
+							sync: [],
+							async: []
+						}
+					}
+				});
+			}
+			const manifest = {
+				id: name,
+				name,
+				metaData: {
+					name,
+					type: "app",
+					buildInfo: {
+						buildVersion: getBuildVersion(),
+						buildName: name
+					},
+					globalName: name,
+					pluginVersion: version$1,
+					publicPath,
+					types: resolveTypesMeta(options.dts)
+				},
+				shared: [],
+				remotes: [],
+				exposes
+			};
+			this.emitFile({
+				type: "asset",
+				fileName: typeof options.manifest === "object" && options.manifest.fileName || "mf-manifest.json",
+				source: `${JSON.stringify(manifest, null, 2)}\n`
+			});
+		}
+	};
+}
+//#endregion
 //#region src/utils/normalizeOptimizeDeps.ts
 var normalizeOptimizeDeps_default = {
 	name: "normalizeOptimizeDeps",
@@ -11475,17 +11634,20 @@ function registerEntryImports(options, projectRoot, recordShared = true, entryFi
 				addUsedRemote(remoteKey, request, options);
 				markStaticRemote(request, options);
 				markPreloadRemote(request, options);
-			} else if (sharedKey && recordShared) addUsedShares(request, options);
+			} else if (sharedKey && recordShared) materializeSharedRequest(options, request);
 			else if (request && !typeOnly) enqueue(request, file, preloadRemotes && isStatic);
 		}
 	}
 	return hasJsxSource;
 }
+function materializeSharedRequest(options, request) {
+	addUsedShares(request, options);
+	const packageName = getPackageName(request);
+	if (packageName !== request && findSharedKey(packageName, options.shared)) addUsedShares(packageName, options);
+}
 function materializeAutomaticJsxRuntime(options, runtime) {
 	if (!findSharedKey(runtime, options.shared)) return false;
-	addUsedShares(runtime, options);
-	const packageName = getPackageName(runtime);
-	if (packageName !== runtime && findSharedKey(packageName, options.shared)) addUsedShares(packageName, options);
+	materializeSharedRequest(options, runtime);
 	return true;
 }
 /**
@@ -11751,9 +11913,21 @@ function applyBuildTimeRuntimeDefines(define, options, { target, isAstro, defaul
 	});
 	if (options.target && define.ENV_TARGET !== JSON.stringify(options.target)) mfWarn(`ENV_TARGET define (${define.ENV_TARGET}) differs from target option ("${options.target}"). ENV_TARGET will not be overridden.`);
 }
+/** Dynamic remote type hints are a runtime plugin; hostProvidesAllShared has no runtime. */
+function withoutDynamicRemoteTypeHints(options) {
+	if (options.dev === false) return options;
+	const dev = options.dev === true || options.dev === void 0 ? {} : options.dev;
+	return {
+		...options,
+		dev: {
+			...dev,
+			disableDynamicRemoteTypeHints: true
+		}
+	};
+}
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-VSLhAx6d.js").then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-DnEX3cp_.js").then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {
@@ -11782,11 +11956,16 @@ function applyExternalRuntimeExperiments(options) {
 function federation(mfUserOptions) {
 	if (isTestEnv()) return [];
 	const options = normalizeModuleFederationOptions(mfUserOptions);
+	if (!options.name) throw createModuleFederationError("name is required");
+	if (options.experiments.hostProvidesAllShared) {
+		const ignored = getIgnoredOptionWarning(mfUserOptions);
+		if (ignored) mfWarn(ignored);
+		return [Object.keys(options.exposes).length > 0 ? pluginHostProvidesAllSharedRemote(options) : pluginHostProvidesAllSharedHost(options), ...loadPluginDts(withoutDynamicRemoteTypeHints(options))];
+	}
 	applyExternalRuntimeExperiments(options);
 	const isVinext = hasPackageDependency("vinext");
-	const { name, shared, filename, hostInitInjectLocation } = options;
+	const { shared, filename, hostInitInjectLocation } = options;
 	const hasTreeShakingShared = Object.values(shared).some((share) => !!share.shareConfig.treeShaking);
-	if (!name) throw createModuleFederationError("name is required");
 	const remoteEntryId = getRemoteEntryId(options);
 	const virtualExposesId = getVirtualExposesId(options);
 	const moduleParseController = createModuleParseController();
@@ -11804,6 +11983,7 @@ function federation(mfUserOptions) {
 	let rootResolveConditions;
 	let ssrResolveConditions;
 	let ssrTarget = "node";
+	let inheritedEnvTarget;
 	const emittedRuntimeCapabilityWarnings = /* @__PURE__ */ new Set();
 	const getLoadHookExportConditions = (context, loadOptions) => {
 		const environment = context.environment;
@@ -12267,14 +12447,24 @@ function federation(mfUserOptions) {
 					config.build ??= {};
 					config.build.target ??= "esnext";
 				}
+				const isBundledDev = Boolean(config.experimental?.bundledDev);
+				if (isRolldown && _command === "serve" && isBundledDev) {
+					config.build.rolldownOptions ??= {};
+					config.build.rolldownOptions.experimental ??= {};
+					const devMode = config.build.rolldownOptions.experimental.devMode;
+					if (typeof devMode === "object") devMode.lazy ??= false;
+					else if (devMode === void 0) config.build.rolldownOptions.experimental.devMode = { lazy: false };
+				}
 				const isAstro = hasPackageDependency("astro");
 				const resolvedTarget = options.target ?? (config.build?.ssr ? "node" : "web");
 				if (!config.define) config.define = {};
+				const userSetEnvTarget = "ENV_TARGET" in config.define;
 				applyBuildTimeRuntimeDefines(config.define, options, {
 					target: resolvedTarget,
 					isAstro,
 					defaultDisableSnapshot: resolvedTarget === "node" ? true : void 0
 				});
+				inheritedEnvTarget = userSetEnvTarget ? void 0 : config.define.ENV_TARGET;
 				for (const warning of getRuntimeCapabilityConfigurationWarnings(options)) {
 					if (emittedRuntimeCapabilityWarnings.has(warning)) continue;
 					emittedRuntimeCapabilityWarnings.add(warning);
@@ -12290,6 +12480,7 @@ function federation(mfUserOptions) {
 				if (!isServerEnvironment(name, config)) return;
 				const isAstro = hasPackageDependency("astro");
 				config.define = { ...config.define ?? {} };
+				if (inheritedEnvTarget !== void 0 && config.define.ENV_TARGET === inheritedEnvTarget) delete config.define.ENV_TARGET;
 				applyBuildTimeRuntimeDefines(config.define, options, {
 					target: options.target ?? "node",
 					isAstro,