@module-federation/vite 1.16.11 → 1.16.13

package/lib/{pluginDts-CrSsDUnT.js → pluginDts-CTAHkt4C.js}

@@ -193,10 +193,56 @@ function getPackageNameFromNodeModulePath(source) {
 	if (parts[0].startsWith("@")) return parts[1] ? `${parts[0]}/${parts[1]}` : void 0;
 	return parts[0];
 }
-function getSharedCacheKey(pkg, shareItem) {
-	const prefix = `${shareItem.scope || "default"}:`;
-	return shareItem.shareConfig.singleton || !shareItem.version ? `${prefix}${pkg}` : `${prefix}${pkg}@${shareItem.version}`;
+function getSharedCacheKeyParts(input) {
+	const scope = (Array.isArray(input.scope) ? input.scope[0] : input.scope) || "default";
+	const id = input.singleton || !input.version ? input.pkg : `${input.pkg}@${input.version}`;
+	return {
+		scope,
+		id,
+		key: `${scope}:${id}`
+	};
+}
+function getSharedCacheDescriptor(pkg, shareItem) {
+	const parts = getSharedCacheKeyParts({
+		pkg,
+		singleton: shareItem.shareConfig.singleton,
+		version: shareItem.version,
+		scope: shareItem.scope
+	});
+	return {
+		canonical: parts.key,
+		...parts.scope === "default" ? { aliases: [parts.id] } : {}
+	};
 }
+const sharedCacheHelperCode = `const __mfGetSharedCacheDescriptor = (pkg, singleton, version, scope) => {
+            const normalizedScope = Array.isArray(scope) ? scope[0] : scope;
+            const scopeName = normalizedScope || "default";
+            const id = singleton || !version ? pkg : pkg + "@" + version;
+            const descriptor = { canonical: scopeName + ":" + id };
+            if (scopeName === "default") descriptor.aliases = [id];
+            return descriptor;
+          };
+          const __mfReadSharedCache = (cache, descriptor) => {
+            const value = cache[descriptor.canonical];
+            if (value !== undefined) return value;
+            const aliases = descriptor.aliases || [];
+            for (const alias of aliases) {
+              const aliasValue = cache[alias];
+              if (aliasValue !== undefined) {
+                cache[descriptor.canonical] = aliasValue;
+                return aliasValue;
+              }
+            }
+            return undefined;
+          };
+          const __mfWriteSharedCache = (cache, descriptor, value) => {
+            cache[descriptor.canonical] = value;
+            const aliases = descriptor.aliases || [];
+            for (const alias of aliases) {
+              if (cache[alias] === undefined) cache[alias] = value;
+            }
+            return value;
+          };`;
 function getInstalledPackageJson(pkg, opts) {
 	const cwd = opts?.cwd || getPackageDetectionCwd();
 	const packageName = opts?.packageName || getPackageName(pkg);
@@ -630,4 +676,4 @@ function pluginDts(options) {
 	}];
 }
 //#endregion
-export { mfWarn as _, getIsRolldown as a, getPackageNameFromNodeModulePath as c, isNuxtProjectRoot as d, packageNameDecode as f, createModuleFederationError as g, setPackageDetectionCwd as h, getInstalledPackageJson as i, getSharedCacheKey as l, resolveImportPath as m, pluginDts_exports as n, getPackageDetectionCwd as o, packageNameEncode as p, getInstalledPackageEntry as r, getPackageName as s, DEFAULT_PUBLIC_TYPES_FOLDER as t, hasPackageDependency as u, normalizePathForImport as v, rebaseImport as y };
+export { createModuleFederationError as _, getIsRolldown as a, rebaseImport as b, getPackageNameFromNodeModulePath as c, isNuxtProjectRoot as d, packageNameDecode as f, sharedCacheHelperCode as g, setPackageDetectionCwd as h, getInstalledPackageJson as i, getSharedCacheDescriptor as l, resolveImportPath as m, pluginDts_exports as n, getPackageDetectionCwd as o, packageNameEncode as p, getInstalledPackageEntry as r, getPackageName as s, DEFAULT_PUBLIC_TYPES_FOLDER as t, hasPackageDependency as u, mfWarn as v, normalizePathForImport as y };

