@module-federation/vite 1.23.1 → 1.23.3

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 { a as CodeRewriter, c as normalizePathForImport, i as createCodePositionMap, l as rebaseImport, o as createSourceMap, r as mfWarn, t as createModuleFederationError, u as resolveHashPlaceholderFileName } from "./logger--uKHOVjR.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-Bs4FukGL.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-DSTzyKSG.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;
 /**
@@ -279,9 +281,17 @@ function isClientEnvironment(ctx) {
 * the legacy root `build.ssr` flag.
 */
 function isServerBuildContext(ctx, config) {
+	return isServerContext(ctx, Boolean(config?.build?.ssr));
+}
+/**
+* Whether a hook runs for a server graph. Hooks without an environment context
+* (Vite 5) use `legacySsr`, such as the root `build.ssr` flag or the load
+* hook's `ssr` option.
+*/
+function isServerContext(ctx, legacySsr) {
 	const target = resolveEnvironmentConsumerTarget(ctx);
 	if (target) return target === "server";
-	return Boolean(config?.build?.ssr);
+	return legacySsr;
 }
 function resolveRemoteConsumer(ctx, hasMultiEnvironment) {
 	if (!hasMultiEnvironment) return "unified";
@@ -723,13 +733,18 @@ 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) {
-	const strategy = ssrEntryLoader?.strategy;
-	if (strategy !== "temp-file" && strategy !== "vm") return void 0;
-	return { strategy };
+	if (!ssrEntryLoader) return void 0;
+	const normalized = {};
+	if (ssrEntryLoader.strategy === "temp-file" || ssrEntryLoader.strategy === "vm") normalized.strategy = ssrEntryLoader.strategy;
+	if (Number.isFinite(ssrEntryLoader.maxAgeMs)) normalized.maxAgeMs = ssrEntryLoader.maxAgeMs;
+	if (Number.isFinite(ssrEntryLoader.fetchTimeoutMs)) normalized.fetchTimeoutMs = ssrEntryLoader.fetchTimeoutMs;
+	if (Number.isFinite(ssrEntryLoader.fetchMaxBytes)) normalized.fetchMaxBytes = ssrEntryLoader.fetchMaxBytes;
+	return Object.keys(normalized).length > 0 ? normalized : void 0;
 }
 let config;
 let explicitSharedKeys = /* @__PURE__ */ new Set();
