@module-federation/vite 1.17.0 → 1.18.0

package/lib/{ssrVmStrategy-DtpfkCw1.js → ssrVmStrategy-ChF8MB7l.js}

@@ -1,4 +1,4 @@
-import { SsrEntryHttpError, neutralizeBrowserPreloadHelpers } from "./utils/ssrEntryLoader.js";
+import { n as neutralizeBrowserPreloadHelpers, o as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-DgsCQOqq.js";
 //#region src/utils/ssrVmStrategy.ts
 /**
 * vm.SourceTextModule strategy for loading remote SSR entries.
@@ -47,9 +47,13 @@ function getFederationInstances() {
 * build-time resolvedShared file map, then plain host import.
 */
 async function loadBareModule(specifier, options) {
-	for (const instance of getFederationInstances()) {
+	const owner = options.federationInstance;
+	const instances = owner ? [owner] : getFederationInstances();
+	for (const instance of instances) {
 		if (typeof instance?.loadShare !== "function") continue;
-		if (!instance.options?.shared || !(specifier in instance.options.shared)) continue;
+		const shared = instance.options?.shared?.[specifier];
+		if (!shared) continue;
+		if (!(Array.isArray(shared.scope) ? shared.scope : [shared.scope ?? "default"]).includes(options.shareScopeName)) continue;
 		try {
 			const factory = await instance.loadShare(specifier);
 			if (typeof factory === "function") {
@@ -80,11 +84,28 @@ function createSyntheticModule(vm, specifier, namespace) {
 }
 const httpModuleCache = /* @__PURE__ */ new Map();
 const namespaceCache = /* @__PURE__ */ new Map();
+const contextIds = /* @__PURE__ */ new WeakMap();
+let nextContextId = 1;
+function getContextId(context) {
+	let id = contextIds.get(context);
+	if (id === void 0) {
+		id = nextContextId++;
+		contextIds.set(context, id);
+	}
+	return id;
+}
+function getVmCacheContextKey(options) {
+	return JSON.stringify([
+		getContextId(options.cacheContext),
+		options.shareScopeName,
+		Object.entries(options.resolvedShared).sort(([left], [right]) => left.localeCompare(right))
+	]);
+}
 function getBodyPreview(body) {
 	return body.slice(0, 240).replace(/\s+/g, " ").trim();
 }
-async function fetchModuleSource(url) {
-	const res = await fetch(url);
+async function fetchModuleSource(url, fetchTimeoutMs) {
+	const res = await fetchWithTimeout(url, {}, fetchTimeoutMs);
 	const text = await res.text();
 	if (!res.ok) throw new SsrEntryHttpError(url, res.status, res.statusText, getBodyPreview(text));
 	return neutralizeBrowserPreloadHelpers(text);
@@ -99,9 +120,14 @@ function resolveSpecifierUrl(specifier, referencerUrl) {
 	return null;
 }
 function getHttpModule(vm, url, options) {
-	const cacheKey = `${options.versionKey}::${url}`;
+	const cacheKey = JSON.stringify([
+		getVmCacheContextKey(options),
+		options.fetchTimeoutMs ?? 1e4,
+		options.versionKey,
+		url
+	]);
 	if (!httpModuleCache.has(cacheKey)) httpModuleCache.set(cacheKey, (async () => {
-		const code = await fetchModuleSource(url);
+		const code = await fetchModuleSource(url, options.fetchTimeoutMs);
 		return new vm.SourceTextModule(code, {
 			identifier: url,
 			initializeImportMeta(meta) {
@@ -135,7 +161,7 @@ async function importDynamically(vm, specifier, referencingModule, options) {
 async function loadViaVmStrategy(entryUrl, options) {
 	const vm = await getVmApi();
 	if (!vm) return null;
-	const cacheKey = `${options.versionKey}::${entryUrl}`;
+	const cacheKey = `${getVmCacheContextKey(options)}::${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);

package/lib/utils/ssrEntryLoader.d.ts

@@ -100,13 +100,20 @@ interface SsrEntryLoaderOptions {
    * source.
    */
   maxAgeMs?: number;
+  /**
+   * Maximum time in milliseconds for each SSR network request. Defaults to
+   * 10 seconds. Set to `0` to disable the timeout.
+   */
+  fetchTimeoutMs?: number;
 }
 declare function ssrEntryLoaderPlugin(options?: SsrEntryLoaderOptions): {
   name: string;
   loadEntry({
-    remoteInfo
+    remoteInfo,
+    origin
   }: {
     remoteInfo: RemoteInfo;
+    origin?: object;
   }): Promise<{
     init: unknown;
     get: unknown;

package/lib/utils/ssrEntryLoader.js

@@ -1,491 +1,2 @@
-//#region src/utils/ssrEntryLoader.ts
-/**
-* MF runtime plugin that intercepts the `loadEntry` lifecycle hook on the
-* server and loads the SSR-compatible remote entry instead of the browser one.
-*
-* This completely replaces the need for any `@module-federation/sdk` patches.
-* The `loadEntry` hook is emitted by `runtime-core` before it falls through to
-* `loadScriptNode` — if the hook returns a value, the runtime uses it directly.
-*
-* Strategy:
-*  - 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.
-*  - Dev mode (Vite 8+ only): use `ModuleRunner` with an HTTP transport backed
-*    by the remote's `/__mf_runner__` endpoint. This fetches fully-transformed
-*    module source through Vite's plugin pipeline, avoiding serialisation which
-*    cannot faithfully represent React components or closures.
-*
-*    Dev mode on Vite < 8 is NOT supported — `ModuleRunner` and
-*    `FetchableDevEnvironment` are Vite 8+ APIs. If you need dev-mode SSR on
-*    an older Vite version, implement an alternative loader in `loadSSRRemoteEntry`
-*    for the `isDevSsrEntry` branch and expose a corresponding server endpoint
-*    from `pluginSSRRemoteEntry.configureServer`.
-*
-* Exported as a plain factory function so it can be serialised into the
-* generated runtimePlugins list in virtualRemotes.ts.
-*/
-const importCache = /* @__PURE__ */ new Map();
-async function nodeImport(id) {
-	if (!importCache.has(id)) importCache.set(id, import(
-		/* @vite-ignore */
-		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
-* subpath doesn't exist. Uses a plain dynamic import (not nodeImport) so that
-* Vitest can intercept it with vi.mock in tests.
-*/
-async function getModuleRunnerModule() {
-	try {
-		return await import("vite/module-runner");
-	} catch {
-		return null;
-	}
-}
-/**
-* Create a ModuleRunner that fetches modules from a remote Vite dev server's
-* `/__mf_runner__` endpoint. Each HTTP POST carries a `fetchModule` invoke
-* payload; the remote responds with the transformed module source as JSON.
-*
-* This is Vite 8+ only — older versions don't expose `vite/module-runner` or
-* the `/__mf_runner__` proxy endpoint.
-*/
-async function getOrCreateRunner(remoteOrigin) {
-	if (runnerCache.has(remoteOrigin)) return runnerCache.get(remoteOrigin);
-	const promise = (async () => {
-		const viteRunner = await getModuleRunnerModule();
-		if (!viteRunner) return null;
-		const { ModuleRunner, ESModulesEvaluator } = viteRunner;
-		const runnerEndpoint = `${remoteOrigin}/__mf_runner__`;
-		try {
-			return new ModuleRunner({
-				hmr: false,
-				transport: { async invoke(payload) {
-					return await (await fetch(runnerEndpoint, {
-						method: "POST",
-						headers: { "Content-Type": "application/json" },
-						body: JSON.stringify(payload)
-					})).json();
-				} }
-			}, new ESModulesEvaluator());
-		} catch {
-			return null;
-		}
-	})();
-	runnerCache.set(remoteOrigin, promise);
-	return promise;
-}
-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 {
-	constructor(url, status, statusText, bodyPreview) {
-		super(`Failed to fetch SSR module "${url}": ${status} ${statusText}` + (bodyPreview ? `\npreview: ${bodyPreview}` : ""));
-		this.url = url;
-		this.status = status;
-		this.statusText = statusText;
-		this.bodyPreview = bodyPreview;
-		this.name = "SsrEntryHttpError";
-	}
-};
-function getBodyPreview(body) {
-	return body.slice(0, 240).replace(/\s+/g, " ").trim();
-}
-function isSsrEntryHttpError(error) {
-	return error instanceof SsrEntryHttpError;
-}
-async function fetchManifest(manifestUrl) {
-	try {
-		const res = await fetch(manifestUrl);
-		if (!res.ok) return null;
-		return await res.json();
-	} catch {
-		return null;
-	}
-}
-async function fetchManifestCached(manifestUrl) {
-	if (!manifestFetchCache.has(manifestUrl)) manifestFetchCache.set(manifestUrl, fetchManifest(manifestUrl));
-	return manifestFetchCache.get(manifestUrl);
-}
-/** True when the host configured a manifest URL as the remote entry (any .json name). */
-function isManifestEntry(remoteEntryUrl) {
-	try {
-		const { pathname } = new URL(remoteEntryUrl);
-		return /\.json$/i.test(pathname);
-	} catch {
-		return /\.json(?:[?#]|$)/i.test(remoteEntryUrl);
-	}
-}
-function isSsrEntry(remoteEntryUrl) {
-	return /\.ssr\.js(?:[?#].*)?$/.test(remoteEntryUrl);
-}
-function getManifestUrl(remoteEntryUrl) {
-	if (isManifestEntry(remoteEntryUrl)) return remoteEntryUrl;
-	return remoteEntryUrl.replace(/\/[^/]+$/, "/mf-manifest.json");
-}
-function getEntryFilename(entryUrl) {
-	return entryUrl.split("/").pop()?.replace(/[?#].*$/, "").replace(/\.[^.]+$/, "") ?? "remoteEntry";
-}
-function resolveEntryAssetUrl(entry, manifestUrl) {
-	const base = manifestUrl.replace(/\/[^/]+$/, "/");
-	return new URL(`${entry.path || ""}${entry.name}`, base).href;
-}
-function resolveSSREntryUrl(manifest, manifestUrl) {
-	const meta = manifest?.metaData;
-	if (!meta?.ssrRemoteEntry?.name) return null;
-	const base = manifestUrl.replace(/\/[^/]+$/, "/");
-	const entryPath = (meta.ssrRemoteEntry.path || "") + meta.ssrRemoteEntry.name;
-	return {
-		url: new URL(entryPath, base).href,
-		type: meta.ssrRemoteEntry.type || "module",
-		versionKey: computeManifestVersionKey(manifest)
-	};
-}
-/**
-* Derive the SSR entry URL by convention when no manifest is available.
-* remoteEntry.js → remoteEntry.ssr.js
-* remoteEntry.js → /__mf_ssr__/remoteEntry.ssr.js (dev middleware)
-* Returns the first URL that responds with a 200.
-*/
-async function headCheckSsrEntry(candidate) {
-	try {
-		const res = await fetch(candidate.url, { method: "HEAD" });
-		const ct = res.headers.get("content-type") ?? "";
-		if (res.ok && !ct.includes("text/html")) return candidate;
-	} catch {}
-	return null;
-}
-function resolveAssetBaseUrl(entryUrl, manifest, manifestUrl) {
-	const remoteEntry = manifest?.metaData?.remoteEntry;
-	if (remoteEntry?.name) return resolveEntryAssetUrl(remoteEntry, manifestUrl);
-	if (!isManifestEntry(entryUrl)) return entryUrl;
-	return new URL("remoteEntry.js", manifestUrl.replace(/\/[^/]+$/, "/")).href;
-}
-async function buildEntryContext(entryUrl) {
-	const manifestUrl = getManifestUrl(entryUrl);
-	const manifest = await fetchManifestCached(manifestUrl);
-	const assetBaseUrl = resolveAssetBaseUrl(entryUrl, manifest, manifestUrl);
-	return {
-		entryUrl,
-		manifestUrl,
-		manifest,
-		assetBaseUrl,
-		filename: getEntryFilename(assetBaseUrl),
-		remoteOrigin: assetBaseUrl.replace(/\/[^/]+$/, "")
-	};
-}
-function buildSsrEntryCandidates(ctx, options = {}) {
-	const { assetBaseUrl, filename, remoteOrigin } = ctx;
-	const base = assetBaseUrl.replace(/\.[^.]+$/, "");
-	const candidates = [];
-	if (!options.skipServerBuild) candidates.push({
-		url: `${remoteOrigin}/__mf_server__/${filename}.ssr.js`,
-		type: "module",
-		versionKey: UNVERSIONED
-	});
-	candidates.push({
-		url: `${base}.ssr.js`,
-		type: "module",
-		versionKey: UNVERSIONED
-	}, {
-		url: `${remoteOrigin}/__mf_ssr__/${filename}.ssr.js`,
-		type: "module",
-		versionKey: UNVERSIONED
-	});
-	return candidates;
-}
-async function resolveFirstReachableCandidate(candidates) {
-	for (const candidate of candidates) {
-		const hit = await headCheckSsrEntry(candidate);
-		if (hit) return hit;
-	}
-	return null;
-}
-async function resolveSSREntryImpl(remoteEntryUrl) {
-	if (isSsrEntry(remoteEntryUrl)) return {
-		url: remoteEntryUrl,
-		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",
-			versionKey: UNVERSIONED
-		});
-		if (fromServerBuild) return fromServerBuild;
-	}
-	const ctx = await buildEntryContext(remoteEntryUrl);
-	if (ctx.manifest) {
-		const fromManifest = resolveSSREntryUrl(ctx.manifest, ctx.manifestUrl);
-		if (fromManifest) return fromManifest;
-	}
-	return resolveFirstReachableCandidate(buildSsrEntryCandidates(ctx, { skipServerBuild: !isManifestEntry(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;
-async function getSSRCacheDir() {
-	if (!ssrCacheDirPromise) ssrCacheDirPromise = (async () => {
-		const { join } = await _path();
-		const { rmSync } = await _fs();
-		const dir = join(process.cwd(), "node_modules", ".ssr-cache");
-		process.once("exit", () => {
-			try {
-				rmSync(dir, {
-					recursive: true,
-					force: true
-				});
-			} catch {}
-		});
-		return dir;
-	})();
-	return ssrCacheDirPromise;
-}
-/**
-* 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+/);
-			return (parts[1] ?? parts[0]).trim();
-		}).filter(Boolean).map((l) => `const ${l} = (fn) => fn();`).join("\n");
-	});
-	code = code.replace(/__vite__mapDeps\([^)]+\)/g, "[]");
-	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");
-}
-/**
-* 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, versionKey = UNVERSIONED) {
-	const cacheKey = `${versionKey}::${url}`;
-	if (visited.has(url)) return visited.get(url);
-	if (tempFileCache.has(cacheKey)) return tempFileCache.get(cacheKey);
-	const promise = (async () => {
-		const res = await fetch(url);
-		let code = await res.text();
-		if (!res.ok) throw new SsrEntryHttpError(url, res.status, res.statusText, getBodyPreview(code));
-		const base = url.replace(/\/[^/]*$/, "/");
-		const relImports = [];
-		const relRegex = /(?:from|export\s*\*\s*from|import\s*(?:\(|\s))\s*["'`]([^"'`\s]+)["'`]/g;
-		let m;
-		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, versionKey);
-			subMap.set(u, `file://${tmpPath}`);
-		}));
-		code = transformSsrCode(code, base, sharedPkgMap);
-		for (const [httpUrl, fileUrl] of subMap) code = code.split(httpUrl).join(fileUrl);
-		const { createHash } = await _crypto();
-		const { join } = await _path();
-		const { writeFileSync } = await _fs();
-		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(cacheKey, promise);
-	return promise;
-}
-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, 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);
-		try {
-			return req(url);
-		} catch {}
-	}
-	if (url.startsWith("http://") || url.startsWith("https://")) {
-		const urlObj = new URL(url);
-		if (urlObj.pathname.includes("/__mf_ssr__/")) {
-			const remoteOrigin = urlObj.origin;
-			const runner = await getOrCreateRunner(remoteOrigin);
-			if (!runner) {
-				if (process.env.NODE_ENV !== "production") return null;
-			} else try {
-				const mod = await runner.import(urlObj.pathname);
-				if (mod && typeof mod === "object" && "init" in mod) return mod;
-				if (process.env.NODE_ENV !== "production") return null;
-			} catch {
-				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, versionKey), versionKey);
-		} catch (error) {
-			if (isSsrEntryHttpError(error)) throw error;
-			return null;
-		}
-	}
-	try {
-		return await import(
-			/* @vite-ignore */
-			url
-);
-	} catch {
-		return null;
-	}
-}
-function ssrEntryLoaderPlugin(options = {}) {
-	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 (!isNodeServer()) return;
-			const ssrEntry = await getSSREntry(remoteInfo.entry, resolved.maxAgeMs);
-			if (!ssrEntry) return;
-			const mod = await loadSSRRemoteEntry(ssrEntry, resolved);
-			if (!mod) return;
-			return mod;
-		}
-	};
-}
-//#endregion
+import { i as ssrEntryLoaderPlugin, n as neutralizeBrowserPreloadHelpers, r as revalidate, t as SsrEntryHttpError } from "../ssrEntryLoader-DgsCQOqq.js";
 export { SsrEntryHttpError, ssrEntryLoaderPlugin as default, neutralizeBrowserPreloadHelpers, revalidate };

package/package.json

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