package/lib/ssrVmStrategy-DtpfkCw1.js

@@ -0,0 +1,152 @@
+import { SsrEntryHttpError, neutralizeBrowserPreloadHelpers } from "./utils/ssrEntryLoader.js";
+//#region src/utils/ssrVmStrategy.ts
+/**
+* vm.SourceTextModule strategy for loading remote SSR entries.
+*
+* Unlike the temp-file strategy (which rewrites bare shared imports to
+* host-resolved file:// paths at fetch time), this strategy evaluates the
+* remote's ESM graph with `vm.SourceTextModule` in the current context and
+* resolves bare imports through a linker, in order:
+*
+*  1. The host's federation share scope — `instance.loadShare(name)` on the
+*     global `__FEDERATION__` instances. This restores real share-scope
+*     semantics (version negotiation, loaded-first reuse) on the server.
+*  2. The build-time `resolvedShared` file map (same source as the temp-file
+*     strategy) as a fallback when no instance shares the package.
+*  3. Plain host `import(specifier)` for everything else (node builtins,
+*     packages the remote expects the host to provide).
+*
+* Requires Node with `--experimental-vm-modules`; callers must check
+* `isVmStrategyAvailable()` and fall back to the temp-file strategy when the
+* API is missing.
+*/
+let vmApiPromise;
+async function getVmApi() {
+	if (!vmApiPromise) vmApiPromise = (async () => {
+		try {
+			const vm = await import(
+				/* @vite-ignore */
+				"vm"
+);
+			if (typeof vm.SourceTextModule !== "function" || typeof vm.SyntheticModule !== "function") return null;
+			return vm;
+		} catch {
+			return null;
+		}
+	})();
+	return vmApiPromise;
+}
+async function isVmStrategyAvailable() {
+	return await getVmApi() !== null;
+}
+function getFederationInstances() {
+	return globalThis.__FEDERATION__?.__INSTANCES__ ?? [];
+}
+/**
+* Resolve a bare specifier to a module namespace: share scope first, then the
+* build-time resolvedShared file map, then plain host import.
+*/
+async function loadBareModule(specifier, options) {
+	for (const instance of getFederationInstances()) {
+		if (typeof instance?.loadShare !== "function") continue;
+		if (!instance.options?.shared || !(specifier in instance.options.shared)) continue;
+		try {
+			const factory = await instance.loadShare(specifier);
+			if (typeof factory === "function") {
+				const shared = factory();
+				if (shared) return shared;
+			}
+		} catch {}
+	}
+	const resolvedPath = options.resolvedShared[specifier];
+	if (resolvedPath) return import(
+		/* @vite-ignore */
+		`file://${resolvedPath}`
+);
+	return import(
+		/* @vite-ignore */
+		specifier
+);
+}
+function createSyntheticModule(vm, specifier, namespace) {
+	const source = namespace && typeof namespace === "object" ? namespace : { default: namespace };
+	const exportNames = new Set(Object.keys(source));
+	exportNames.add("default");
+	const syntheticModule = new vm.SyntheticModule([...exportNames], () => {
+		for (const exportName of exportNames) if (exportName === "default") syntheticModule.setExport("default", source.default !== void 0 ? source.default : namespace);
+		else syntheticModule.setExport(exportName, source[exportName]);
+	}, { identifier: `mf-shared:${specifier}` });
+	return syntheticModule;
+}
+const httpModuleCache = /* @__PURE__ */ new Map();
+const namespaceCache = /* @__PURE__ */ new Map();
+function getBodyPreview(body) {
+	return body.slice(0, 240).replace(/\s+/g, " ").trim();
+}
+async function fetchModuleSource(url) {
+	const res = await fetch(url);
+	const text = await res.text();
+	if (!res.ok) throw new SsrEntryHttpError(url, res.status, res.statusText, getBodyPreview(text));
+	return neutralizeBrowserPreloadHelpers(text);
+}
+function isHttpUrl(value) {
+	return value.startsWith("http://") || value.startsWith("https://");
+}
+/** Resolve a specifier against the referencing module's URL; null for bare specifiers. */
+function resolveSpecifierUrl(specifier, referencerUrl) {
+	if (isHttpUrl(specifier)) return specifier;
+	if (specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/")) return new URL(specifier, referencerUrl).href;
+	return null;
+}
+function getHttpModule(vm, url, options) {
+	const cacheKey = `${options.versionKey}::${url}`;
+	if (!httpModuleCache.has(cacheKey)) httpModuleCache.set(cacheKey, (async () => {
+		const code = await fetchModuleSource(url);
+		return new vm.SourceTextModule(code, {
+			identifier: url,
+			initializeImportMeta(meta) {
+				meta.url = url;
+			},
+			importModuleDynamically: (specifier, referencingModule) => importDynamically(vm, specifier, referencingModule, options)
+		});
+	})().catch((error) => {
+		httpModuleCache.delete(cacheKey);
+		throw error;
+	}));
+	return httpModuleCache.get(cacheKey);
+}
+async function linkModule(vm, specifier, referencingModule, options) {
+	const url = resolveSpecifierUrl(specifier, referencingModule.identifier);
+	if (url) return getHttpModule(vm, url, options);
+	return createSyntheticModule(vm, specifier, await loadBareModule(specifier, options));
+}
+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);
+	if (module.status === "linked") await module.evaluate();
+	return module;
+}
+/**
+* Load and evaluate a remote SSR entry as a `vm.SourceTextModule` graph and
+* return its namespace (the federation container with `init`/`get`).
+* Returns null when the vm module APIs are unavailable.
+*/
+async function loadViaVmStrategy(entryUrl, options) {
+	const vm = await getVmApi();
+	if (!vm) return null;
+	const cacheKey = `${options.versionKey}::${entryUrl}`;
+	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);
+		if (entryModule.status === "linked") await entryModule.evaluate();
+		return entryModule.namespace;
+	})().catch((error) => {
+		namespaceCache.delete(cacheKey);
+		throw error;
+	}));
+	return namespaceCache.get(cacheKey);
+}
+//#endregion
+export { isVmStrategyAvailable, loadViaVmStrategy };