@@ -3297,7 +3312,7 @@ function generateEagerWorkspaceSingletonExports(edges, namedExports, importSourc
     __mfApplyEagerShareExportsWhenReady(exportModule);
     export { __mf_default as default };${namedExportLine}${mutableExportLine}`;
 }
-function generateLazyWorkspaceSingletonExports(edges, namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer, serveLocalFallback = false, mutableExports = [], deferredEntryFallback = false) {
+function generateLazyWorkspaceSingletonExports(edges, namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer, serveLocalFallback = false, mutableExports = [], deferredEntryFallback = false, ssrLocalFallback = true) {
 	const copiedExports = namedExports.filter((name) => !mutableExports.includes(name));
 	const namedExportVars = copiedExports.map((_name, i) => `__mf_${i}`);
 	const declarations = namedExports.length > 0 ? ["let __mf_default;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ") : "let __mf_default;";
@@ -3337,7 +3352,7 @@ function generateLazyWorkspaceSingletonExports(edges, namedExports, importSource
             __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});
           });
         })`;
-	const synchronousFallbackConditions = [...deferredEntryFallback ? [] : ["import.meta.env.SSR"], ...serveLocalFallback ? ["(import.meta.env.DEV && typeof __mfLocalShare !== 'undefined')"] : []];
+	const synchronousFallbackConditions = [...ssrLocalFallback ? ["import.meta.env.SSR"] : [], ...serveLocalFallback ? ["(import.meta.env.DEV && typeof __mfLocalShare !== 'undefined')"] : []];
 	const trackPendingLoad = `__mfTrackPendingShareLoad(${deferredEntryFallback ? deferredEntryLoad : deferredInitLoad});`;
 	return `${declarations}
     const __mfApplyLazyShareExports = (mod) => {
@@ -3543,7 +3558,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 		exportLine = generateLazyWorkspaceSingletonExports(edges, namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && !servesRemoteSingletonFallback && (isWorkspaceSingleton || isWorkspacePackage), liveNamedExports);
 	} else if (usesDeferredEntryInjectedSingletonFallback) {
 		importLine = `${getRuntimeInitPromiseBootstrapCode(false, runtimeInitOwnerImportId)}\n    ${importLine}`;
-		exportLine = generateLazyWorkspaceSingletonExports(edges, namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, false, liveNamedExports, true);
+		exportLine = generateLazyWorkspaceSingletonExports(edges, namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, false, liveNamedExports, true, pkg !== REACT_DOM_CLIENT_SHARE);
 	} else if (usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback) exportLine = generateEagerWorkspaceSingletonExports(edges, namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, liveNamedExports);
 	else if (usesDeferredSingletonFallback) {
 		importLine = `${getRuntimeInitPromiseBootstrapCode(false, runtimeInitOwnerImportId)}\n    ${importLine}`;
@@ -3738,16 +3753,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;
@@ -5830,6 +5851,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;
         })();
       }
@@ -6196,9 +6233,23 @@ function getLazyRemotePendingExport() {
 };`;
 }
 function getEagerRemotePendingExport() {
-	return `export const __mf_remote_pending =
+	return `export let __mf_remote_pending =
   __mfRemotePending ??
-  __mfStartRemoteLoad().then(__mfAssignRemoteModule);`;
+  __mfStartRemoteLoad().then(__mfAssignRemoteModule);
+__mf_remote_pending.then(undefined, () => {
+  let attempt;
+  const retry = {
+    then(onFulfilled, onRejected) {
+      attempt ||= __mfStartRemoteLoad().then(__mfAssignRemoteModule, (error) => {
+        attempt = undefined;
+        throw error;
+      });
+      return attempt.then(onFulfilled, onRejected);
+    },
+  };
+  if (__mfRemotePending) __mfRemotePending = retry;
+  __mf_remote_pending = retry;
+});`;
 }
 function getServerThenExport() {
 	return `export function then(onFulfilled, onRejected) {
@@ -6212,7 +6263,15 @@ function getServerThenExport() {
         __moduleExports: exportModule,
         __mf_remote_pending: __mfRemotePending,
       };
-    })
+    }, () => ({
+      get default() {
+        return __mfDefaultExport;
+      },
+      get __moduleExports() {
+        return exportModule;
+      },
+      __mf_remote_pending: { then: (resolve, reject) => __mf_remote_pending.then(resolve, reject) },
+    }))
     .then(onFulfilled, onRejected);
 }`;
 }
@@ -6456,6 +6515,7 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 	let emittedFileName;
 	let skipTransformIds = /* @__PURE__ */ new Set();
 	let injectedTransformIds = /* @__PURE__ */ new Set();
+	const virtualEntryCode = /* @__PURE__ */ new Map();
 	const ignoredHtmlScriptSources = /* @__PURE__ */ new Set();
 	let bootstrapDir = "";
 	function skipSvelteKitSsrBuild() {
@@ -6841,7 +6901,12 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			}
 			if (htmlFilePath) addHtmlScriptEntries(htmlFilePath);
 		},
-		buildStart() {
+		async buildStart() {
+			if (inject === "entry" && waitsForInit && isClientEnvironment(this)) for (const entry of [...entryFiles]) {
+				if (path$1.isAbsolute(entry)) continue;
+				const resolved = await this.resolve(entry, void 0, { skipSelf: true }).catch(() => null);
+				if (resolved && !resolved.external && (_command === "serve" || !resolved.id.startsWith("\0"))) addEntryFile(resolveProjectId(resolved.id));
+			}
 			if (_command === "serve") return;
 			if (skipSvelteKitSsrBuild()) return;
 			if (this.environment?.name === "ssr") return;
@@ -6947,11 +7012,18 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			};
 			setTimeout(retry, 0);
 		},
