@module-federation/vite 1.21.5 → 1.21.6

package/lib/{buildPaths-BkaQHrd2.js → buildPaths-BoaQTkxt.js}

@@ -43,5 +43,24 @@ function isAbsoluteUrl(src) {
 	if (/^[a-z]:[\\/]/i.test(src)) return false;
 	return EXTERNAL_URL_RE.test(src);
 }
+const HASH_PLACEHOLDER_RE = /(?:[._-]?\[hash(?::\d+)?\])/g;
+function hasFileExtension(fileName) {
+	return fileName.slice(Math.max(fileName.lastIndexOf("/"), fileName.lastIndexOf("\\")) + 1).lastIndexOf(".") > 0;
+}
+/**
+* Resolve a bundler `filename` template that still contains `[hash]` placeholders
+* into the concrete, stable file name Module Federation serves.
+*
+* The federation entries are emitted by us rather than hashed by the bundler, so
+* the placeholder is dropped instead of being substituted. When stripping it also
+* removes the extension (`mf-[hash:8]` → `mf`), `.js` is appended so the result
+* stays a loadable module. The extension check deliberately looks at the basename
+* only — a dotted directory (`assets/v1.2/entry`) must not be mistaken for one.
+*/
+function resolveHashPlaceholderFileName(fileName) {
+	if (!fileName.includes("[hash")) return fileName;
+	const normalized = fileName.replace(HASH_PLACEHOLDER_RE, "");
+	return hasFileExtension(normalized) ? normalized : `${normalized}.js`;
+}
 //#endregion
-export { normalizePathForImport as n, rebaseImport as r, EXTERNAL_URL_RE as t };
+export { resolveHashPlaceholderFileName as i, normalizePathForImport as n, rebaseImport as r, EXTERNAL_URL_RE as t };

package/lib/index.js

@@ -1,4 +1,4 @@
-import { n as normalizePathForImport, r as rebaseImport } from "./buildPaths-BkaQHrd2.js";
+import { i as resolveHashPlaceholderFileName, n as normalizePathForImport, r as rebaseImport } from "./buildPaths-BoaQTkxt.js";
 import { a as getPackageDetectionCwd, c as getSharedCacheDescriptor, d as packageNameDecode, f as packageNameEncode, g as createModuleFederationError, h as sharedCacheHelperCode, i as getIsRolldown, l as hasPackageDependency, m as setPackageDetectionCwd, n as getInstalledPackageEntry, o as getPackageName, p as resolveImportPath, r as getInstalledPackageJson, s as getPackageNameFromNodeModulePath, u as isNuxtProjectRoot, v as mfWarn } from "./dtsConstants-BsaLBaaK.js";
 import { a as filterId, c as getCommonSharedSubpaths, d as isNodeModulePath, f as isNuxtClientBase, h as resolvePublicPath, i as ensureTrailingSlash, l as getMatchingNodeModuleSubpath, m as normalizeNodeModulePath, n as invalidateSharedKeyMatcher, o as getBasePath$1, p as isViteOptimizableEntry, r as matchesSharedSource, s as getCommonSharedSubpathFromNodeModulePath, t as findSharedKey, u as isAssetLikeImport } from "./sharedKeyMatcher-DiUzRVH1.js";
 import { createRequire } from "node:module";
@@ -14,13 +14,23 @@ import * as fs$1 from "node:fs";
 import { existsSync as existsSync$1, readFileSync as readFileSync$1 } from "node:fs";
 import { pathToFileURL as pathToFileURL$1 } from "node:url";
 import { isIPv6 } from "node:net";
+//#region src/utils/regexEscape.ts
+const REGEXP_SPECIAL_CHARS_RE = /[.*+?^${}()|[\]\\]/g;
+/**
+* Escape `value` so it matches literally when interpolated into a regex source.
+*
+* Federation interpolates user-controlled strings — package names, chunk file
+* names, virtual module ids — into generated matchers. Those routinely contain
+* `.`, `+`, `[` and `\`, which would otherwise change what the pattern matches.
+*/
+function escapeRegExp(value) {
+	return value.replace(REGEXP_SPECIAL_CHARS_RE, "\\$&");
+}
+//#endregion
 //#region src/utils/bundleHelpers.ts
 function isOutputChunk$1(chunk) {
 	return chunk.type === "chunk";
 }