package/lib/utils/ssrEntryLoader.d.ts

@@ -8,7 +8,7 @@
  * `loadScriptNode` — if the hook returns a value, the runtime uses it directly.
  *
  * Strategy:
- *  - In Node (typeof window === 'undefined'), fetch the remote's mf-manifest.json
+ *  - In Node (detected through process.versions.node), fetch the remote's mf-manifest.json
  *    to discover the ssrRemoteEntry URL and its type.
  *  - ESM entry: use a dynamic `import()` — the SSR entry has no browser
  *    globals and all shared packages are external.
@@ -32,6 +32,29 @@ interface RemoteInfo {
   type?: string;
   entryGlobalName?: string;
 }
+declare class SsrEntryHttpError extends Error {
+  readonly url: string;
+  readonly status: number;
+  readonly statusText: string;
+  readonly bodyPreview: string;
+  constructor(url: string, status: number, statusText: string, bodyPreview: string);
+}
+/**
+ * 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.
+ *
+ * Note: the MF runtime keeps its own container/module caches per federation
+ * instance. This function best-effort clears the module caches of all global
+ * federation instances so re-renders load fresh remote modules, but hosts that
+ * hold direct references to previously loaded modules keep those references.
+ */
+declare function revalidate(remoteEntryUrl?: string): void;
+/**
+ * Neutralize browser-only preload machinery in Vite/Rolldown output so the
+ * code can evaluate in Node. Shared by the temp-file and vm strategies.
+ */
+declare function neutralizeBrowserPreloadHelpers(code: string): string;
 /**
  * MF runtime plugin factory.
  *
@@ -50,6 +73,33 @@ interface SsrEntryLoaderOptions {
    * in remote SSR entry temp files — no runtime createRequire walk-up needed.
    */
   resolvedShared?: Record<string, string>;
