@module-federation/vite 1.16.3 → 1.16.5

package/lib/pluginDts-7EoFboCu.cjs

@@ -1,311 +0,0 @@
-const require_packageUtils = require("./packageUtils-se-UDhCa.cjs");
-let fs = require("fs");
-fs = require_packageUtils.__toESM(fs);
-let pathe = require("pathe");
-pathe = require_packageUtils.__toESM(pathe);
-let _module_federation_sdk = require("@module-federation/sdk");
-let _module_federation_dts_plugin = require("@module-federation/dts-plugin");
-let _module_federation_dts_plugin_core = require("@module-federation/dts-plugin/core");
-//#region src/plugins/pluginDts.ts
-const DEFAULT_DEV_OPTIONS = {
-	disableLiveReload: true,
-	disableHotTypesReload: false,
-	disableDynamicRemoteTypeHints: false
-};
-const DYNAMIC_HINTS_PLUGIN = "@module-federation/dts-plugin/dynamic-remote-type-hints-plugin";
-const getIPv4 = () => process.env["FEDERATION_IPV4"] || "127.0.0.1";
-const DEV_TYPES_FOLDER = ".dev-server";
-const DEFAULT_PUBLIC_TYPES_FOLDER = "@mf-types";
-const forkDevWorkerPath = require.resolve("@module-federation/dts-plugin/dist/fork-dev-worker.js");
-var DevWorker = class {
-	worker = _module_federation_dts_plugin_core.rpc.createRpcWorker(forkDevWorkerPath, {}, void 0, false);
-	constructor(options) {
-		this.worker.connect(options);
-	}
-	update() {
-		this.worker.process?.send?.({
-			type: _module_federation_dts_plugin_core.rpc.RpcGMCallTypes.CALL,
-			id: this.worker.id,
-			args: [void 0, "update"]
-		});
-	}
-	exit() {
-		this.worker.terminate();
-	}
-};
-const normalizeDevOptions = (dev) => {
-	if (dev === false) return false;
-	if (dev === true || typeof dev === "undefined") return { ...DEFAULT_DEV_OPTIONS };
-	return {
-		...DEFAULT_DEV_OPTIONS,
-		...dev
-	};
-};
-const buildDtsModuleFederationConfig = (options) => {
-	const exposes = {};
-	Object.entries(options.exposes).forEach(([key, value]) => {
-		if (value.import) exposes[key] = value.import;
-	});
-	const remotes = {};
-	Object.entries(options.remotes).forEach(([key, remote]) => {
-		if (!remote.entry) return;
-		remotes[key] = `${remote.entryGlobalName?.startsWith("http") || remote.entryGlobalName?.includes(".json") ? remote.name || key : remote.entryGlobalName || remote.name || key}@${remote.entry}`;
-	});
-	return {
-		...options,
-		exposes,
-		remotes
-	};
-};
-const resolveOutputDir = (config) => {
-	const { outDir } = config.build;
-	if (pathe.isAbsolute(outDir)) return pathe.relative(config.root, outDir);
-	return outDir;
-};
-const ensureRuntimePlugin = (options, pluginId) => {
-	if (!options.runtimePlugins.some((plugin) => {
-		if (typeof plugin === "string") return plugin === pluginId;
-		return plugin[0] === pluginId;
-	})) options.runtimePlugins.push(pluginId);
-};
-const getExposeImportPaths = (options) => {
-	return Object.values(options.exposes).map((value) => {
-		return value.import;
-	}).filter((value) => Boolean(value));
-};
-const usesVueSfcExposes = (options) => {
-	return getExposeImportPaths(options).some((value) => value.endsWith(".vue"));
-};
-const resolveDtsPluginOptions = (dts, options, context) => {
-	if (dts === false) return false;
-	const inferredGenerateTypesDefaults = { generateAPITypes: true };
-	if (usesVueSfcExposes(options) && require_packageUtils.hasPackageDependency("vue-tsc", context)) inferredGenerateTypesDefaults.compilerInstance = "vue-tsc";
-	if (dts === true || typeof dts === "undefined") return { generateTypes: inferredGenerateTypesDefaults };
-	const generateTypes = dts.generateTypes;
-	return {
-		...dts,
-		generateTypes: generateTypes === false ? false : {
-			...inferredGenerateTypesDefaults,
-			...generateTypes === true || typeof generateTypes === "undefined" ? {} : generateTypes
-		}
-	};
-};
-const getBasePath = (base) => {
-	if (base.startsWith("http://") || base.startsWith("https://")) return new URL(base).pathname.replace(/\/$/, "") || "/";
-	return base.replace(/\/$/, "") || "/";
-};
-const joinBaseAndAsset = (base, assetFileName) => {
-	const basePath = getBasePath(base);
-	return `${basePath === "/" ? "" : basePath}/${assetFileName}`.replace(/\/{2,}/g, "/");
-};
-const getDevDtsAssetPaths = (options) => {
-	const { outputDir, publicTypesFolder, root, base } = options;
-	return {
-		apiFilePath: pathe.resolve(root, outputDir, `${DEV_TYPES_FOLDER}.d.ts`),
-		apiRequestPath: joinBaseAndAsset(base, `${publicTypesFolder}.d.ts`),
-		zipFilePath: pathe.resolve(root, outputDir, `${DEV_TYPES_FOLDER}.zip`),
-		zipRequestPath: joinBaseAndAsset(base, `${publicTypesFolder}.zip`)
-	};
-};
-const createDevDtsAssetMiddleware = (assetPaths) => {
-	return (req, res, next) => {
-		const requestPath = req.url?.split("?")[0];
-		const isZipRequest = requestPath === assetPaths.zipRequestPath;
-		const isApiRequest = requestPath === assetPaths.apiRequestPath;
-		if (!isZipRequest && !isApiRequest) {
-			next();
-			return;
-		}
-		const filePath = isZipRequest ? assetPaths.zipFilePath : assetPaths.apiFilePath;
-		if (!fs.default.existsSync(filePath)) {
-			res.statusCode = 404;
-			res.end();
-			return;
-		}
-		res.statusCode = 200;
-		res.setHeader("Content-Type", isZipRequest ? "application/x-gzip" : "application/typescript");
-		if (req.method === "HEAD") {
-			res.end();
-			return;
-		}
-		const stream = fs.default.createReadStream(filePath);
-		stream.on("error", () => {
-			if (!res.headersSent) res.statusCode = 500;
-			res.end();
-		});
-		res.on("close", () => {
-			stream.destroy();
-		});
-		stream.pipe(res);
-	};
-};
-const normalizeDevDtsOptions = (dts, context) => {
-	return (0, _module_federation_sdk.normalizeOptions)((0, _module_federation_dts_plugin.isTSProject)(dts, context), {
-		generateTypes: { compileInChildProcess: true },
-		consumeTypes: { consumeAPITypes: true },
-		extraOptions: {},
-		displayErrorInTerminal: typeof dts === "object" && dts ? dts.displayErrorInTerminal : void 0
-	}, "mfOptions.dts")(dts);
-};
-const logDtsError = (error, dtsOptions) => {
-	if (dtsOptions === false) return;
-	if (typeof dtsOptions === "object" && dtsOptions && dtsOptions.displayErrorInTerminal === false) return;
-	require_packageUtils.mfError(error);
-};
-function pluginDts(options) {
-	if (options.dts === false) return [];
-	const baseDtsModuleFederationConfig = buildDtsModuleFederationConfig(options);
-	const getDtsModuleFederationConfig = (context) => ({
-		...baseDtsModuleFederationConfig,
-		dts: resolveDtsPluginOptions(options.dts, options, context)
-	});
-	let resolvedConfig;
-	let devWorker;
-	let normalizedDevOptions;
-	let hasGeneratedBundle = false;
-	return [{
-		name: "module-federation-dts-dev",
-		apply: "serve",
-		config(config) {
-			normalizedDevOptions = normalizeDevOptions(options.dev);
-			if (!normalizedDevOptions) return;
-			if (normalizedDevOptions.disableDynamicRemoteTypeHints) return;
-			ensureRuntimePlugin(options, DYNAMIC_HINTS_PLUGIN);
-			const define = config.define ? { ...config.define } : {};
-			if (!("FEDERATION_IPV4" in define)) define.FEDERATION_IPV4 = JSON.stringify(getIPv4());
-			config.define = define;
-		},
-		configResolved(config) {
-			resolvedConfig = config;
-		},
-		configureServer(server) {
-			if (!normalizedDevOptions || !resolvedConfig) return;
-			const devOptions = normalizedDevOptions;
-			if (devOptions.disableDynamicRemoteTypeHints && devOptions.disableHotTypesReload && devOptions.disableLiveReload) return;
-			if (!options.name) throw require_packageUtils.createModuleFederationError("name is required if you want to enable dev server!");
-			const outputDir = resolveOutputDir(resolvedConfig);
-			const dtsModuleFederationConfig = getDtsModuleFederationConfig(resolvedConfig.root);
-			const normalizedDtsOptions = normalizeDevDtsOptions(dtsModuleFederationConfig.dts, resolvedConfig.root);
-			if (typeof normalizedDtsOptions !== "object") return;
-			const normalizedGenerateTypes = (0, _module_federation_sdk.normalizeOptions)(Boolean(normalizedDtsOptions), { compileInChildProcess: true }, "mfOptions.dts.generateTypes")(normalizedDtsOptions.generateTypes);
-			const remote = normalizedGenerateTypes === false ? void 0 : {
-				implementation: normalizedDtsOptions.implementation,
-				context: resolvedConfig.root,
-				outputDir,
-				moduleFederationConfig: { ...dtsModuleFederationConfig },
-				hostRemoteTypesFolder: normalizedGenerateTypes.typesFolder || DEFAULT_PUBLIC_TYPES_FOLDER,
-				...normalizedGenerateTypes,
-				typesFolder: DEV_TYPES_FOLDER
-			};
-			if (remote) server.middlewares.use(createDevDtsAssetMiddleware(getDevDtsAssetPaths({
-				outputDir,
-				publicTypesFolder: remote.hostRemoteTypesFolder || DEFAULT_PUBLIC_TYPES_FOLDER,
-				root: resolvedConfig.root,
-				base: resolvedConfig.base
-			})));
-			if (remote && !remote.tsConfigPath && normalizedDtsOptions.tsConfigPath) remote.tsConfigPath = normalizedDtsOptions.tsConfigPath;
-			const normalizedConsumeTypes = (0, _module_federation_sdk.normalizeOptions)(Boolean(normalizedDtsOptions), { consumeAPITypes: true }, "mfOptions.dts.consumeTypes")(normalizedDtsOptions.consumeTypes);
-			const host = normalizedConsumeTypes === false ? void 0 : {
-				implementation: normalizedDtsOptions.implementation,
-				context: resolvedConfig.root,
-				moduleFederationConfig: dtsModuleFederationConfig,
-				typesFolder: normalizedConsumeTypes.typesFolder || "@mf-types",
-				abortOnError: false,
-				...normalizedConsumeTypes
-			};
-			const extraOptions = normalizedDtsOptions.extraOptions || {};
-			if (!remote && !host && devOptions.disableLiveReload) return;
-			const startDevWorker = async () => {
-				let remoteTypeUrls;
-				if (host) remoteTypeUrls = await new Promise((resolve) => {
-					(0, _module_federation_dts_plugin.consumeTypesAPI)({
-						host,
-						extraOptions,
-						displayErrorInTerminal: normalizedDtsOptions.displayErrorInTerminal
-					}, resolve);
-				});
-				devWorker = new DevWorker({
-					name: options.name,
-					remote,
-					host: host ? {
-						...host,
-						remoteTypeUrls
-					} : void 0,
-					extraOptions,
-					disableLiveReload: devOptions.disableLiveReload,
-					disableHotTypesReload: devOptions.disableHotTypesReload
-				});
-				const update = () => devWorker?.update();
-				server.watcher.on("change", update);
-				server.watcher.on("add", update);
-				server.watcher.on("unlink", update);
-				server.httpServer?.once("close", () => {
-					devWorker?.exit();
-					server.watcher.off("change", update);
-					server.watcher.off("add", update);
-					server.watcher.off("unlink", update);
-				});
-			};
-			startDevWorker().catch((error) => {
-				logDtsError(error, normalizedDtsOptions);
-			});
-		}
-	}, {
-		name: "module-federation-dts-build",
-		apply: "build",
-		configResolved(config) {
-			resolvedConfig = config;
-		},
-		async generateBundle() {
-			if (hasGeneratedBundle) return;
-			hasGeneratedBundle = true;
-			if (!resolvedConfig) return;
-			let normalizedDtsOptions;
-			try {
-				normalizedDtsOptions = (0, _module_federation_dts_plugin.normalizeDtsOptions)(getDtsModuleFederationConfig(resolvedConfig.root), resolvedConfig.root);
-			} catch (error) {
-				logDtsError(error, options.dts);
-				return;
-			}
-			if (typeof normalizedDtsOptions !== "object") return;
-			const context = resolvedConfig.root;
-			const outputDir = resolveOutputDir(resolvedConfig);
-			let consumeOptions;
-			try {
-				consumeOptions = (0, _module_federation_dts_plugin.normalizeConsumeTypesOptions)({
-					context,
-					dtsOptions: normalizedDtsOptions,
-					pluginOptions: getDtsModuleFederationConfig(resolvedConfig.root)
-				});
-			} catch (error) {
-				logDtsError(error, normalizedDtsOptions);
-				return;
-			}
-			if (consumeOptions?.host?.typesOnBuild) try {
-				await (0, _module_federation_dts_plugin.consumeTypesAPI)(consumeOptions);
-			} catch (error) {
-				logDtsError(error, normalizedDtsOptions);
-			}
-			let generateOptions;
-			try {
-				generateOptions = (0, _module_federation_dts_plugin.normalizeGenerateTypesOptions)({
-					context,
-					outputDir,
-					dtsOptions: normalizedDtsOptions,
-					pluginOptions: getDtsModuleFederationConfig(resolvedConfig.root)
-				});
-			} catch (error) {
-				logDtsError(error, normalizedDtsOptions);
-				return;
-			}
-			if (!generateOptions) return;
-			try {
-				await (0, _module_federation_dts_plugin.generateTypesAPI)({ dtsManagerOptions: generateOptions });
-			} catch (error) {
-				logDtsError(error, normalizedDtsOptions);
-			}
-		}
-	}];
-}
-//#endregion
-exports.default = pluginDts;