+		load(id) {
+			return virtualEntryCode.get(id);
+		},
 		transform(code, id) {
 			if (skipSvelteKitSsrBuild()) return;
 			if (viteConfig?.command === "build" && !waitsForInit) return;
 			if (isSvelteKitServerModule(id)) return;
-			if (hasEntryBootstrapParam(id)) return;
+			if (hasEntryBootstrapParam(id)) return {
+				code,
+				map: null,
+				moduleSideEffects: true
+			};
 			if (normalizeModuleId(id).endsWith(".html")) return;
 			const projectId = resolveProjectId(id);
 			if (skipTransformIds.has(projectId)) return;
@@ -6985,7 +7057,11 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 				clientInjected = true;
 				injectedTransformIds.add(projectId);
 				if (!waitsForInit) return mapCodeToCodeWithSourcemap(`import ${JSON.stringify(getEntryPath())};\n` + code);
-				const entrySrc = id.includes("?") ? `${id}&${ENTRY_BOOTSTRAP_QUERY.slice(1)}` : `${id}${ENTRY_BOOTSTRAP_QUERY}`;
+				let entrySrc = id.includes("?") ? `${id}&${ENTRY_BOOTSTRAP_QUERY.slice(1)}` : `${id}${ENTRY_BOOTSTRAP_QUERY}`;
+				if (entrySrc.startsWith("\0")) {
+					virtualEntryCode.set(entrySrc, code);
+					entrySrc = toViteEncodedId(entrySrc.slice(1));
+				}
 				return mapCodeToCodeWithSourcemap(getBootstrapSource(getEntryPath(), entrySrc, false, { skipRemotePreload: _command === "serve" && isNuxtEntryAsyncModule }));
 			}
 		}
@@ -8058,7 +8134,7 @@ function ${helperName}(names) {
 }
 //#endregion
 //#region package.json
-var version$1 = "1.23.1";
+var version$1 = "1.23.3";
 //#endregion
 //#region src/virtualModules/virtualExposesSSR.ts
 /**
@@ -8160,6 +8236,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 }) => {
@@ -8188,7 +8266,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)})
@@ -8525,18 +8602,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;
@@ -8545,8 +8625,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 {}
 			}
@@ -8564,7 +8648,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();
@@ -8640,11 +8724,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: "",
@@ -8769,6 +8854,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 {
@@ -8910,7 +9095,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);
@@ -8919,7 +9104,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);
 				}
@@ -9219,96 +9404,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:
@@ -9522,8 +9617,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;
@@ -9941,7 +10037,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;
 				}
@@ -10441,6 +10537,8 @@ function pluginSSRRemoteEntry(options) {
 			return exposeKeys.every((key) => code.includes(JSON.stringify(key)));
 		})?.fileName;
 	};
+	const isNuxtLike = () => isNuxtProject || isNuxtClientBase(getBasePath$1(viteConfig?.base));
+	const findEmittedExposesChunk = (bundle) => Object.values(bundle).find((file) => file.type === "chunk" && file.facadeModuleId === virtualExposesSSRId)?.fileName;
 	return [{
 		name: "mf:ssr-remote-entry:pre",
 		enforce: "pre",
@@ -10483,7 +10581,7 @@ function pluginSSRRemoteEntry(options) {
 			const base = "/__mf_ssr__";
 			const basePath = getBasePath$1(viteConfig?.base);
 			const ssrEntryFileName = getSsrRemoteEntryFileName(options);
-			if (isNuxtProject || isNuxtClientBase(basePath)) server.middlewares.use((req, _res, next) => {
+			if (isNuxtLike()) server.middlewares.use((req, _res, next) => {
 				if (req.url?.replace(/\?.*/, "") === `${basePath}/${ssrEntryFileName}`) req.url = `${basePath}/__mf_ssr__/${ssrEntryFileName}`;
 				next();
 			});