+  /**
+   * How to evaluate remote SSR entries on the server.
+   *
+   * - `'temp-file'` (default): fetch the ESM graph, rewrite specifiers, write
+   *   temp files and `import()` them. Works on stock Node; shared packages are
+   *   pinned to the host's copies via `resolvedShared` (no version negotiation).
+   * - `'vm'`: evaluate the graph with `vm.SourceTextModule` and link bare
+   *   shared imports through the host's federation share scope (`loadShare`),
+   *   restoring version negotiation. Requires `--experimental-vm-modules`;
+   *   falls back to `'temp-file'` when unavailable.
+   */
+  strategy?: 'temp-file' | 'vm';
+  /**
+   * Share scope consulted by the `'vm'` strategy when linking bare imports.
+   * Defaults to `'default'`.
+   */
+  shareScopeName?: string;
+  /**
+   * Re-check each remote's manifest when the cached SSR entry resolution is
+   * older than this many milliseconds. When the manifest's version changes
+   * (remote redeployed at the same URL), the loader drops its caches for that
+   * remote so subsequent loads use the new build. Omit to cache until process
+   * exit or an explicit `revalidate()` call. Only manifest-resolved entries
+   * can be revalidated this way — convention-resolved entries have no version
+   * source.
+   */
+  maxAgeMs?: number;
 }
 declare function ssrEntryLoaderPlugin(options?: SsrEntryLoaderOptions): {
   name: string;
@@ -63,4 +113,4 @@ declare function ssrEntryLoaderPlugin(options?: SsrEntryLoaderOptions): {
   } | undefined>;
 };
 //#endregion
-export { ssrEntryLoaderPlugin as default };
+export { SsrEntryHttpError, ssrEntryLoaderPlugin as default, neutralizeBrowserPreloadHelpers, revalidate };

package/lib/utils/ssrEntryLoader.js

@@ -8,7 +8,7 @@
 * `loadScriptNode` — if the hook returns a value, the runtime uses it directly.
 *
 * Strategy:
-*  - In Node (typeof window === 'undefined'), fetch the remote's mf-manifest.json
+*  - In Node (detected through process.versions.node), fetch the remote's mf-manifest.json
 *    to discover the ssrRemoteEntry URL and its type.
 *  - ESM entry: use a dynamic `import()` — the SSR entry has no browser
 *    globals and all shared packages are external.
@@ -34,6 +34,7 @@ async function nodeImport(id) {
 ));
 	return importCache.get(id);
 }