package/lib/utils/ssrEntryLoader.cjs

@@ -1,301 +0,0 @@
-//#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 (typeof window === 'undefined'), 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 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({
-							name: payload.data.name,
-							data: payload.data.data
-						})
-					})).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");
-const manifestCache = /* @__PURE__ */ new Map();
-async function fetchManifest(manifestUrl) {
-	try {
-		const res = await fetch(manifestUrl);
-		if (!res.ok) return null;
-		return await res.json();
-	} catch {
-		return null;
-	}
-}
-function getManifestUrl(remoteEntryUrl) {
-	return remoteEntryUrl.replace(/\/[^/]+$/, "/mf-manifest.json");
-}
-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"
-	};
-}
-/**
-* 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;
-}
-async function getSSREntryByConvention(remoteEntryUrl, options = {}) {
-	const base = remoteEntryUrl.replace(/\.[^.]+$/, "");
-	const remoteOrigin = remoteEntryUrl.replace(/\/[^/]+$/, "");
-	const filename = remoteEntryUrl.split("/").pop()?.replace(/\.[^.]+$/, "") ?? "remoteEntry";
-	const candidates = [
-		...options.skipServerBuild ? [] : [{
-			url: `${remoteOrigin}/__mf_server__/${filename}.ssr.js`,
-			type: "module"
-		}],
-		{
-			url: `${base}.ssr.js`,
-			type: "module"
-		},
-		{
-			url: `${remoteOrigin}/__mf_ssr__/${filename}.ssr.js`,
-			type: "module"
-		}
-	];
-	for (const candidate of candidates) {
-		const hit = await headCheckSsrEntry(candidate);
-		if (hit) return hit;
-	}
-	return null;
-}
-async function getSSREntry(remoteEntryUrl) {
-	const remoteOrigin = remoteEntryUrl.replace(/\/[^/]+$/, "");
-	const filename = remoteEntryUrl.split("/").pop()?.replace(/\.[^.]+$/, "") ?? "remoteEntry";
-	const manifestUrl = getManifestUrl(remoteEntryUrl);
-	if (!manifestCache.has(manifestUrl)) manifestCache.set(manifestUrl, (async () => {
-		const fromServerBuild = await headCheckSsrEntry({
-			url: `${remoteOrigin}/__mf_server__/${filename}.ssr.js`,
-			type: "module"
-		});
-		if (fromServerBuild) return fromServerBuild;
-		const manifest = await fetchManifest(manifestUrl);
-		if (manifest) {
-			const fromManifest = resolveSSREntryUrl(manifest, manifestUrl);
-			if (fromManifest) return fromManifest;
-		}
-		return getSSREntryByConvention(remoteEntryUrl, { skipServerBuild: true });
-	})());
-	return manifestCache.get(manifestUrl);
-}
-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;
-}
-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;
-	});
-	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;
-}
-/**
-* Fetch an HTTP ESM module, transform it, write it to a temp .mjs file and
-* return the file path. Recursively does the same for HTTP transitive imports
-* so that `import('file:///...temp.mjs')` can resolve them.
-*/
-async function fetchEsmToTempFile(url, tmpDir, visited, sharedPkgMap) {
-	if (visited.has(url)) return visited.get(url);
-	if (tempFileCache.has(url)) return tempFileCache.get(url);
-	const promise = (async () => {
-		let code = await (await fetch(url)).text();
-		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("../")) 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);
-			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(url).digest("hex").slice(0, 12)}.mjs`);
-		writeFileSync(tmpFile, code, "utf8");
-		visited.set(url, tmpFile);
-		return tmpFile;
-	})();
-	tempFileCache.set(url, promise);
-	return promise;
-}
-async function importTempModule(filePath) {
-	return await import(
-		/* @vite-ignore */
-		filePath
-);
-}
-async function loadSSRRemoteEntry(ssrEntry, resolvedShared = {}) {
-	const { url, type } = ssrEntry;
-	if (type === "commonjs-module" || type === "commonjs") {
-		const { createRequire } = await _module();
-		const req = createRequire(require("url").pathToFileURL(__filename).href);
-		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) return null;
-			try {
-				return await runner.import(urlObj.pathname);
-			} catch {
-				return null;
-			}
-		}
-		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));
-		} catch {
-			return null;
-		}
-	}
-	try {
-		return await import(
-			/* @vite-ignore */
-			url
-);
-	} catch {
-		return null;
-	}
-}
-function ssrEntryLoaderPlugin(options = {}) {
-	const resolvedShared = options.resolvedShared ?? {};
-	return {
-		name: "mf-vite:ssr-entry-loader",
-		async loadEntry({ remoteInfo }) {
-			if (typeof globalThis.window !== "undefined") return;
-			const ssrEntry = await getSSREntry(remoteInfo.entry);
-			if (!ssrEntry) return;
-			const mod = await loadSSRRemoteEntry(ssrEntry, resolvedShared);
-			if (!mod) return;
-			return mod;
-		}
-	};
-}
-//#endregion
-module.exports = ssrEntryLoaderPlugin;

package/lib/utils/ssrEntryLoader.d.cts

@@ -1,65 +0,0 @@
-//#region src/utils/ssrEntryLoader.d.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 (typeof window === 'undefined'), 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.
- */
-interface RemoteInfo {
-  name: string;
-  entry: string;
-  type?: string;
-  entryGlobalName?: string;
-}
-/**
- * MF runtime plugin factory.
- *
- * Usage in runtimePlugins:
- *   import { ssrEntryLoaderPlugin } from '@module-federation/vite/ssrEntryLoader'
- *   federation({ runtimePlugins: [ssrEntryLoaderPlugin] })
- *
- * The plugin is also injected automatically for SSR contexts by the vite plugin.
- */
-interface SsrEntryLoaderOptions {
-  /**
-   * Pre-resolved absolute file paths for common shared packages, keyed by
-   * bare specifier. Populated at build time by the Vite plugin from the MF
-   * plugin's own installed location so the resolution is package-manager-
-   * agnostic. ssrEntryLoader uses these directly when rewriting bare specifiers
-   * in remote SSR entry temp files — no runtime createRequire walk-up needed.
-   */
-  resolvedShared?: Record<string, string>;
-}
-declare function ssrEntryLoaderPlugin(options?: SsrEntryLoaderOptions): {
-  name: string;
-  loadEntry({
-    remoteInfo
-  }: {
-    remoteInfo: RemoteInfo;
-  }): Promise<{
-    init: unknown;
-    get: unknown;
-  } | undefined>;
-};
-export = ssrEntryLoaderPlugin;