@module-federation/vite 1.23.1 → 1.23.2

package/README.md

@@ -402,6 +402,42 @@ federation({
 `provideExternalRuntime` injects a local runtime plugin that publishes `runtime-core` on `globalThis._FEDERATION_RUNTIME_CORE`. `externalRuntime` rewrites imports of `@module-federation/runtime-core` to read that global. A container that also `exposes` (e.g. a host consumed by its own remotes) may provide the runtime too, as long as exactly one container on the page does and it is loaded before any `externalRuntime` remote evaluates (a second provider is ignored with a `Detect multiple module federation runtime!` warning; a remote evaluated before the provider throws `_FEDERATION_RUNTIME_CORE is missing`).
 The `externalRuntime` rewrite applies to the browser remote graph; SSR remote entries continue to resolve `@module-federation/runtime-core` from Node so they do not depend on the browser global.
 
+## Host provides all shared (`experiments.hostProvidesAllShared`)
+
+For topologies where **one host provides every shared dependency** and remotes only consume them, shared dependencies can be resolved by a native browser [import map](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script/type/importmap) instead of the Module Federation runtime. No `loadShare` / prebuild glue is generated and `eager` is not needed: shared modules are ordinary static ES imports, so code that reads a shared value at module-evaluation time (`class X extends SharedBase`, decorator metadata) just works.
+
+**Remote** (a container with `exposes`):
+
+```ts
+federation({
+  name: "remote",
+  exposes: { "./Button": "./src/Button.tsx" },
+  shared: { react: {}, "react-dom": {}, "react/jsx-runtime": {} },
+  experiments: { hostProvidesAllShared: true },
+});
+```
+
+The remote build emits one fixed-name entry per expose (`./Button` → `Button.js`), keeps every shared key as a bare external import and writes a standard `mf-manifest.json` next to the entries, with no `remoteEntry` since there is no runtime container. `metaData.publicPath` comes from Vite's `base` (or `publicPath`); `auto` is inferred from the manifest URL by the host.
+
+**Host** (no `exposes`):
+
+```ts
+federation({
+  name: "host",
+  remotes: { remote: "https://cdn.example.com/remote/mf-manifest.json" },
+  shared: { react: {}, "react-dom": {}, "react/jsx-runtime": {} },
+  experiments: { hostProvidesAllShared: true },
+});
+```
+
+The host emits one re-export chunk per shared key, which the bundler dedupes with the host's own imports, and injects a `<script type="importmap">` into `index.html` mapping each shared key to that chunk and each remote expose (`remote/Button`) to the entry listed in the manifest. A manifest may also be a path relative to the host root (for example `../remote/dist/mf-manifest.json`). A manifest that has a `remoteEntry` belongs to a Module Federation runtime remote and is rejected. The dev server serves the same map, pointing shared keys at virtual modules that resolve to the host's pre-bundled dependencies, so host and remotes share one instance in dev too.
+
+A remote that imports an unshared subpath of a shared package (`rxjs/operators` with only `rxjs` shared) bundles a private copy of that package's internals; the remote build warns and names the key to add to `shared`.
+
+`dts` keeps working through the manifest's `metaData.types`: a remote emits its types archive next to `mf-manifest.json` and a host referencing the manifest by URL consumes it from there.
+
+Not supported in this mode, since the Module Federation runtime is not loaded: version negotiation and fallbacks, share aliasing (`request` / `shareKey`), `import: false`, runtime plugins, SSR, tree-shaking artifacts, `loadRemote` / runtime-registered remotes, and interop with webpack / rspack containers. Options that only the runtime or `remoteEntry.js` pipeline reads (for example `filename`, `shareStrategy`, `runtimePlugins`, `eager`, `requiredVersion`) are ignored; one warning names them. `singleton` needs no setting: every shared key has exactly one instance. The import map is fixed when the host is built, so a remote must keep its expose entry names stable across deploys. The inline import map changes with every host build; a strict CSP needs a nonce or hash for it.
+
 ## ⚠️ `codeSplitting` is managed by the plugin
 
 Do not set `build.rollupOptions.output.codeSplitting` or

package/lib/{dtsConstants-Bs4FukGL.js → dtsConstants-r5OfegUr.js}

@@ -1,5 +1,5 @@
 import { d as getNodeModulesSuffix, r as getSharedRuntimeKey } from "./sharedKeyMatcher-Od_nYxJA.js";
-import { r as mfWarn, t as createModuleFederationError } from "./logger--uKHOVjR.js";
+import { r as mfWarn, t as createModuleFederationError } from "./logger-DOwfTlw5.js";
 import { existsSync, readFileSync, readdirSync, realpathSync } from "fs";
 import { createRequire } from "module";
 import * as path$1 from "node:path";

package/lib/index.d.ts

@@ -167,6 +167,23 @@ interface PluginExperimentsOptions {
   provideExternalRuntime?: boolean;
   /** Generate the React SSR/hydration island capability for eligible exposes. */
   ssrMode?: 'ISLAND';
+  /**
+   * The host provides every shared dependency; remotes bring none. Shared keys
+   * are resolved by a native browser import map instead of the Module
+   * Federation runtime: the host emits one entry chunk per shared key and
+   * injects `<script type="importmap">`, remotes keep shared imports as bare
+   * specifiers and emit one fixed-name entry per expose plus a standard
+   * `mf-manifest.json` (without `remoteEntry`) the host maps from.
+   *
+   * Shared modules become ordinary static ES imports, so there is no
+   * `loadShare` glue and no `eager` is needed for code that reads a shared
+   * value at module-evaluation time. There is no version negotiation and no
+   * runtime API: `requiredVersion`, `strictVersion`, `shareStrategy`,
+   * `runtimePlugins` and `manifest` are ignored.
+   *
+   * @see https://github.com/module-federation/vite/issues/1381
+   */
+  hostProvidesAllShared?: boolean;
 }
 type SsrEntryLoaderStrategy = 'temp-file' | 'vm';
 type SsrEntryLoaderConfig = {

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-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;
 /**
@@ -723,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) {
@@ -3738,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;
@@ -5830,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;
         })();
       }
@@ -8058,7 +8083,7 @@ function ${helperName}(names) {
 }
 //#endregion
 //#region package.json
-var version$1 = "1.23.1";
+var version$1 = "1.23.2";
 //#endregion
 //#region src/virtualModules/virtualExposesSSR.ts
 /**
@@ -8160,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 }) => {
@@ -8188,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)})
@@ -8525,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;
@@ -8545,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 {}
 			}
@@ -8564,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();
@@ -8640,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: "",
@@ -8769,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 {
@@ -8910,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);
@@ -8919,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);
 				}
@@ -9219,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:
@@ -9522,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;
@@ -9941,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;
 				}
@@ -10900,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",
@@ -11514,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-DxgS2FEd.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) {
@@ -11545,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();
@@ -11567,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;
@@ -12041,11 +12458,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 +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,

package/lib/{logger--uKHOVjR.js → logger-DOwfTlw5.js}

@@ -363,4 +363,4 @@ const moduleFederationConsole = {
 const mfWarn = moduleFederationConsole.warn;
 const mfError = moduleFederationConsole.error;
 //#endregion
-export { CodeRewriter as a, normalizePathForImport as c, createCodePositionMap as i, rebaseImport as l, mfError as n, createSourceMap as o, mfWarn as r, EXTERNAL_URL_RE as s, createModuleFederationError as t, resolveHashPlaceholderFileName as u };
+export { CodeRewriter as a, isAbsoluteUrl as c, resolveHashPlaceholderFileName as d, createCodePositionMap as i, normalizePathForImport as l, mfError as n, createSourceMap as o, mfWarn as r, EXTERNAL_URL_RE as s, createModuleFederationError as t, rebaseImport as u };

package/lib/{pluginDts-DxgS2FEd.js → pluginDts-DnEX3cp_.js}

@@ -1,9 +1,9 @@
-import { c as normalizePathForImport, n as mfError, t as createModuleFederationError } from "./logger--uKHOVjR.js";
-import { g as resolveImportPath, u as hasPackageDependency } from "./dtsConstants-Bs4FukGL.js";
+import { l as normalizePathForImport, n as mfError, t as createModuleFederationError } from "./logger-DOwfTlw5.js";
+import { g as resolveImportPath, u as hasPackageDependency } from "./dtsConstants-r5OfegUr.js";
 import fs from "fs";
 import * as path$1 from "node:path";
-import os from "os";
 import { normalizeOptions } from "@module-federation/sdk";
+import os from "os";
 import { consumeTypesAPI, generateTypesAPI, isTSProject, normalizeConsumeTypesOptions, normalizeDtsOptions, normalizeGenerateTypesOptions } from "@module-federation/dts-plugin";
 import { rpc } from "@module-federation/dts-plugin/core";
 //#region src/plugins/pluginDts.ts

package/lib/{ssrEntryLoader-DmqLXUmm.js → ssrEntryLoader-DEH3eV1e.js}

@@ -1,4 +1,4 @@
-import { a as CodeRewriter, i as createCodePositionMap, r as mfWarn, s as EXTERNAL_URL_RE } from "./logger--uKHOVjR.js";
+import { a as CodeRewriter, i as createCodePositionMap, r as mfWarn, s as EXTERNAL_URL_RE } from "./logger-DOwfTlw5.js";
 //#region src/utils/fetchWithTimeout.ts
 const DEFAULT_SSR_FETCH_TIMEOUT_MS = 1e4;
 const DEFAULT_SSR_FETCH_MAX_BYTES = 10 * 1024 * 1024;
@@ -483,25 +483,30 @@ async function getSSREntry(remoteEntryUrl, maxAgeMs, fetchTimeoutMs, fetchMaxByt
 	return record.promise;
 }
 /**
-* Drop per-remote temp-file caches after a version change so old artifacts stop
-* being reused. Temp-file cache keys hold SSR entry/chunk URLs (not the
-* browser entry URL), so scope the invalidation by origin.
+* Drop a remote graph's temp-file caches after a version change so old
+* artifacts stop being reused. A generated module can be shared by multiple
+* remote graphs, so cleanup is scoped by graph owner rather than URL origin.
 */
 function dropRemoteTempFileCaches(remoteEntryUrl) {
-	const origin = getUrlOrigin(remoteEntryUrl);
-	if (!origin) return;
-	const staleRecords = [...tempFileRecords.values()].filter((record) => record.remoteOrigin === origin);
-	for (const [key] of tempFileCache) if (JSON.parse(key).find((part) => typeof part === "string" && /^https?:\/\//.test(part))?.startsWith(origin)) {
+	const staleRecords = [];
+	for (const [key, record] of tempFileRecords) {
+		if (!record.owners.delete(remoteEntryUrl) || record.owners.size > 0) continue;
 		tempFileCache.delete(key);
 		tempFilePathCache.delete(key);
+		staleRecords.push(record);
 	}
 	scheduleTempFileCleanup(staleRecords);
 }
-/** Invalidate all SSR loader caches owned by a remote. */
-async function invalidateRemoteCaches(remoteEntryUrl) {
+/**
+* Invalidate all SSR loader caches owned by a remote. The runtime loading map
+* is cleared synchronously so `revalidate()` can safely clear module caches
+* immediately after invoking this function.
+*/
+function invalidateRemoteCaches(remoteEntryUrl) {
+	invalidateRuntimeRemoteEntry(remoteEntryUrl);
 	dropRemoteTempFileCaches(remoteEntryUrl);
 	scheduleVmCacheCleanup(remoteEntryUrl);
-	await clearRunnerCaches(remoteEntryUrl);
+	return clearRunnerCaches(remoteEntryUrl);
 }
 /**
 * The VM strategy owns separate in-memory module-graph caches. Keep their
@@ -512,6 +517,12 @@ function scheduleVmCacheCleanup(remoteEntryUrl) {
 	if (!vmStrategyModulePromise) return;
 	vmStrategyModulePromise.then(({ clearVmStrategyCaches }) => clearVmStrategyCaches(remoteEntryUrl)).catch(() => {});
 }
+/**
+* A dev-mode ModuleRunner is created per origin (one Vite dev server) and is
+* shared by every remote that server hosts, so its module cache can only be
+* cleared as a whole. Origin scoping is therefore the finest granularity here;
+* clearing only costs a re-evaluation, no generated files are removed.
+*/
 async function clearRunnerCaches(remoteEntryUrl) {
 	let remoteOrigin;
 	if (remoteEntryUrl) {
@@ -526,7 +537,9 @@ async function clearRunnerCaches(remoteEntryUrl) {
 }
 /** Invalidate all SSR loader caches across every remote. */
 function invalidateAllRemoteCaches() {
+	invalidateRuntimeRemoteEntry();
 	const staleRecords = [...tempFileRecords.values()];
+	for (const record of staleRecords) record.owners.clear();
 	tempFileCache.clear();
 	tempFilePathCache.clear();
 	scheduleTempFileCleanup(staleRecords);
@@ -534,6 +547,17 @@ function invalidateAllRemoteCaches() {
 	clearRunnerCaches();
 }
 /**
+* runtime-core deduplicates remote entry loads in a process-global map. The
+* SSR loader's module cache invalidation must evict the matching runtime entry
+* too, otherwise the next loadRemote() returns the pre-revalidation container
+* without invoking this loader again.
+*/
+function invalidateRuntimeRemoteEntry(remoteEntryUrl) {
+	const globalLoading = globalThis.__GLOBAL_LOADING_REMOTE_ENTRY__;
+	if (!globalLoading) return;
+	for (const key of Object.keys(globalLoading)) if (remoteEntryUrl === void 0 || key === remoteEntryUrl || key.endsWith(`:${remoteEntryUrl}`)) delete globalLoading[key];
+}
+/**
 * Drop the loader's caches so the next `loadEntry` re-resolves and re-fetches
 * remote SSR entries. Pass a remote entry URL to scope the invalidation to one
 * remote; call with no arguments to invalidate everything.
@@ -579,6 +603,7 @@ function scheduleTempFileCleanup(records) {
 async function cleanupTempFileRecord(record) {
 	try {
 		await record.promise.catch(() => void 0);
+		if (record.owners.size > 0) return;
 		if (tempFileRecords.get(record.cacheKey) !== record) return;
 		const filePath = await record.filePathPromise;
 		const { rmSync } = await _fs();
@@ -733,7 +758,7 @@ function getTempFileImportUrl(filePath, versionKey) {
 * a remote redeploy (new manifest → new key) produces new files and bypasses
 * Node's ESM module cache instead of serving the stale build.
 */
-async function fetchEsmToTempFile(url, tmpDir, visited, pending, sharedPkgMap, versionKey = UNVERSIONED, fetchTimeoutMs = DEFAULT_SSR_FETCH_TIMEOUT_MS, contextKey = "default", fetchMaxBytes = DEFAULT_SSR_FETCH_MAX_BYTES, extension = ".mjs") {
+async function fetchEsmToTempFile(url, tmpDir, visited, pending, sharedPkgMap, versionKey = UNVERSIONED, fetchTimeoutMs = DEFAULT_SSR_FETCH_TIMEOUT_MS, contextKey = "default", fetchMaxBytes = DEFAULT_SSR_FETCH_MAX_BYTES, extension = ".mjs", owner) {
 	const cacheKey = JSON.stringify([
 		fetchTimeoutMs,
 		fetchMaxBytes,
@@ -745,6 +770,7 @@ async function fetchEsmToTempFile(url, tmpDir, visited, pending, sharedPkgMap, v
 	if (visited.has(url)) return visited.get(url);
 	const cached = tempFileCache.get(cacheKey);
 	if (cached) {
+		if (owner) tempFileRecords.get(cacheKey)?.owners.add(owner);
 		pending.add(cached);
 		const reserved = tempFilePathCache.get(cacheKey);
 		const tmpFile = reserved ? await reserved : await cached;
@@ -768,7 +794,7 @@ async function fetchEsmToTempFile(url, tmpDir, visited, pending, sharedPkgMap, v
 		const relImports = specifiers.map(({ value }) => value).filter((value) => isRelativeSpecifier(value) && !isVitePreloadHelperSpecifier(value)).map((value) => new URL(value, base).href);
 		const subMap = /* @__PURE__ */ new Map();
 		await Promise.all([...new Set(relImports)].filter((u) => u.startsWith("http://") || u.startsWith("https://")).map(async (u) => {
-			const tmpPath = await fetchEsmToTempFile(u, tmpDir, visited, pending, sharedPkgMap, versionKey, fetchTimeoutMs, contextKey, fetchMaxBytes, extension);
+			const tmpPath = await fetchEsmToTempFile(u, tmpDir, visited, pending, sharedPkgMap, versionKey, fetchTimeoutMs, contextKey, fetchMaxBytes, extension, owner);
 			subMap.set(u, getTempFileImportUrl(tmpPath, versionKey));
 		}));
 		const requireShimUrl = sharedPkgMap?.size && specifiers.some(({ value }) => isNodeModuleSpecifier(value)) ? await getRequireShimUrl(tmpDir, sharedPkgMap, contextKey) : void 0;
@@ -781,7 +807,7 @@ async function fetchEsmToTempFile(url, tmpDir, visited, pending, sharedPkgMap, v
 		cacheKey,
 		filePathPromise: tmpFilePromise,
 		promise,
-		remoteOrigin: getUrlOrigin(url)
+		owners: owner ? /* @__PURE__ */ new Set([owner]) : /* @__PURE__ */ new Set()
 	};
 	tempFileRecords.set(cacheKey, record);
 	tempFileCache.set(cacheKey, promise);
@@ -793,9 +819,9 @@ async function fetchEsmToTempFile(url, tmpDir, visited, pending, sharedPkgMap, v
 	});
 	return promise;
 }
-async function fetchEsmGraphToTempFile(url, tmpDir, sharedPkgMap, versionKey = UNVERSIONED, fetchTimeoutMs = DEFAULT_SSR_FETCH_TIMEOUT_MS, contextKey = "default", fetchMaxBytes = DEFAULT_SSR_FETCH_MAX_BYTES, extension = ".mjs") {
+async function fetchEsmGraphToTempFile(url, tmpDir, sharedPkgMap, versionKey = UNVERSIONED, fetchTimeoutMs = DEFAULT_SSR_FETCH_TIMEOUT_MS, contextKey = "default", fetchMaxBytes = DEFAULT_SSR_FETCH_MAX_BYTES, extension = ".mjs", owner) {
 	const pending = /* @__PURE__ */ new Set();
-	const rootFile = await fetchEsmToTempFile(url, tmpDir, /* @__PURE__ */ new Map(), pending, sharedPkgMap, versionKey, fetchTimeoutMs, contextKey, fetchMaxBytes, extension);
+	const rootFile = await fetchEsmToTempFile(url, tmpDir, /* @__PURE__ */ new Map(), pending, sharedPkgMap, versionKey, fetchTimeoutMs, contextKey, fetchMaxBytes, extension, owner);
 	await Promise.all(pending);
 	return rootFile;
 }
@@ -808,7 +834,7 @@ async function importTempModule(filePath, versionKey) {
 let warnedVmUnavailable = false;
 let vmStrategyModulePromise;
 function getVmStrategyModule() {
-	if (!vmStrategyModulePromise) vmStrategyModulePromise = import("./ssrVmStrategy-B_e3yqa2.js");
+	if (!vmStrategyModulePromise) vmStrategyModulePromise = import("./ssrVmStrategy-COMHOCN2.js");
 	return vmStrategyModulePromise;
 }
 /**
@@ -819,7 +845,7 @@ function getVmStrategyModule() {
 function warnStrategyFallback(strategy, url, fallback, error) {
 	mfWarn(`SSR entry loader: strategy "${strategy}" failed to load ${url}; falling back to ${fallback}.`, error);
 }
-async function tryVmStrategy(ssrEntry, options) {
+async function tryVmStrategy(ssrEntry, options, rootEntryUrl) {
 	const { loadViaVmStrategy, isVmStrategyAvailable } = await getVmStrategyModule();
 	if (!await isVmStrategyAvailable()) {
 		if (!warnedVmUnavailable) {
@@ -835,10 +861,11 @@ async function tryVmStrategy(ssrEntry, options) {
 		fetchTimeoutMs: options.fetchTimeoutMs,
 		fetchMaxBytes: options.fetchMaxBytes,
 		cacheContext: options.cacheContext,
-		federationInstance: options.federationInstance
+		federationInstance: options.federationInstance,
+		rootEntryUrl
 	});
 }
-async function loadSSRRemoteEntry(ssrEntry, options) {
+async function loadSSRRemoteEntry(ssrEntry, options, rootEntryUrl) {
 	const { url, type, versionKey } = ssrEntry;
 	const { resolvedShared } = options;
 	if (type === "commonjs-module" || type === "commonjs") {
@@ -865,7 +892,7 @@ async function loadSSRRemoteEntry(ssrEntry, options) {
 			}
 		}
 		if (options.strategy === "vm") try {
-			const fromVm = await tryVmStrategy(ssrEntry, options);
+			const fromVm = await tryVmStrategy(ssrEntry, options, rootEntryUrl);
 			if (fromVm) return fromVm;
 		} catch (error) {
 			if (isSsrEntryHttpError(error) || isSsrFetchBodyTooLargeError(error)) throw error;
@@ -877,7 +904,7 @@ async function loadSSRRemoteEntry(ssrEntry, options) {
 		const sharedPkgMap = new Map(Object.entries(resolvedShared));
 		const extension = type === "commonjs-module" || type === "commonjs" ? ".js" : ".mjs";
 		try {
-			return await importTempModule(await fetchEsmGraphToTempFile(url, cacheDir, sharedPkgMap, versionKey, options.fetchTimeoutMs, getSsrTransformContextKey(resolvedShared, options.shareScopeName), options.fetchMaxBytes, extension), versionKey);
+			return await importTempModule(await fetchEsmGraphToTempFile(url, cacheDir, sharedPkgMap, versionKey, options.fetchTimeoutMs, getSsrTransformContextKey(resolvedShared, options.shareScopeName), options.fetchMaxBytes, extension, rootEntryUrl), versionKey);
 		} catch (error) {
 			if (isSsrEntryHttpError(error) || isSsrFetchBodyTooLargeError(error)) throw error;
 			warnStrategyFallback("temp-file", url, "the federation runtime's loader", error);
@@ -914,11 +941,11 @@ function ssrEntryLoaderPlugin(options = {}) {
 			} : resolved;
 			const ssrEntry = await getSSREntry(remoteInfo.entry, loadOptions.maxAgeMs, loadOptions.fetchTimeoutMs, loadOptions.fetchMaxBytes);
 			if (!ssrEntry) return;
-			const mod = await loadSSRRemoteEntry(ssrEntry, loadOptions);
+			const mod = await loadSSRRemoteEntry(ssrEntry, loadOptions, remoteInfo.entry);
 			if (!mod) return;
 			return mod;
 		}
 	};
 }
 //#endregion
-export { getUrlOrigin as a, fetchWithTimeout as c, ssrEntryLoaderPlugin as i, readResponseTextBounded as l, neutralizeBrowserPreloadHelpers as n, DEFAULT_SSR_FETCH_MAX_BYTES as o, revalidate as r, DEFAULT_SSR_FETCH_TIMEOUT_MS as s, SsrEntryHttpError as t };
+export { DEFAULT_SSR_FETCH_MAX_BYTES as a, readResponseTextBounded as c, ssrEntryLoaderPlugin as i, neutralizeBrowserPreloadHelpers as n, DEFAULT_SSR_FETCH_TIMEOUT_MS as o, revalidate as r, fetchWithTimeout as s, SsrEntryHttpError as t };

package/lib/{ssrVmStrategy-B_e3yqa2.js → ssrVmStrategy-COMHOCN2.js}

@@ -1,5 +1,5 @@
 import { t as findSharedKey } from "./sharedKeyMatcher-Od_nYxJA.js";
-import { a as getUrlOrigin, c as fetchWithTimeout, l as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, t as SsrEntryHttpError } from "./ssrEntryLoader-DmqLXUmm.js";
+import { c as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, s as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-DEH3eV1e.js";
 //#region src/utils/ssrVmStrategy.ts
 /**
 * vm.SourceTextModule strategy for loading remote SSR entries.
@@ -144,30 +144,24 @@ function addVmCacheOwner(ownersByCacheKey, cacheKey, rootEntryUrl) {
 	owners.add(rootEntryUrl);
 	ownersByCacheKey.set(cacheKey, owners);
 }
-function clearOwnedVmCache(cache, ownersByCacheKey, remoteOrigin) {
+function clearOwnedVmCache(cache, ownersByCacheKey, remoteEntryUrl) {
 	for (const [cacheKey, owners] of ownersByCacheKey) {
-		if (!remoteOrigin) {
-			cache.delete(cacheKey);
-			ownersByCacheKey.delete(cacheKey);
-			continue;
-		}
-		for (const owner of owners) if (getUrlOrigin(owner) === remoteOrigin) owners.delete(owner);
-		if (owners.size === 0) {
-			cache.delete(cacheKey);
-			ownersByCacheKey.delete(cacheKey);
-		}
+		if (remoteEntryUrl !== void 0 && !owners.delete(remoteEntryUrl)) continue;
+		if (remoteEntryUrl !== void 0 && owners.size > 0) continue;
+		cache.delete(cacheKey);
+		ownersByCacheKey.delete(cacheKey);
 	}
 }
 /**
 * Drop cached VM module graphs after a remote revalidation. A module graph can
-* contain URLs from another origin, so ownership is tracked by the root entry
-* rather than inferred from each module URL.
+* contain URLs from another origin, and one origin can serve several remotes,
+* so ownership is tracked by the owning remote entry URL rather than inferred
+* from each module URL. A module shared by several graphs stays cached while
+* another remote still owns it.
 */
 function clearVmStrategyCaches(remoteEntryUrl) {
-	const remoteOrigin = remoteEntryUrl === void 0 ? void 0 : getUrlOrigin(remoteEntryUrl);
-	if (remoteEntryUrl !== void 0 && !remoteOrigin) return;
-	clearOwnedVmCache(httpModuleCache, httpModuleCacheOwners, remoteOrigin);
-	clearOwnedVmCache(namespaceCache, namespaceCacheOwners, remoteOrigin);
+	clearOwnedVmCache(httpModuleCache, httpModuleCacheOwners, remoteEntryUrl);
+	clearOwnedVmCache(namespaceCache, namespaceCacheOwners, remoteEntryUrl);
 }
 function getBodyPreview(body) {
 	return body.slice(0, 240).replace(/\s+/g, " ").trim();
@@ -243,12 +237,13 @@ async function importDynamically(vm, specifier, referencingModule, options) {
 async function loadViaVmStrategy(entryUrl, options) {
 	const vm = await getVmApi();
 	if (!vm) return null;
+	const rootEntryUrl = options.rootEntryUrl ?? entryUrl;
 	const graphOptions = {
 		...options,
-		rootEntryUrl: entryUrl
+		rootEntryUrl
 	};
 	const cacheKey = `${getVmCacheContextKey(options)}::${options.versionKey}::${entryUrl}`;
-	addVmCacheOwner(namespaceCacheOwners, cacheKey, entryUrl);
+	addVmCacheOwner(namespaceCacheOwners, cacheKey, rootEntryUrl);
 	if (!namespaceCache.has(cacheKey)) namespaceCache.set(cacheKey, (async () => {
 		const entryModule = await getHttpModule(vm, entryUrl, graphOptions);
 		const linker = (specifier, referencingModule) => linkModule(vm, specifier, referencingModule, graphOptions);

package/lib/utils/ssrEntryLoader.js

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

package/package.json

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