+const isNodeServer = () => typeof globalThis.process?.versions?.node === "string";
 const runnerCache = /* @__PURE__ */ new Map();
 /**
 * Import `vite/module-runner` dynamically. Returns null on Vite < 8 where the
@@ -69,10 +70,7 @@ async function getOrCreateRunner(remoteOrigin) {
 					return await (await fetch(runnerEndpoint, {
 						method: "POST",
 						headers: { "Content-Type": "application/json" },
-						body: JSON.stringify({
-							name: payload.data.name,
-							data: payload.data.data
-						})
+						body: JSON.stringify(payload)
 					})).json();
 				} }
 			}, new ESModulesEvaluator());
@@ -87,6 +85,27 @@ const _path = () => nodeImport("path");
 const _fs = () => nodeImport("fs");
 const _crypto = () => nodeImport("crypto");
 const _module = () => nodeImport("module");
+/**
+* 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.
+*/
+const UNVERSIONED = "unversioned";
+function hashString(value) {
+	let hash = 2166136261;
+	for (let i = 0; i < value.length; i++) {
+		hash ^= value.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function computeManifestVersionKey(manifest) {
+	const buildVersion = manifest.metaData?.buildInfo?.buildVersion;
+	const contentHash = hashString(JSON.stringify(manifest));
+	return buildVersion ? `${buildVersion}-${contentHash}` : contentHash;
+}
 const ssrEntryCache = /* @__PURE__ */ new Map();
 const manifestFetchCache = /* @__PURE__ */ new Map();
 var SsrEntryHttpError = class extends Error {
@@ -148,7 +167,8 @@ function resolveSSREntryUrl(manifest, manifestUrl) {
 	const entryPath = (meta.ssrRemoteEntry.path || "") + meta.ssrRemoteEntry.name;
 	return {
 		url: new URL(entryPath, base).href,
-		type: meta.ssrRemoteEntry.type || "module"
+		type: meta.ssrRemoteEntry.type || "module",
+		versionKey: computeManifestVersionKey(manifest)
 	};
 }
 /**
@@ -190,14 +210,17 @@ function buildSsrEntryCandidates(ctx, options = {}) {
 	const candidates = [];
 	if (!options.skipServerBuild) candidates.push({
 		url: `${remoteOrigin}/__mf_server__/${filename}.ssr.js`,
-		type: "module"
+		type: "module",
+		versionKey: UNVERSIONED
 	});
 	candidates.push({
 		url: `${base}.ssr.js`,
-		type: "module"
+		type: "module",
+		versionKey: UNVERSIONED
 	}, {
 		url: `${remoteOrigin}/__mf_ssr__/${filename}.ssr.js`,
-		type: "module"
+		type: "module",
+		versionKey: UNVERSIONED
 	});
 	return candidates;
 }
@@ -211,13 +234,15 @@ async function resolveFirstReachableCandidate(candidates) {
 async function resolveSSREntryImpl(remoteEntryUrl) {
 	if (isSsrEntry(remoteEntryUrl)) return {
 		url: remoteEntryUrl,
-		type: "module"
+		type: "module",
+		versionKey: UNVERSIONED
 	};
 	if (!isManifestEntry(remoteEntryUrl)) {
 		const filename = getEntryFilename(remoteEntryUrl);
 		const fromServerBuild = await headCheckSsrEntry({
 			url: `${remoteEntryUrl.replace(/\/[^/]+$/, "")}/__mf_server__/${filename}.ssr.js`,
-			type: "module"
+			type: "module",
+			versionKey: UNVERSIONED
 		});
 		if (fromServerBuild) return fromServerBuild;
 	}
@@ -228,9 +253,63 @@ async function resolveSSREntryImpl(remoteEntryUrl) {
 	}
 	return resolveFirstReachableCandidate(buildSsrEntryCandidates(ctx, { skipServerBuild: !isManifestEntry(remoteEntryUrl) }));
 }
-async function getSSREntry(remoteEntryUrl) {
-	if (!ssrEntryCache.has(remoteEntryUrl)) ssrEntryCache.set(remoteEntryUrl, resolveSSREntryImpl(remoteEntryUrl));
-	return ssrEntryCache.get(remoteEntryUrl);
+function setSsrEntryCache(remoteEntryUrl) {
+	const record = {
+		promise: resolveSSREntryImpl(remoteEntryUrl),
+		resolvedAt: Date.now()
+	};
+	ssrEntryCache.set(remoteEntryUrl, record);
+	return record;
+}
+async function getSSREntry(remoteEntryUrl, maxAgeMs) {
+	const cached = ssrEntryCache.get(remoteEntryUrl);
+	if (!cached) return setSsrEntryCache(remoteEntryUrl).promise;
+	if (!(typeof maxAgeMs === "number" && maxAgeMs >= 0 && Date.now() - cached.resolvedAt >= maxAgeMs)) return cached.promise;
+	const previous = await cached.promise.catch(() => null);
+	manifestFetchCache.delete(getManifestUrl(remoteEntryUrl));
+	const record = setSsrEntryCache(remoteEntryUrl);
+	const next = await record.promise.catch(() => null);
+	if (previous && next && previous.versionKey !== next.versionKey) dropRemoteCaches(remoteEntryUrl);
+	return record.promise;
+}
+/**
+* Drop per-remote 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.
+*/
+function dropRemoteCaches(remoteEntryUrl) {
+	let origin;
+	try {
+		origin = new URL(remoteEntryUrl).origin;
+	} catch {
+		return;
+	}
+	for (const key of tempFileCache.keys()) if (key.slice(key.indexOf("::") + 2).startsWith(origin)) tempFileCache.delete(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.
+*
+* Note: the MF runtime keeps its own container/module caches per federation
+* instance. This function best-effort clears the module caches of all global
+* federation instances so re-renders load fresh remote modules, but hosts that
+* hold direct references to previously loaded modules keep those references.
+*/
+function revalidate(remoteEntryUrl) {
+	if (remoteEntryUrl) {
+		ssrEntryCache.delete(remoteEntryUrl);
+		manifestFetchCache.delete(getManifestUrl(remoteEntryUrl));
+		dropRemoteCaches(remoteEntryUrl);
+	} else {
+		ssrEntryCache.clear();
+		manifestFetchCache.clear();
+		tempFileCache.clear();
+	}
+	const federation = globalThis.__FEDERATION__;
+	for (const instance of federation?.__INSTANCES__ ?? []) try {
+		instance?.moduleCache?.clear?.();
+	} catch {}
 }
 const tempFileCache = /* @__PURE__ */ new Map();
 let ssrCacheDirPromise;
@@ -251,14 +330,11 @@ async function getSSRCacheDir() {
 	})();
 	return ssrCacheDirPromise;
 }
-function transformSsrCode(code, base, sharedPkgMap) {
-	code = code.replace(/((?:from|export\s*\*\s*from)\s*)(["'`])(\.\.?\/[^"'`\s][^"'`]*)["'`]/g, (_m, prefix, _q, specifier) => `${prefix}"${new URL(specifier, base).href}"`);
-	code = code.replace(/(import\s*)(["'`])(\.\.?\/[^"'`\s][^"'`]*)["'`]/g, (_m, prefix, _q, specifier) => `${prefix}"${new URL(specifier, base).href}"`);
-	code = code.replace(/(import\s*\(\s*)(["'`])(\.\.?\/[^"'`\s][^"'`]*)["'`](\s*\))/g, (_m, prefix, _q, specifier, suffix) => `${prefix}"${new URL(specifier, base).href}"${suffix}`);
-	if (sharedPkgMap && sharedPkgMap.size > 0) code = code.replace(/(?:from|import\s*\()\s*(["'`])([^"'`./][^"'`]*)["'`]/g, (m, _q, specifier) => {
-		const resolved = sharedPkgMap.get(specifier);
-		return resolved ? m.replace(specifier, `file://${resolved}`) : m;
-	});
+/**
+* Neutralize browser-only preload machinery in Vite/Rolldown output so the
+* code can evaluate in Node. Shared by the temp-file and vm strategies.
+*/
+function neutralizeBrowserPreloadHelpers(code) {
 	code = code.replace(/import\s*\{([^}]*)\}\s*from\s*["'][^"']*preload-helper[^"']*["'];?/g, (_m, bindings) => {
 		return bindings.split(",").map((b) => {
 			const parts = b.trim().split(/\s+as\s+/);
@@ -269,6 +345,16 @@ function transformSsrCode(code, base, sharedPkgMap) {
 	code = code.replace(/\b([A-Za-z_$][\w$]*)\s*\(\s*\(\s*\)\s*=>\s*import\(([^)]*)\)\s*,\s*\[\]\s*\)/g, "import($2)");
 	return code;
 }
+function transformSsrCode(code, base, sharedPkgMap) {
+	code = code.replace(/((?:from|export\s*\*\s*from)\s*)(["'`])(\.\.?\/[^"'`\s][^"'`]*)["'`]/g, (_m, prefix, _q, specifier) => `${prefix}"${new URL(specifier, base).href}"`);
+	code = code.replace(/(import\s*)(["'`])(\.\.?\/[^"'`\s][^"'`]*)["'`]/g, (_m, prefix, _q, specifier) => `${prefix}"${new URL(specifier, base).href}"`);
+	code = code.replace(/(import\s*\(\s*)(["'`])(\.\.?\/[^"'`\s][^"'`]*)["'`](\s*\))/g, (_m, prefix, _q, specifier, suffix) => `${prefix}"${new URL(specifier, base).href}"${suffix}`);
+	if (sharedPkgMap && sharedPkgMap.size > 0) code = code.replace(/(?:from|import\s*\()\s*(["'`])([^"'`./][^"'`]*)["'`]/g, (m, _q, specifier) => {
+		const resolved = sharedPkgMap.get(specifier);
+		return resolved ? m.replace(specifier, `file://${resolved}`) : m;
+	});
+	return neutralizeBrowserPreloadHelpers(code);
+}
 function isVitePreloadHelperSpecifier(specifier) {
 	return specifier.includes("preload-helper");
 }
@@ -276,10 +362,15 @@ function isVitePreloadHelperSpecifier(specifier) {
 * 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
 * so that `import('file:///...temp.js')` can resolve them.
+*
+* `versionKey` participates in both the cache key and the temp file name, so
+* 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, sharedPkgMap) {
+async function fetchEsmToTempFile(url, tmpDir, visited, sharedPkgMap, versionKey = UNVERSIONED) {
+	const cacheKey = `${versionKey}::${url}`;
 	if (visited.has(url)) return visited.get(url);
-	if (tempFileCache.has(url)) return tempFileCache.get(url);
+	if (tempFileCache.has(cacheKey)) return tempFileCache.get(cacheKey);
 	const promise = (async () => {
 		const res = await fetch(url);
 		let code = await res.text();
@@ -291,7 +382,7 @@ async function fetchEsmToTempFile(url, tmpDir, visited, sharedPkgMap) {
 		while ((m = relRegex.exec(code)) !== null) if ((m[1].startsWith("./") || m[1].startsWith("../")) && !isVitePreloadHelperSpecifier(m[1])) relImports.push(new URL(m[1], 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, sharedPkgMap);
+			const tmpPath = await fetchEsmToTempFile(u, tmpDir, visited, sharedPkgMap, versionKey);
 			subMap.set(u, `file://${tmpPath}`);
 		}));
 		code = transformSsrCode(code, base, sharedPkgMap);
@@ -299,22 +390,36 @@ async function fetchEsmToTempFile(url, tmpDir, visited, sharedPkgMap) {
 		const { createHash } = await _crypto();
 		const { join } = await _path();
 		const { writeFileSync } = await _fs();
-		const tmpFile = join(tmpDir, `${createHash("sha1").update(url).digest("hex").slice(0, 12)}.js`);
+		const tmpFile = join(tmpDir, `${createHash("sha1").update(cacheKey).digest("hex").slice(0, 12)}.js`);
 		writeFileSync(tmpFile, code, "utf8");
 		visited.set(url, tmpFile);
 		return tmpFile;
 	})();
-	tempFileCache.set(url, promise);
+	tempFileCache.set(cacheKey, promise);
 	return promise;
 }
-async function importTempModule(filePath) {
-	return await import(
-		/* @vite-ignore */
-		filePath
-);
+async function importTempModule(filePath, versionKey) {
+	return await import(`${filePath}?v=${encodeURIComponent(versionKey)}`);
+}
+let warnedVmUnavailable = false;
+async function tryVmStrategy(ssrEntry, options) {
+	const { loadViaVmStrategy, isVmStrategyAvailable } = await import("../ssrVmStrategy-DtpfkCw1.js");
+	if (!await isVmStrategyAvailable()) {
+		if (!warnedVmUnavailable) {
+			warnedVmUnavailable = true;
+			console.warn("[mf-vite:ssr-entry-loader] strategy \"vm\" requires vm.SourceTextModule (run Node with --experimental-vm-modules); falling back to the temp-file strategy.");
+		}
+		return null;
+	}
+	return await loadViaVmStrategy(ssrEntry.url, {
+		resolvedShared: options.resolvedShared,
+		shareScopeName: options.shareScopeName,
+		versionKey: ssrEntry.versionKey
+	});
 }
-async function loadSSRRemoteEntry(ssrEntry, resolvedShared = {}) {
-	const { url, type } = ssrEntry;
+async function loadSSRRemoteEntry(ssrEntry, options) {
+	const { url, type, versionKey } = ssrEntry;
+	const { resolvedShared } = options;
 	if (type === "commonjs-module" || type === "commonjs") {
 		const { createRequire } = await _module();
 		const req = createRequire(import.meta.url);
@@ -337,12 +442,18 @@ async function loadSSRRemoteEntry(ssrEntry, resolvedShared = {}) {
 				if (process.env.NODE_ENV !== "production") return null;
 			}
 		}
+		if (options.strategy === "vm") try {
+			const fromVm = await tryVmStrategy(ssrEntry, options);
+			if (fromVm) return fromVm;
+		} catch (error) {
+			if (isSsrEntryHttpError(error)) throw error;
+		}
 		const { mkdirSync } = await _fs();
 		const cacheDir = await getSSRCacheDir();
 		mkdirSync(cacheDir, { recursive: true });
 		const sharedPkgMap = new Map(Object.entries(resolvedShared));
 		try {
-			return await importTempModule(await fetchEsmToTempFile(url, cacheDir, /* @__PURE__ */ new Map(), sharedPkgMap));
+			return await importTempModule(await fetchEsmToTempFile(url, cacheDir, /* @__PURE__ */ new Map(), sharedPkgMap, versionKey), versionKey);
 		} catch (error) {
 			if (isSsrEntryHttpError(error)) throw error;
 			return null;
@@ -358,18 +469,23 @@ async function loadSSRRemoteEntry(ssrEntry, resolvedShared = {}) {
 	}
 }
 function ssrEntryLoaderPlugin(options = {}) {
-	const resolvedShared = options.resolvedShared ?? {};
+	const resolved = {
+		resolvedShared: options.resolvedShared ?? {},
+		strategy: options.strategy ?? "temp-file",
+		shareScopeName: options.shareScopeName ?? "default",
+		maxAgeMs: options.maxAgeMs
+	};
 	return {
 		name: "mf-vite:ssr-entry-loader",
 		async loadEntry({ remoteInfo }) {
-			if (typeof globalThis.window !== "undefined") return;
-			const ssrEntry = await getSSREntry(remoteInfo.entry);
+			if (!isNodeServer()) return;
+			const ssrEntry = await getSSREntry(remoteInfo.entry, resolved.maxAgeMs);
 			if (!ssrEntry) return;
-			const mod = await loadSSRRemoteEntry(ssrEntry, resolvedShared);
+			const mod = await loadSSRRemoteEntry(ssrEntry, resolved);
 			if (!mod) return;
 			return mod;
 		}
 	};
 }
 //#endregion
-export { ssrEntryLoaderPlugin as default };
+export { SsrEntryHttpError, ssrEntryLoaderPlugin as default, neutralizeBrowserPreloadHelpers, revalidate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/vite",
-  "version": "1.16.11",
+  "version": "1.16.13",
   "description": "Vite plugin for Module Federation",
   "type": "module",
   "main": "./lib/index.js",
@@ -86,4 +86,4 @@
     "vite": "8.1.0",
     "vitest": "4.0.18"
   }
-}
+}