@@ -10570,16 +10668,26 @@ function pluginSSRRemoteEntry(options) {
 				fileName: ssrOutputFilename,
 				preserveSignature: "strict"
 			});
+			else if (Object.keys(options.exposes).length > 0 && !isNuxtLike()) this.emitFile({
+				type: "chunk",
+				id: virtualExposesSSRId,
+				name: "ssrExposes",
+				preserveSignature: "strict"
+			});
 		},
 		generateBundle: {
 			order: "post",
 			handler(_options, bundle) {
 				const isRolldown = getIsRolldown(this);
 				const environment = this.environment;
-				const exposesChunk = findNuxtExposesChunk(bundle);
+				const exposesChunk = findNuxtExposesChunk(bundle) ?? findEmittedExposesChunk(bundle);
 				if (!isRolldown && isSsrRemoteEntryBuild(environment)) {
 					let source = getSsrRemoteEntrySource();
-					if (exposesChunk) source = source.replace(/import\("virtual:mf-exposes-ssr:[^"]+"\)/g, `import("./${exposesChunk}")`);
+					if (exposesChunk) {
+						let exposesImport = path$1.posix.relative(path$1.posix.dirname(ssrOutputFilename), exposesChunk);
+						if (!exposesImport.startsWith(".")) exposesImport = `./${exposesImport}`;
+						source = source.replace(/import\("virtual:mf-exposes-ssr:[^"]+"\)/g, `import("${exposesImport}")`);
+					}
 					this.emitFile({
 						type: "asset",
 						fileName: ssrOutputFilename,
@@ -10900,6 +11008,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",
@@ -11499,7 +11961,7 @@ export default __mfShared.default ?? __mfShared;`
 				resolveImportPath(ssrEntryLoaderSpecifier);
 				options.runtimePlugins.push([ssrEntryLoaderSpecifier, {
 					resolvedShared,
-					...options.ssrEntryLoader?.strategy ? { strategy: options.ssrEntryLoader.strategy } : {}
+					...options.ssrEntryLoader
 				}]);
 			} catch {}
 		}
@@ -11514,9 +11976,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-DxgS2FEd.js").then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-CVyHPAEq.js").then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {
@@ -11545,11 +12019,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();
@@ -11567,6 +12046,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;
@@ -11660,7 +12140,11 @@ function federation(mfUserOptions) {
 				const virtualModule = VirtualModule.findById(id);
 				if (!virtualModule) return;
 				if (command === "build" && (id.includes("__loadShare__") || id.includes("__loadRemote__"))) return;
-				return virtualModule.code;
+				const code = virtualModule.code;
+				if (code && id.includes("__loadShare__")) {
+					if (isServerContext(this, loadOptions?.ssr === true)) return prependWorkspaceSingletonSsrImport(code);
+				}
+				return code;
 			}
 		},
 		...options.experiments.externalRuntime ? [pluginExternalRuntimeCore()] : [],
@@ -11920,8 +12404,7 @@ function federation(mfUserOptions) {
 					const virtualModule = VirtualModule.findById(id);
 					if (!virtualModule?.code) return null;
 					let code = virtualModule.code;
-					const consumerTarget = resolveEnvironmentConsumerTarget(this);
-					if (consumerTarget === "server" || !consumerTarget && isSsrBuild) {
+					if (isServerContext(this, isSsrBuild)) {
 						const withSsrImport = prependWorkspaceSingletonSsrImport(code);
 						if (withSsrImport !== code) {
 							const pkg = getCachedLoadSharePkg(id);
@@ -12041,11 +12524,13 @@ function federation(mfUserOptions) {
 				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);
@@ -12061,6 +12546,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,