-function escapeRegExp$2(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 /**
 * Whether `code` references `name` as a whole identifier.
 *
@@ -30,7 +40,7 @@ function escapeRegExp$2(value) {
 * as "unused", which orphans a still-referenced import.
 */
 function isIdentifierReferenced(name, code) {
-	return new RegExp(`(?<![$\\w])${escapeRegExp$2(name)}(?![$\\w])`).test(code);
+	return new RegExp(`(?<![$\\w])${escapeRegExp(name)}(?![$\\w])`).test(code);
 }
 function getProxyBaseName(fileName) {
 	return fileName.replace(/^.*\//, "").replace(/\.js$/, "").replace(/-[A-Za-z0-9_-]+$/, "");
@@ -40,10 +50,10 @@ function getProxyBaseName(fileName) {
 * regex end-anchor, so the pattern would silently match nothing.
 */
 function functionDeclarationRegExp(name) {
-	return new RegExp(`function\\s+${escapeRegExp$2(name)}\\s*\\(`);
+	return new RegExp(`function\\s+${escapeRegExp(name)}\\s*\\(`);
 }
 function extractFunctionDeclaration(code, functionName) {
-	const funcRe = new RegExp(`function\\s+${escapeRegExp$2(functionName)}\\s*\\([^)]*\\)\\s*\\{`);
+	const funcRe = new RegExp(`function\\s+${escapeRegExp(functionName)}\\s*\\([^)]*\\)\\s*\\{`);
 	const funcStart = code.search(funcRe);
 	if (funcStart < 0) return;
 	let depth = 0;
@@ -127,7 +137,7 @@ function rewriteEsmProxyConsumers(code, proxyChunks) {
 	const claimedLocals = /* @__PURE__ */ new Set();
 	for (const [proxyFileName, proxyInfo] of Array.from(proxyChunks.entries())) {
 		const proxyBaseName = getProxyBaseName(proxyFileName);
-		const importMatch = new RegExp(`import\\s*\\{([^}]+)\\}\\s*from\\s*["']([^"']*${escapeRegExp$2(proxyBaseName)}[^"']*)["']\\s*;?`).exec(nextCode);
+		const importMatch = new RegExp(`import\\s*\\{([^}]+)\\}\\s*from\\s*["']([^"']*${escapeRegExp(proxyBaseName)}[^"']*)["']\\s*;?`).exec(nextCode);
 		if (!importMatch) continue;
 		const fullImport = importMatch[0];
 		const bindings = importMatch[1].split(",").map((s) => {
@@ -184,7 +194,7 @@ function rewriteSystemProxyConsumers(code, systemProxyInfo) {
 	let nextCode = code;
 	for (const [proxyFileName, proxyInfo] of Array.from(systemProxyInfo.entries())) {
 		const proxyBaseName = getProxyBaseName(proxyFileName);
-		const depMatch = new RegExp(`["']([^"']*${escapeRegExp$2(proxyBaseName)}[^"']*)["']`).exec(nextCode);
+		const depMatch = new RegExp(`["']([^"']*${escapeRegExp(proxyBaseName)}[^"']*)["']`).exec(nextCode);
 		if (!depMatch) continue;
 		let setterIndex = 0;
 		const depListMatch = nextCode.match(/System\.register\(\[([\s\S]*?)\]/);
@@ -940,7 +950,7 @@ function normalizeModuleFederationOptions(options) {
 		disableSnapshot: options.disableSnapshot,
 		experiments: normalizeExperiments(options.experiments)
 	};
-	if (normalized.experiments.ssrMode === "ISLAND" && Object.prototype.hasOwnProperty.call(normalized.shared, "react")) mfWarn("Island expose generation is disabled because experiments.ssrMode is \"ISLAND\" and React is configured as shared. Remove \"react\" from shared to generate island exposes, or remove ssrMode to use standard shared rendering.");
+	if (normalized.experiments.ssrMode === "ISLAND" && Object.hasOwn(normalized.shared, "react")) mfWarn("Island expose generation is disabled because experiments.ssrMode is \"ISLAND\" and React is configured as shared. Remove \"react\" from shared to generate island exposes, or remove ssrMode to use standard shared rendering.");
 	explicitSharedKeysByOptions.set(normalized, new Set(explicitSharedKeys));
 	return config = normalized;
 }
@@ -958,11 +968,8 @@ const idCacheMap = {};
 const VITE_ID_PREFIX = "/@id/";
 const VITE_ENCODED_NULL_BYTE_PREFIX = `${VITE_ID_PREFIX}__x00__`;
 const MF_OWNER_INFIX = "__mf_owner__";
-function escapeRegExp$1(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function createViteEncodedIdPrefixRegExp(sourcePrefix = "") {
-	return new RegExp(`^(?:${escapeRegExp$1(VITE_ENCODED_NULL_BYTE_PREFIX)})?${sourcePrefix}`);
+	return new RegExp(`^(?:${escapeRegExp(VITE_ENCODED_NULL_BYTE_PREFIX)})?${sourcePrefix}`);
 }
 function toViteEncodedId(id) {
 	return `${VITE_ENCODED_NULL_BYTE_PREFIX}${id}`;
@@ -1103,7 +1110,7 @@ function serializeRuntimeOptions(options) {
 				if (val instanceof Map) return `new Map([${Array.from(val.entries()).map(([k, v]) => `[${valueToCode(k)}, ${valueToCode(v)}]`).join(", ")}])`;
 				if (val instanceof Set) return `new Set([${Array.from(val.values()).map(valueToCode).join(", ")}])`;
 				const properties = [];
-				for (const key in val) if (Object.prototype.hasOwnProperty.call(val, key)) properties.push(`${toSafeJsLiteral(key)}: ${valueToCode(val[key])}`);
+				for (const key in val) if (Object.hasOwn(val, key)) properties.push(`${toSafeJsLiteral(key)}: ${valueToCode(val[key])}`);
 				return `{${properties.join(", ")}}`;
 			} finally {
 				ancestors.delete(val);
@@ -1112,7 +1119,7 @@ function serializeRuntimeOptions(options) {
 		return toSafeJsLiteral(String(val));
 	}
 	const topLevelProps = [];
-	for (const key in options) if (Object.prototype.hasOwnProperty.call(options, key)) topLevelProps.push(`${toSafeJsLiteral(key)}: ${valueToCode(options[key])}`);
+	for (const key in options) if (Object.hasOwn(options, key)) topLevelProps.push(`${toSafeJsLiteral(key)}: ${valueToCode(options[key])}`);
 	return `{${topLevelProps.join(", ")}}`;
 }
 const NATIVE_FUNCTION_SOURCE = /\{\s*\[native code\]\s*\}\s*$/;
@@ -1223,7 +1230,7 @@ function isReactComponentFile(filePath, seen = /* @__PURE__ */ new Set()) {
 */
 function getReactIslandExposes(options, root) {
 	if (options.experiments.ssrMode !== "ISLAND") return /* @__PURE__ */ new Set();
-	if (Object.prototype.hasOwnProperty.call(options.shared, "react")) return /* @__PURE__ */ new Set();
+	if (Object.hasOwn(options.shared, "react")) return /* @__PURE__ */ new Set();
 	const islandExposes = /* @__PURE__ */ new Set();
 	for (const [key, expose] of Object.entries(options.exposes)) {
 		const sourceFile = resolveSourceFile(expose.import, root);
@@ -3707,6 +3714,7 @@ function getMaterializedShares(options) {
 	const pending = [...shares];
 	while (pending.length) {
 		const pkg = pending.pop();
+		const share = getNormalizeShareItem(pkg, resolvedOptions);
 		const packageName = getPackageName(pkg);
 		const packageJson = getInstalledPackageJson(pkg)?.packageJson ?? (pkg !== packageName ? getInstalledPackageJson(packageName)?.packageJson : void 0);
 		const dependencies = {
@@ -3716,7 +3724,8 @@ function getMaterializedShares(options) {
 		};
 		for (const dependency of Object.keys(dependencies)) {
 			const sharedDependency = configured.get(dependency);
-			if (sharedDependency && !shares.has(sharedDependency)) {
+			const dependencyShare = sharedDependency ? getNormalizeShareItem(sharedDependency, resolvedOptions) : void 0;
+			if (sharedDependency && !shares.has(sharedDependency) && dependencyShare?.scope === share?.scope) {
 				shares.add(sharedDependency);
 				pending.push(sharedDependency);
 			}
@@ -4438,9 +4447,9 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
     return exposesMapPromise
   }
 
-  async function init(shared = {}, initScope = []) {
+  async function init(shared = {}, initScope = [], remoteEntryInitOptions = {}) {
     ${sharedCacheHelperCode}
-    const getShareScope = (scopeName) => ${hasMultipleShareScopes} ? (shared?.[scopeName] || {}) : shared;
+    const getShareScope = (scopeName) => remoteEntryInitOptions.shareScopeMap?.[scopeName] ?? (${hasMultipleShareScopes} ? (shared?.[scopeName] || {}) : shared);
     const getShareScopeNames = (share) => {
       const configuredScopes = Array.isArray(share?.scope) ? share.scope : [share?.scope || shareScopeName];
       if (!${hasMultipleShareScopes}) return configuredScopes;
@@ -5272,9 +5281,9 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
     return (exposesMap[moduleName])().then(res => () => res)
   }
   ${guardHostAutoInit ? `let __mfInitPromise;
-  function __mfGuardedInit(shared, initScope) {
+  function __mfGuardedInit(shared, initScope, remoteEntryInitOptions) {
     if (shared === undefined && __mfInitPromise) return __mfInitPromise;
-    __mfInitPromise = init(shared, initScope);
+    __mfInitPromise = init(shared, initScope, remoteEntryInitOptions);
     return __mfInitPromise;
   }
   export { __mfGuardedInit as init, getExposes as get }` : `export { init, getExposes as get }`}
@@ -5324,6 +5333,12 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
           const {usedShared} = await import("${getLocalSharedImportMapPath(options)}");
           ${normalizeRuntimeShareCode}
           ${shouldPreloadShares ? `
+          const __mfHasAlternativeSharedVersion = (pkg, share) =>
+            (Array.isArray(share.scope) ? share.scope : [share.scope || 'default']).some(
+              (scopeName) => Object.keys(runtime.shareScopeMap?.[scopeName]?.[pkg] || {}).some(
+                (version) => version !== share.version
+              )
+            );
           const __mfHostInitShareBatches = ${hostInitShareBatches};
           for (const __mfHostInitShareBatch of __mfHostInitShareBatches) {
             await Promise.all(__mfHostInitShareBatch.map(async (pkg) => {
@@ -5336,7 +5351,10 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
               const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
               if (
                 __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined &&
-                __mfReadSharedCacheOwner(__mfModuleCache.share, cacheDescriptor) ${_command === "serve" ? "!== undefined" : `=== ${cacheOwner}`}
+                ${_command === "serve" ? `__mfReadSharedCacheOwner(__mfModuleCache.share, cacheDescriptor) !== undefined` : `(
+                        (!share.shareConfig?.singleton && __mfReadSharedCacheOwner(__mfModuleCache.share, cacheDescriptor) === ${cacheOwner}) ||
+                        (share.shareConfig?.singleton && !__mfHasAlternativeSharedVersion(pkg, share))
+                      )`}
               ) return;
               // An import:false share has nothing to load until a foreign provider
               // registers: its own stub getter throws by construction.
@@ -5431,8 +5449,9 @@ function getPendingSharesState(options) {
 function generatePendingSharesCode(command = "build", options) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const pendingShareImports = command === "build" ? getMaterializedShares(options).filter((pkg) => {
-		const shareItem = resolvedOptions.shared?.[pkg];
-		return Boolean(shareItem) && !pkg.endsWith("/") && shareItem.shareConfig.import !== false && !shareItem.shareConfig.treeShaking;
+		const shareItem = getShareItemForPreload(pkg, resolvedOptions);
+		if (!shareItem || pkg.endsWith("/")) return false;
+		return shareItem.shareConfig.import !== false && !shareItem.shareConfig.treeShaking;
 	}).map((pkg) => `[${toSafeJsLiteral(pkg)}, () => import(${toSafeJsLiteral(getLoadShareModulePath(pkg, false, options))})]`) : [];
 	return `
     ${getRuntimeModuleCacheBootstrapCode()}
@@ -5525,8 +5544,15 @@ function getScopedUsedRemotesMap(options) {
 	return scoped;
 }
 function recordUsedRemote(map, remoteKey, remoteModule) {
+	ensureUsedRemoteKey(map, remoteKey).add(remoteModule);
+}
+function ensureUsedRemoteKey(map, remoteKey) {
 	if (!map[remoteKey]) map[remoteKey] = /* @__PURE__ */ new Set();
-	map[remoteKey].add(remoteModule);
+	return map[remoteKey];
+}
+function ensureUsedRemote(remoteKey, options) {
+	ensureUsedRemoteKey(usedRemotesMap, remoteKey);
+	if (options) ensureUsedRemoteKey(getScopedUsedRemotesMap(options), remoteKey);
 }
 function addUsedRemote(remoteKey, remoteModule, options) {
 	recordUsedRemote(usedRemotesMap, remoteKey, remoteModule);
@@ -5833,7 +5859,7 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
 }
 //#endregion
 //#region src/plugins/pluginAddEntry.ts
-const isPreloadableVirtualMfChunk = (name) => name.includes("virtual_mf") && !name.includes("__prebuild__");
+const isPreloadableVirtualMfChunk = (name) => name.includes("virtual_mf") && !name.includes("__prebuild__") && !name.includes("__loadShare__");
 const HOST_INIT_PRELOAD_CHUNKS = [
 	(name) => name === "hostInit",
 	(name) => name === "remoteEntry",
@@ -5935,12 +5961,6 @@ function stripQueryAndHash$1(file) {
 function isReactRouterClientRouteInput(file) {
 	return /[?&]__react-router-build-client-route(?:[=&]|$)/.test(file);
 }
-function resolveDevHashEntryFileName$1(fileName) {
-	if (!fileName.includes("[hash")) return fileName;
-	const normalized = fileName.replace(/(?:[._-]?\[hash(?::\d+)?\])/g, "");
-	const baseName = path$1.basename(normalized);
-	return path$1.extname(baseName) ? normalized : `${normalized}.js`;
-}
 function getBuildInput(config) {
 	return config.build?.rollupOptions?.input ?? config.build?.rolldownOptions?.input;
 }
@@ -6058,7 +6078,7 @@ const __mfCurrentScript = document.currentScript;
 		const normalizedOptions = federationOptions ?? getNormalizeModuleFederationOptions();
 		const isLoadedFirstClientBuild = (_command === "build" || viteConfig?.command === "build") && waitsForInit && !viteConfig?.build?.ssr && normalizedOptions.shareStrategy === "loaded-first";
 		if (normalizedOptions.shareStrategy === "loaded-first" && !isLoadedFirstClientBuild) return [];
-		const remoteSources = isLoadedFirstClientBuild ? Array.from(getPreloadRemotes(normalizedOptions)) : Object.entries(getUsedRemotesMap(federationOptions)).flatMap(([, remotes]) => Array.from(remotes)).filter((remote) => !federationOptions || !isDynamicOnlyRemote(remote, federationOptions));
+		const remoteSources = isLoadedFirstClientBuild ? Array.from(getPreloadRemotes(normalizedOptions)) : Object.keys(getUsedRemotesMap(federationOptions));
 		return Array.from(new Set(remoteSources.flatMap((remote) => {
 			const registration = getRemoteRegistration(remote, normalizedOptions.remotes, federationOptions);
 			return registration && (registration.type === "module" || registration.type === "esm") && /^(?:https?:)?\/\//.test(registration.entry) ? [registration.entry] : [];
@@ -6091,7 +6111,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 ` : "";
 		const sharedPreloadSources = _command === "serve" && waitsForInit && Object.keys(normalizedOptions.exposes || {}).length > 0 && Object.keys(normalizedOptions.remotes || {}).length === 0 && federationOptions ? Array.from(getUsedShares(federationOptions)).filter((pkg) => !pkg.endsWith("/")).filter((pkg) => {
 			const shareItem = federationOptions.shared[pkg] || Object.entries(federationOptions.shared).find(([key]) => key.endsWith("/") && pkg.startsWith(key))?.[1];
-			const isExplicitShare = Object.prototype.hasOwnProperty.call(federationOptions.shared, pkg);
+			const isExplicitShare = Object.hasOwn(federationOptions.shared, pkg);
 			return shareItem?.shareConfig?.singleton === true && shareItem?.shareConfig?.import !== false && !shareItem?.shareConfig?.treeShaking && (isExplicitShare || typeof shareItem?.shareConfig?.import === "string" || Boolean(getProjectResolvedImportPath(pkg)));
 		}).map((pkg) => toViteEncodedId(getLoadShareModulePath(pkg, false, federationOptions))) : [];
 		const sharedPreloadBlock = sharedPreloadSources.length > 0 ? `
@@ -6256,7 +6276,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 					next();
 					return;
 				}
-				const devFileName = resolveDevHashEntryFileName$1(fileName);
+				const devFileName = resolveHashPlaceholderFileName(fileName);
 				if (devFileName !== fileName && req.url?.startsWith((viteConfig.base + devFileName).replace(/^\/?/, "/"))) req.url = req.url.replace(devFileName, fileName);
 				if (req.url && req.url.startsWith((viteConfig.base + fileName).replace(/^\/?/, "/"))) {
 					req.url = devEntryPath;
@@ -7231,6 +7251,9 @@ function pluginExternalRuntimeCore() {
 	};
 }
 //#endregion
+//#region package.json
+var version$1 = "1.21.6";
+//#endregion
 //#region src/virtualModules/index.ts
 function initVirtualModules(command, remoteEntryId, enableSsrInit = false, options) {
 	writeLocalSharedImportMap(options);
@@ -7458,21 +7481,22 @@ const REMOTE_ENTRY_SSR_ID = "virtual:mf-REMOTE_ENTRY_SSR_ID";
 function getRemoteEntrySSRId(options) {
 	return `${REMOTE_ENTRY_SSR_ID}:${getVirtualModuleScopeKey(options)}`;
 }
-function stripSsrFilenameHashPlaceholder(filename) {
-	if (!filename.includes("[hash")) return filename;
-	filename = filename.replace(/(?:[._-]?\[hash(?::\d+)?\])/g, "");
-	if (!/\.[^.]+$/.test(filename)) filename = `${filename}.js`;
-	return filename;
+const FILE_EXTENSION_RE = /\.[^.]+$/;
+function getSsrFileNameParts(browserFilename) {
+	const filename = resolveHashPlaceholderFileName(browserFilename);
+	const ext = FILE_EXTENSION_RE.exec(filename)?.[0];
+	return {
+		base: ext ? filename.slice(0, filename.length - ext.length) : filename,
+		ext
+	};
 }
 function getSsrRemoteEntryFileName(browserFilename) {
-	const filename = stripSsrFilenameHashPlaceholder(browserFilename);
-	const ext = filename.match(/\.[^.]+$/)?.[0] || ".js";
-	return `${filename.slice(0, filename.length - ext.length)}.ssr${ext}`;
+	const { base, ext } = getSsrFileNameParts(browserFilename);
+	return `${base}.ssr${ext ?? ".js"}`;
 }
 function getSsrExposesFileName(browserFilename) {
-	const filename = stripSsrFilenameHashPlaceholder(browserFilename);
-	const ext = filename.match(/\.[^.]+$/)?.[0];
-	return `${ext ? filename.slice(0, filename.length - ext.length) : filename}.exposes.js`;
+	const { base } = getSsrFileNameParts(browserFilename);
+	return `${base}.exposes.js`;
 }
 /** Singleton map for SSR loadShare: expand `pkg/` via usedShares; never serialize the prefix. */
 function getSsrSharedSingletons(options) {
@@ -7650,12 +7674,6 @@ function resolveTypesMeta(dts) {
 		api: `${typesFolder}.d.ts`
 	};
 }
-function resolveDevRemoteEntryFileName(fileName) {
-	if (!fileName.includes("[hash")) return fileName;
-	const normalized = fileName.replace(/(?:[._-]?\[hash(?::\d+)?\])/g, "");
-	const baseName = path$1.basename(normalized);
-	return path$1.extname(baseName) ? normalized : `${normalized}.js`;
-}
 function createRemoteEntryAssetMap(fileName) {
 	return {
 		js: {
@@ -7741,10 +7759,10 @@ const Manifest = (providedOptions) => {
 	let mfManifestStatsName = mfManifestName ? getStatsFileName(mfManifestName) : void 0;
 	const isConsumerProject = Object.keys(mfOptions.exposes).length === 0;
 	let disableAssetsAnalyze = false;
-	const getDefaultDisableAssetsAnalyze = (command) => command === "serve" && isConsumerProject && (typeof manifestOptions !== "object" || !Object.prototype.hasOwnProperty.call(manifestOptions, "disableAssetsAnalyze"));
+	const getDefaultDisableAssetsAnalyze = (command) => command === "serve" && isConsumerProject && (typeof manifestOptions !== "object" || !Object.hasOwn(manifestOptions, "disableAssetsAnalyze"));
 	const getConfiguredDisableAssetsAnalyze = (command) => {
 		if (typeof manifestOptions === "object" && manifestOptions !== null) {
-			if (Object.prototype.hasOwnProperty.call(manifestOptions, "disableAssetsAnalyze")) return manifestOptions.disableAssetsAnalyze === true;
+			if (Object.hasOwn(manifestOptions, "disableAssetsAnalyze")) return manifestOptions.disableAssetsAnalyze === true;
 		}
 		return getDefaultDisableAssetsAnalyze(command);
 	};
@@ -7774,7 +7792,7 @@ const Manifest = (providedOptions) => {
 		*/
 		configureServer(server) {
 			server.middlewares.use((req, res, next) => {
-				const devRemoteEntryFile = resolveDevRemoteEntryFileName(filename);
+				const devRemoteEntryFile = resolveHashPlaceholderFileName(filename);
 				if (devRemoteEntryFile !== filename && Object.keys(mfOptions.exposes).length > 0 && req.url?.startsWith((viteConfig.base + devRemoteEntryFile).replace(/^\/?/, "/"))) {
 					req.url = req.url.replace(devRemoteEntryFile, filename);
 					next();
@@ -7817,7 +7835,7 @@ const Manifest = (providedOptions) => {
 								} : void 0,
 								types: resolveTypesMeta(mfOptions.dts),
 								globalName: name,
-								pluginVersion: "0.2.5",
+								pluginVersion: version$1,
 								publicPath
 							}
 						});
@@ -7861,7 +7879,7 @@ const Manifest = (providedOptions) => {
 			const expectedSsrRemoteEntryFile = getSsrRemoteEntryFileName(mfOptions.filename);
 			const foundSsrRemoteEntryFile = Object.values(bundle).find((file) => file.fileName === expectedSsrRemoteEntryFile)?.fileName;
 			if (foundRemoteEntryFile) remoteEntryFile = foundRemoteEntryFile;
-			ssrRemoteEntryFile = foundSsrRemoteEntryFile || (_command === "serve" ? getSsrRemoteEntryFileName(resolveDevRemoteEntryFileName(mfOptions.filename)) : expectedSsrRemoteEntryFile);
+			ssrRemoteEntryFile = foundSsrRemoteEntryFile || (_command === "serve" ? getSsrRemoteEntryFileName(resolveHashPlaceholderFileName(mfOptions.filename)) : expectedSsrRemoteEntryFile);
 			const allCssAssets = mfOptions.bundleAllCSS && !disableAssetsAnalyze ? collectCssAssets(bundle) : /* @__PURE__ */ new Set();
 			if (allCssAssets.size > 0) {
 				const secondaryCss = /* @__PURE__ */ new Set();
@@ -7886,6 +7904,13 @@ const Manifest = (providedOptions) => {
 				expandExposeAssets(filesMap, exposesModules, bundle, foundRemoteEntryFile, mfOptions);
 				const fileToShareKey = await buildFileToShareKeyMap(getUsedShares(mfOptions), this.resolve.bind(this), mfOptions);
 				processModuleAssets(Object.fromEntries(Object.entries(bundle).filter(([, file]) => !isTreeShakingProviderChunk(file))), filesMap, (modulePath) => fileToShareKey.get(modulePath));
+				for (const shareKey of getUsedShares(mfOptions)) {
+					const shareItem = getNormalizeShareItem(shareKey, mfOptions);
+					const assets = filesMap[shareKey];
+					if (!assets || shareItem?.shareConfig.eager === true) continue;
+					assets.js.async.push(...assets.js.sync.splice(0));
+					assets.css.async.push(...assets.css.sync.splice(0));
+				}
 				if (mfOptions.bundleAllCSS) addCssAssetsToAllExports(filesMap, allCssAssets);
 				filesMap = deduplicateAssets(filesMap);
 			}
@@ -7913,14 +7938,14 @@ const Manifest = (providedOptions) => {
 	function generateMFManifest(preloadMap, disableAssetsAnalyze = false) {
 		const options = mfOptions;
 		const { name, varFilename } = options;
-		const resolvedRemoteEntryFile = _command === "serve" ? remoteEntryFile || resolveDevRemoteEntryFileName(filename) : remoteEntryFile;
+		const resolvedRemoteEntryFile = _command === "serve" ? remoteEntryFile || resolveHashPlaceholderFileName(filename) : remoteEntryFile;
 		const remoteEntry = {
 			name: resolvedRemoteEntryFile,
 			path: "",
 			type: "module"
 		};
 		const ssrRemoteEntry = {
-			name: ssrRemoteEntryFile || getSsrRemoteEntryFileName(_command === "serve" ? resolveDevRemoteEntryFileName(filename) : filename),
+			name: ssrRemoteEntryFile || getSsrRemoteEntryFileName(_command === "serve" ? resolveHashPlaceholderFileName(filename) : filename),
 			path: _command === "serve" ? "/__mf_ssr__/" : "",
 			type: "module"
 		};
@@ -8007,7 +8032,7 @@ const Manifest = (providedOptions) => {
 				varRemoteEntry,
 				types: resolveTypesMeta(options.dts),
 				globalName: name,
-				pluginVersion: "0.2.5",
+				pluginVersion: version$1,
 				...!!getPublicPath ? { getPublicPath } : { publicPath }
 			},
 			...disableAssetsAnalyze ? {} : { shared },
@@ -8220,12 +8245,6 @@ function pluginModuleParseEnd_default(excludeFn, options, controller = createMod
 }
 //#endregion
 //#region src/plugins/pluginProxyRemoteEntry.ts
-function resolveDevHashEntryFileName(fileName) {
-	if (!fileName.includes("[hash")) return fileName;
-	const normalized = fileName.replace(/(?:[._-]?\[hash(?::\d+)?\])/g, "");
-	const baseName = path$1.basename(normalized);
-	return path$1.extname(baseName) ? normalized : `${normalized}.js`;
-}
 function resolveAbsoluteDevRemoteEntryUrl(publicPath, fileName) {
 	const base = new URL(publicPath);
 	base.pathname = ensureTrailingSlash(base.pathname);
@@ -8366,7 +8385,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 						const host = formatDevServerHostForOrigin(viteConfig.server?.host);
 						const resolvedPublicPath = resolvePublicPath(options, viteConfig.base, originalConfigBase);
 						const devPublicPath = resolvedPublicPath === "auto" ? "/" : resolvedPublicPath;
-						const remoteEntryFileName = resolveDevHashEntryFileName(options.filename);
+						const remoteEntryFileName = resolveHashPlaceholderFileName(options.filename);
 						const isAbsolutePublicPath = /^https?:\/\//i.test(devPublicPath);
 						const remoteEntryUrl = JSON.stringify(isAbsolutePublicPath ? resolveAbsoluteDevRemoteEntryUrl(devPublicPath, remoteEntryFileName) : `${ensureTrailingSlash(devPublicPath)}${remoteEntryFileName}`);
 						const fallbackOrigin = `//${host}:${viteConfig.server?.port}`;
@@ -8438,9 +8457,6 @@ function resolveRemoteConsumer(ctx, hasMultiEnvironment) {
 function isNodeModulesImporter(importer) {
 	return importer?.includes("/node_modules/") || importer?.includes("\\node_modules\\");
 }
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 function appendAlias(config, alias) {
 	config.resolve ??= {};
 	const existingAlias = config.resolve.alias;
@@ -8748,7 +8764,7 @@ const NON_RUNTIME_DIRS = /* @__PURE__ */ new Set([
 	"dist",
 	"build"
 ]);
-/** Bundled artifacts of a published package never import workspace packages; skip them instead of scanning megabytes. */
+/** Keep local runtime walks bounded without skipping the package entry itself. */
 const MAX_SCANNED_SOURCE_BYTES = 256 * 1024;
 const BARE_PACKAGE_SPECIFIER_RE = /^(?:@[^\s'"`()\/]+\/)?[^\s'"`()\/.@][^\s'"`()\/]*(?:\/[^\s'"`()]*)?$/;
 /** Module specifiers evaluated by a source file. */
@@ -8764,24 +8780,30 @@ function collectAllRuntimeImports(dir, into) {
 	try {
 		entries = readdirSync(dir, { withFileTypes: true });
 	} catch {
-		return;
+		return false;
 	}
+	let complete = true;
 	for (const entry of entries) {
 		if (entry.isDirectory()) {
-			if (!NON_RUNTIME_DIRS.has(entry.name)) collectAllRuntimeImports(path$1.join(dir, entry.name), into);
+			if (!NON_RUNTIME_DIRS.has(entry.name) && !collectAllRuntimeImports(path$1.join(dir, entry.name), into)) complete = false;
 			continue;
 		}
 		if (!SOURCE_FILE_RE.test(entry.name) || NON_RUNTIME_SOURCE_RE.test(entry.name)) continue;
 		const file = path$1.join(dir, entry.name);
 		let code;
 		try {
-			if (statSync(file).size > MAX_SCANNED_SOURCE_BYTES) continue;
+			if (statSync(file).size > MAX_SCANNED_SOURCE_BYTES) {
+				complete = false;
+				continue;
+			}
 			code = readFileSync(file, "utf-8");
 		} catch {
+			complete = false;
 			continue;
 		}
 		for (const specifier of getRuntimeImportSpecifiers(code)) into.add(specifier);
 	}
+	return complete;
 }
 const SOURCE_EXTENSIONS = [
 	"",
@@ -8807,19 +8829,27 @@ function resolveLocalRuntimeImport(importer, specifier) {
 }
 function collectReachableRuntimeImports(entry, dir, into) {
 	const visited = /* @__PURE__ */ new Set();
-	const queue = [entry];
+	const queue = [{
+		file: entry,
+		isEntry: true
+	}];
 	let scanned = false;
+	let complete = true;
 	while (queue.length) {
-		const file = queue.shift();
+		const { file, isEntry } = queue.shift();
 		const relative = path$1.relative(dir, file);
 		if (relative.startsWith("..") || path$1.isAbsolute(relative) || visited.has(file)) continue;
 		visited.add(file);
 		let code;
 		try {
-			if (statSync(file).size > MAX_SCANNED_SOURCE_BYTES) continue;
+			if (!isEntry && statSync(file).size > MAX_SCANNED_SOURCE_BYTES) {
+				complete = false;
+				continue;
+			}
 			code = readFileSync(file, "utf-8");
 			scanned = true;
 		} catch {
+			complete = false;
 			continue;
 		}
 		for (const specifier of getRuntimeModuleSpecifiers(code)) {
@@ -8828,10 +8858,13 @@ function collectReachableRuntimeImports(entry, dir, into) {
 				continue;
 			}
 			const local = resolveLocalRuntimeImport(file, specifier);
-			if (local) queue.push(local);
+			if (local) queue.push({
+				file: local,
+				isEntry: false
+			});
 		}
 	}
-	return scanned;
+	return scanned && complete;
 }
 /**
 * Whether `dependency` is reachable from the shared package through the imports its source files
@@ -8840,11 +8873,13 @@ function collectReachableRuntimeImports(entry, dir, into) {
 * the fallback's evaluation graph rather than the package's declared closure — in a monorepo the
 * latter covers far more than the module graph ever does.
 */
-function isSharedPackageRuntimeDependency(sharedKey, dependency) {
+function isSharedPackageRuntimeDependency(sharedKey, dependency, conditions) {
 	const sharedPackage = getPackageName(sharedKey);
-	let reachable = sharedRuntimeDependencyCache.get(sharedKey);
-	if (!reachable) {
-		reachable = /* @__PURE__ */ new Set();
+	const cacheKey = `${sharedKey}\0${JSON.stringify(conditions ?? null)}`;
+	let result = sharedRuntimeDependencyCache.get(cacheKey);
+	if (!result) {
+		const reachable = /* @__PURE__ */ new Set();
+		let complete = true;
 		const visited = /* @__PURE__ */ new Set();
 		const queue = [{
 			request: sharedKey,
@@ -8852,16 +8887,26 @@ function isSharedPackageRuntimeDependency(sharedKey, dependency) {
 		}];
 		while (queue.length) {
 			const { request, installed } = queue.shift();
-			if (!installed) continue;
+			if (!installed) {
+				complete = false;
+				continue;
+			}
 			const visitKey = `${installed.dir}\0${request}`;
 			if (visited.has(visitKey)) continue;
 			visited.add(visitKey);
 			const specifiers = /* @__PURE__ */ new Set();
 			const entry = getInstalledPackageEntry(request, {
 				cwd: installed.dir,
-				packageName: getPackageName(request)
+				packageName: getPackageName(request),
+				resolveSubpathWithRequire: false,
+				...conditions !== void 0 ? { conditions: [...conditions] } : {}
 			});
-			if (!entry || !collectReachableRuntimeImports(entry, installed.dir, specifiers)) collectAllRuntimeImports(installed.dir, specifiers);
+			if (!entry) {
+				if (!collectAllRuntimeImports(installed.dir, specifiers)) complete = false;
+			} else if (!collectReachableRuntimeImports(entry, installed.dir, specifiers)) {
+				complete = false;
+				collectAllRuntimeImports(installed.dir, specifiers);
+			}
 			for (const specifier of specifiers) {
 				const dep = getPackageName(specifier);
 				if (dep === sharedPackage) continue;
@@ -8873,9 +8918,13 @@ function isSharedPackageRuntimeDependency(sharedKey, dependency) {
 				});
 			}
 		}
-		sharedRuntimeDependencyCache.set(sharedKey, reachable);
+		result = {
+			dependencies: reachable,
+			complete
+		};
+		sharedRuntimeDependencyCache.set(cacheKey, result);
 	}
-	return reachable.has(dependency);
+	return result.dependencies.has(dependency) || !result.complete && isSharedPackageDependency(sharedKey, dependency);
 }
 function proxySharedModule(options) {
 	const { shared = {}, federationOptions, getParsePromise = () => Promise.resolve() } = options;
@@ -8883,12 +8932,30 @@ function proxySharedModule(options) {
 	let _command = "serve";
 	let useDirectReactImport = false;
 	let useRolldown = false;
+	let isProduction = false;
+	let rootResolveConditions;
+	let ssrResolveConditions;
+	let ssrTarget = "node";
 	const savePrebuild = new PromiseStore();
 	let devServer;
 	const materializedLoadShareSources = /* @__PURE__ */ new Set();
 	const emittedTreeShakingProviders = /* @__PURE__ */ new Set();
 	const hasAnalyzableShares = Object.values(shared).some((share) => shouldAnalyzeSharedExports(share));
-	const getEnvironmentConditions = (context) => context.environment?.config?.resolve?.conditions;
+	const getEnvironmentConfig = (context) => context.environment?.config;
+	const getEnvironmentConditions = (context) => getEnvironmentConfig(context)?.resolve?.conditions;
+	const getRuntimeDependencyConditions = (context, resolveOptions) => {
+		const environment = context.environment;
+		const environmentConfig = environment?.config;
+		const isSsr = resolveOptions.ssr === true || Boolean(_config?.build?.ssr) || environmentConfig?.consumer === "server" || Boolean(environmentConfig?.build?.ssr) || environment?.name === "ssr" || environment?.name === "server";
+		return getSharedExportConditions({
+			environmentConditions: environmentConfig?.resolve?.conditions,
+			isProduction: environmentConfig?.isProduction ?? isProduction,
+			isSsr,
+			rootConditions: rootResolveConditions,
+			ssrConditions: ssrResolveConditions,
+			ssrTarget
+		});
+	};
 	const refreshTreeShakingForEnvironment = (context) => refreshTreeShakingModules(federationOptions, _command, getIsRolldown(context), getEnvironmentConditions(context));
 	const normalizeTreeShakingOutputPath = (value) => {
 		const normalized = normalizePathForImport(value);
@@ -8972,8 +9039,13 @@ function proxySharedModule(options) {
 			},
 			configResolved(config) {
 				_config = config;
+				isProduction = config.isProduction;
+				rootResolveConditions = config.resolve?.conditions ? [...config.resolve.conditions] : void 0;
+				ssrResolveConditions = config.ssr?.resolve?.conditions ? [...config.ssr.resolve.conditions] : void 0;
+				ssrTarget = config.ssr?.target ?? "node";
 				const isRolldown = getIsRolldown(this);
-				const registerConfiguredShare = _command === "serve" ? addConfiguredShare : addUsedShares;
+				const resolvedOptions = federationOptions ?? getNormalizeModuleFederationOptions();
+				const registerConfiguredShare = _command === "build" && Object.keys(resolvedOptions.exposes).length > 0 ? addUsedShares : addConfiguredShare;
 				Object.keys(shared).forEach((key) => {
 					if (key.endsWith("/")) return;
 					if (useDirectReactImport && key === "react") {
@@ -9053,7 +9125,9 @@ function proxySharedModule(options) {
 				const importerPackage = getSharedPackageFromFile(importer, shared);
 				if (importerPackage === getPackageName(key)) return;
 				if (importerPackage) {
-					if (!isNodeModulePath(importer) && !Object.keys(shared).some((sharedKey) => getPackageName(sharedKey) === importerPackage) ? isSharedPackageRuntimeDependency(key, importerPackage) : isSharedPackageDependency(key, importerPackage)) return;
+					const importerIsUnsharedWorkspacePackage = !isNodeModulePath(importer) && !Object.keys(shared).some((sharedKey) => getPackageName(sharedKey) === importerPackage);
+					const runtimeDependencyRequest = key.endsWith("/") && matchesSharedSource(source, key) ? source : key;
+					if (importerIsUnsharedWorkspacePackage ? isSharedPackageRuntimeDependency(runtimeDependencyRequest, importerPackage, getRuntimeDependencyConditions(this, resolveOptions)) : isSharedPackageDependency(key, importerPackage)) return;
 				}
 				if (useDirectReactImport && key === "react") return;
 				if (isAssetLikeImport(source)) return;
@@ -9922,7 +9996,7 @@ function isFederationControlChunk(fileName, filename) {
 function sanitizeFederationControlChunk(code, fileName, filename) {
 	let nextCode = stripEmptyPreloadCalls(code);
 	if (fileName.includes("localSharedImportMap")) {
-		const remoteEntryImportRegex = new RegExp(`import\\s*["'][^"']*${filename.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']\\s*;?`, "g");
+		const remoteEntryImportRegex = new RegExp(`import\\s*["'][^"']*${escapeRegExp(filename)}["']\\s*;?`, "g");
 		nextCode = nextCode.replace(remoteEntryImportRegex, "");
 	}
 	return nextCode;
@@ -10054,13 +10128,15 @@ function appendResolveAlias(config, alias) {
 		replacement
 	})), alias];
 }
+const RUNTIME_INDEX_ENTRY_RE = /^(.*[\\/])index(\.[cm]?js)$/;
+const TRAILING_SLASH_RE = /\/$/;
 function getRuntimeHelpersImplementation(runtimeImplementation) {
-	const indexEntryMatch = runtimeImplementation.match(/^(.*[\\/])index(\.[cm]?js)$/);
+	const indexEntryMatch = RUNTIME_INDEX_ENTRY_RE.exec(runtimeImplementation);
 	if (indexEntryMatch) return normalizePathForImport(`${indexEntryMatch[1]}helpers${indexEntryMatch[2]}`);
 	const extension = path$1.extname(runtimeImplementation);
 	if (extension) return normalizePathForImport(path$1.join(path$1.dirname(runtimeImplementation), `helpers${extension}`));
 	if (path$1.isAbsolute(runtimeImplementation) || runtimeImplementation.startsWith(".")) return normalizePathForImport(path$1.join(runtimeImplementation, "helpers"));
-	return `${runtimeImplementation.replace(/\/$/, "")}/helpers`;
+	return `${runtimeImplementation.replace(TRAILING_SLASH_RE, "")}/helpers`;
 }
 const UNSAFE_JS_SOURCE_CHAR_MAP = {
 	"<": "\\u003C",
@@ -10307,7 +10383,7 @@ function createEarlyVirtualModulesPlugin(options) {
 			initVirtualModules(_command, getRemoteEntryId(options), false, options);
 			const isRolldown = getIsRolldown(this);
 			if (remotes && Object.keys(remotes).length > 0) {
-				for (const key of Object.keys(remotes)) addUsedRemote(key, key, options);
+				for (const key of Object.keys(remotes)) ensureUsedRemote(key, options);
 				if (_command === "serve") {
 					config.optimizeDeps = config.optimizeDeps || {};
 					config.optimizeDeps.exclude = config.optimizeDeps.exclude || [];
@@ -10537,7 +10613,7 @@ function applyBuildTimeRuntimeDefines(define, options, { target, isAstro, defaul
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-BhONN9dR.js").then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-4sHIZPIi.js").then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {
@@ -11109,10 +11185,10 @@ function federation(mfUserOptions) {
 				apply: "build",
 				config(_config, { command }) {
 					const manifest = options.manifest;
-					const getDefaultDisableAssetsAnalyze = (cfgCommand) => cfgCommand === "serve" && (typeof manifest !== "object" || !Object.prototype.hasOwnProperty.call(manifest, "disableAssetsAnalyze"));
+					const getDefaultDisableAssetsAnalyze = (cfgCommand) => cfgCommand === "serve" && (typeof manifest !== "object" || !Object.hasOwn(manifest, "disableAssetsAnalyze"));
 					const getConfiguredDisableAssetsAnalyze = (cfgCommand) => {
 						if (typeof manifest === "object" && manifest !== null) {
-							if (Object.prototype.hasOwnProperty.call(manifest, "disableAssetsAnalyze")) return manifest.disableAssetsAnalyze === true;
+							if (Object.hasOwn(manifest, "disableAssetsAnalyze")) return manifest.disableAssetsAnalyze === true;
 						}
 						return getDefaultDisableAssetsAnalyze(cfgCommand);
 					};

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

@@ -1,4 +1,4 @@
-import { n as normalizePathForImport } from "./buildPaths-BkaQHrd2.js";
+import { n as normalizePathForImport } from "./buildPaths-BoaQTkxt.js";
 import { _ as mfError, g as createModuleFederationError, l as hasPackageDependency, p as resolveImportPath } from "./dtsConstants-BsaLBaaK.js";
 import fs from "fs";
 import * as path$1 from "node:path";
@@ -34,6 +34,7 @@ const getIPv4 = () => {
 	return (getIpv4Interfaces()[0] || { address: localIpv4 }).address;
 };
 const DEV_TYPES_FOLDER = ".dev-server";
+const UPDATE_DEBOUNCE_MS = 300;
 const forkDevWorkerPath = (() => {
 	return resolveImportPath("@module-federation/dts-plugin/dist/fork-dev-worker.js");
 })();
@@ -256,11 +257,16 @@ function pluginDts(options) {
 					disableLiveReload: devOptions.disableLiveReload,
 					disableHotTypesReload: devOptions.disableHotTypesReload
 				});
-				const update = () => devWorker?.update();
+				let updateTimer;
+				const update = () => {
+					clearTimeout(updateTimer);
+					updateTimer = setTimeout(() => devWorker?.update(), UPDATE_DEBOUNCE_MS);
+				};
 				server.watcher.on("change", update);
 				server.watcher.on("add", update);
 				server.watcher.on("unlink", update);
 				server.httpServer?.once("close", () => {
+					clearTimeout(updateTimer);
 					devWorker?.exit();
 					server.watcher.off("change", update);
 					server.watcher.off("add", update);

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

@@ -1,4 +1,4 @@
-import { t as EXTERNAL_URL_RE } from "./buildPaths-BkaQHrd2.js";
+import { t as EXTERNAL_URL_RE } from "./buildPaths-BoaQTkxt.js";
 //#region src/utils/fetchWithTimeout.ts
 const DEFAULT_SSR_FETCH_TIMEOUT_MS = 1e4;
 const DEFAULT_SSR_FETCH_MAX_BYTES = 10 * 1024 * 1024;
@@ -188,7 +188,8 @@ async function resolveSharedExternal(id, resolvedShared) {
 }
 async function getOrCreateRunner(remoteOrigin, resolvedShared, fetchTimeoutMs, fetchMaxBytes) {
 	const cacheKey = getRunnerCacheKey(remoteOrigin, resolvedShared, fetchTimeoutMs, fetchMaxBytes);
-	if (runnerCache.has(cacheKey)) return runnerCache.get(cacheKey);
+	const cached = runnerCache.get(cacheKey);
+	if (cached) return cached.promise;
 	const promise = (async () => {
 		const viteRunner = await getModuleRunnerModule();
 		if (!viteRunner) return null;
@@ -215,7 +216,10 @@ async function getOrCreateRunner(remoteOrigin, resolvedShared, fetchTimeoutMs, f
 			return null;
 		}
 	})();
-	runnerCache.set(cacheKey, promise);
+	runnerCache.set(cacheKey, {
+		remoteOrigin,
+		promise
+	});
 	return promise;
 }
 const _path = () => nodeImport("path");
@@ -252,10 +256,19 @@ function parseRunnerInvokeResult(data) {
 * Version key for a resolved SSR entry. Derived from the remote's manifest
 * content so a redeploy at the same URL produces a different key, which in
 * turn produces different temp-file names — busting both our caches and
-* Node's ESM module cache. Convention-resolved entries (no manifest) get a
-* stable placeholder key and cannot be revalidated automatically.
+* Node's ESM module cache. Convention-resolved entries (no manifest) use a
+* stable placeholder key for ordinary loads; explicit `revalidate()` calls
+* advance a process-local generation so the next import is fresh.
 */
 const UNVERSIONED = "unversioned";
+const unversionedGenerations = /* @__PURE__ */ new Map();
+let unversionedGlobalGeneration = 0;
+function getUnversionedVersionKey(remoteEntryUrl) {
+	return `${UNVERSIONED}-${unversionedGlobalGeneration}-${unversionedGenerations.get(remoteEntryUrl) ?? 0}`;
+}
+function bumpUnversionedGeneration(remoteEntryUrl) {
+	unversionedGenerations.set(remoteEntryUrl, (unversionedGenerations.get(remoteEntryUrl) ?? 0) + 1);
+}
 function hashString(value) {
 	let hash = 2166136261;
 	for (let i = 0; i < value.length; i++) {
@@ -392,16 +405,16 @@ function buildSsrEntryCandidates(ctx, options = {}) {
 	if (!options.skipServerBuild) candidates.push({
 		url: `${remoteOrigin}/__mf_server__/${filename}.ssr.js`,
 		type: "module",
-		versionKey: UNVERSIONED
+		versionKey: getUnversionedVersionKey(ctx.entryUrl)
 	});
 	candidates.push({
 		url: `${base}.ssr.js`,
 		type: "module",
-		versionKey: UNVERSIONED
+		versionKey: getUnversionedVersionKey(ctx.entryUrl)
 	}, {
 		url: `${remoteOrigin}/__mf_ssr__/${filename}.ssr.js`,
 		type: "module",
-		versionKey: UNVERSIONED
+		versionKey: getUnversionedVersionKey(ctx.entryUrl)
 	});
 	return candidates;
 }
@@ -416,14 +429,14 @@ async function resolveSSREntryImpl(remoteEntryUrl, fetchTimeoutMs, fetchMaxBytes
 	if (isSsrEntry(remoteEntryUrl)) return {
 		url: remoteEntryUrl,
 		type: "module",
-		versionKey: UNVERSIONED
+		versionKey: getUnversionedVersionKey(remoteEntryUrl)
 	};
 	if (!isManifestEntry(remoteEntryUrl)) {
 		const filename = getEntryFilename(remoteEntryUrl);
 		const fromServerBuild = await headCheckSsrEntry({
 			url: `${remoteEntryUrl.replace(/\/[^/]+$/, "")}/__mf_server__/${filename}.ssr.js`,
 			type: "module",
-			versionKey: UNVERSIONED
+			versionKey: getUnversionedVersionKey(remoteEntryUrl)
 		}, fetchTimeoutMs);
 		if (fromServerBuild) return fromServerBuild;
 	}
@@ -477,6 +490,18 @@ function dropRemoteCaches(remoteEntryUrl) {
 		tempFilePathCache.delete(key);
 	}
 }
+function clearRunnerCaches(remoteEntryUrl) {
+	let remoteOrigin;
+	if (remoteEntryUrl) try {
+		remoteOrigin = new URL(remoteEntryUrl).origin;
+	} catch {
+		return;
+	}
+	for (const cached of runnerCache.values()) {
+		if (remoteOrigin && cached.remoteOrigin !== remoteOrigin) continue;
+		cached.promise.then((runner) => runner?.clearCache?.()).catch(() => {});
+	}
+}
 /**
 * 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
@@ -489,16 +514,19 @@ function dropRemoteCaches(remoteEntryUrl) {
 */
 function revalidate(remoteEntryUrl) {
 	if (remoteEntryUrl) {
+		bumpUnversionedGeneration(remoteEntryUrl);
 		for (const key of ssrEntryCache.keys()) if (key.endsWith(`::${remoteEntryUrl}`)) ssrEntryCache.delete(key);
 		const manifestUrl = getManifestUrl(remoteEntryUrl);
 		for (const key of manifestFetchCache.keys()) if (key.endsWith(`::${manifestUrl}`)) manifestFetchCache.delete(key);
 		dropRemoteCaches(remoteEntryUrl);
 	} else {
+		unversionedGlobalGeneration += 1;
 		ssrEntryCache.clear();
 		manifestFetchCache.clear();
 		tempFileCache.clear();
 		tempFilePathCache.clear();
 	}
+	clearRunnerCaches(remoteEntryUrl);
 	const federation = globalThis.__FEDERATION__;
 	for (const instance of federation?.__INSTANCES__ ?? []) try {
 		instance?.moduleCache?.clear?.();
@@ -555,6 +583,9 @@ function transformSsrCode(code, base, sharedPkgMap) {
 function isVitePreloadHelperSpecifier(specifier) {
 	return specifier.includes("preload-helper");
 }
+function getTempFileImportUrl(filePath, versionKey) {
+	return `file://${filePath}?v=${encodeURIComponent(versionKey)}`;
+}
 /**
 * Fetch an HTTP ESM module, transform it, write it to a temp .js file and
 * return the file path. Recursively does the same for HTTP transitive imports
@@ -601,7 +632,7 @@ async function fetchEsmToTempFile(url, tmpDir, visited, pending, sharedPkgMap, v
 		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);
-			subMap.set(u, `file://${tmpPath}`);
+			subMap.set(u, getTempFileImportUrl(tmpPath, versionKey));
 		}));
 		code = transformSsrCode(code, base, sharedPkgMap);
 		for (const [httpUrl, fileUrl] of subMap) code = code.split(httpUrl).join(fileUrl);
@@ -631,7 +662,7 @@ async function importTempModule(filePath, versionKey) {
 }
 let warnedVmUnavailable = false;
 async function tryVmStrategy(ssrEntry, options) {
-	const { loadViaVmStrategy, isVmStrategyAvailable } = await import("./ssrVmStrategy-D4KB-y3H.js");
+	const { loadViaVmStrategy, isVmStrategyAvailable } = await import("./ssrVmStrategy-CkmYR5_u.js");
 	if (!await isVmStrategyAvailable()) {
 		if (!warnedVmUnavailable) {
 			warnedVmUnavailable = true;

package/lib/{ssrVmStrategy-D4KB-y3H.js → ssrVmStrategy-CkmYR5_u.js}

@@ -1,5 +1,5 @@
 import { t as findSharedKey } from "./sharedKeyMatcher-DiUzRVH1.js";
-import { c as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, s as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-CqtaiDUp.js";
+import { c as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, s as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-BqzV2t-n.js";
 //#region src/utils/ssrVmStrategy.ts
 /**
 * vm.SourceTextModule strategy for loading remote SSR entries.
@@ -90,6 +90,7 @@ function createSyntheticModule(vm, specifier, namespace) {
 }
 const httpModuleCache = /* @__PURE__ */ new Map();
 const namespaceCache = /* @__PURE__ */ new Map();
+const linkQueues = /* @__PURE__ */ new WeakMap();
 const contextIds = /* @__PURE__ */ new WeakMap();
 let nextContextId = 1;
 function getContextId(context) {
@@ -153,10 +154,21 @@ async function linkModule(vm, specifier, referencingModule, options) {
 	if (url) return getHttpModule(vm, url, options);
 	return createSyntheticModule(vm, specifier, await loadBareModule(specifier, options));
 }
+async function linkModuleGraph(module, linker, cacheContext) {
+	const current = (linkQueues.get(cacheContext) ?? Promise.resolve()).catch(() => {}).then(async () => {
+		if (module.status === "unlinked") await module.link(linker);
+	});
+	linkQueues.set(cacheContext, current);
+	try {
+		await current;
+	} finally {
+		if (linkQueues.get(cacheContext) === current) linkQueues.delete(cacheContext);
+	}
+}
 async function importDynamically(vm, specifier, referencingModule, options) {
 	const linker = (spec, referencer) => linkModule(vm, spec, referencer, options);
 	const module = await linker(specifier, referencingModule);
-	if (module.status === "unlinked") await module.link(linker);
+	await linkModuleGraph(module, linker, options.cacheContext);
 	if (module.status === "linked") await module.evaluate();
 	return module;
 }
@@ -172,7 +184,7 @@ async function loadViaVmStrategy(entryUrl, options) {
 	if (!namespaceCache.has(cacheKey)) namespaceCache.set(cacheKey, (async () => {
 		const entryModule = await getHttpModule(vm, entryUrl, options);
 		const linker = (specifier, referencingModule) => linkModule(vm, specifier, referencingModule, options);
-		if (entryModule.status === "unlinked") await entryModule.link(linker);
+		await linkModuleGraph(entryModule, linker, options.cacheContext);
 		if (entryModule.status === "linked") await entryModule.evaluate();
 		return entryModule.namespace;
 	})().catch((error) => {

package/lib/utils/ssrEntryLoader.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/vite",
-  "version": "1.21.5",
+  "version": "1.21.6",
   "description": "Vite plugin for Module Federation",
   "type": "module",
   "main": "./lib/index.js",
@@ -91,6 +91,6 @@
     "tsdown": "0.22.14",
     "typescript": "7.0.2",
     "vite": "8.2.0",
-    "vitest": "4.1.10"
+    "vitest": "4.1.11"
   }
 }