@module-federation/vite 1.22.0 → 1.23.0

package/README.md

@@ -119,6 +119,9 @@ export default defineConfig({
       // optional: additional "var" remoteEntry file
       // needed only for legacy hosts with "var" usage (remote.type = 'var')
       varFilename: "varRemoteEntry.js",
+      // optional: exact name of the SSR remote entry
+      // default: "<filename base>.ssr.js" (e.g. remoteEntry.ssr.js)
+      ssrFilename: "remoteEntry.ssr.js",
       exposes: {
         "./remote-app": "./src/App.vue",
       },
@@ -151,6 +154,18 @@ shared: {
 
 `suppressMissingImportWarning` defaults to `false`. Enable it only when the host is guaranteed to provide the dependency and local named-export detection is unnecessary.
 
+In a production build, a host-only dependency that the exposed modules reach only through a dynamic `import()` is not fetched while the remote initializes. It is loaded from the host's provider when that `import()` runs, before the imported chunk evaluates. A dependency imported statically by an exposed module, or configured with `eager: true`, is still loaded during initialization.
+
+### Shared dependencies installed in several places
+
+An absolute import that resolves inside a different `node_modules` directory than the one the share itself resolves to, for example a workspace package with its own nested copy, is not treated as the shared module by default. Set `allowNodeModulesSuffixMatch: true` on the share to match it by the path after `node_modules/`, as webpack and rspack do with the same option:
+
+```ts
+shared: {
+  react: { singleton: true, allowNodeModulesSuffixMatch: true },
+},
+```
+
 ## The Host Application configuration
 
 file **host/vite.config.ts**
@@ -263,6 +278,8 @@ federation({
 
 The `"vm"` strategy requires Node.js to run with `--experimental-vm-modules`. When unavailable, the loader warns once and falls back to `"temp-file"`. Vite 8 development uses `ModuleRunner`; this option primarily affects build and preview SSR entry loading.
 
+The SSR remote entry is emitted as `<filename base>.ssr.js` next to the browser entry, or under the exact name given by `ssrFilename`, and is advertised as `metaData.ssrRemoteEntry` in `mf-manifest.json`. It keeps `@module-federation/runtime`, `@module-federation/runtime-core` and `@module-federation/sdk` external by default so Node resolves them from the host. Hosts that cannot resolve those packages, such as a plain `@module-federation/enhanced` host using the SDK's reference Node loader, need a self-contained entry: opt the packages back in with Vite's `ssr.noExternal` (for example `ssr: { noExternal: true }`) on the remote.
+
 ## Runtime capability optimization
 
 Runtime features that a build never uses can be removed at build time:
@@ -389,7 +406,9 @@ The `externalRuntime` rewrite applies to the browser remote graph; SSR remote en
 
 Do not set `build.rollupOptions.output.codeSplitting` or
 `build.rolldownOptions.output.codeSplitting` to `false` — it will be **ignored** (with a warning).
-Module Federation requires chunk splitting so `runtimeInitStatus` and deferred `loadShare` wrappers stay isolated for correct bootstrap order. Eager `loadShare` wrappers are coalesced into one `loadShare-eager` chunk on Vite 8+ to reduce startup requests.
+Module Federation requires chunk splitting so `runtimeInitStatus` and deferred `loadShare` wrappers stay isolated for correct bootstrap order. Eager `loadShare` wrappers are coalesced into one `loadShare-eager` chunk to reduce startup requests, on both Rolldown (Vite 8+) and Rollup (Vite 5–7).
+
+Non-eager `loadShare` wrappers that reach their local `__prebuild__` fallback only through `import()` are merged into one `__loadShare__shared` chunk per `federation()` instance, with the shared-cache helpers included once. A wrapper that statically imports its local payload keeps its own chunk, since merging it could close a top-level-await cycle. `__prebuild__` fallbacks stay in separate lazily imported chunks, so a consumer never downloads its local copy when a peer already provides the share. The plugin warns at build time if a fallback ends up inside the merged chunk.
 
 ### `codeSplitting.groups` (Vite 8+ / Rolldown)
 

package/lib/{dtsConstants-BEGrtvcw.js → dtsConstants-DEMpRfBz.js}

@@ -1,4 +1,5 @@
-import { existsSync, readFileSync, readdirSync } from "fs";
+import { d as getNodeModulesSuffix, r as getSharedRuntimeKey } from "./sharedKeyMatcher-Od_nYxJA.js";
+import { existsSync, readFileSync, readdirSync, realpathSync } from "fs";
 import { createRequire } from "module";
 import * as path$1 from "node:path";
 import { fileURLToPath, pathToFileURL } from "url";
@@ -34,6 +35,29 @@ const moduleFederationConsole = {
 const mfWarn = moduleFederationConsole.warn;
 const mfError = moduleFederationConsole.error;
 //#endregion
+//#region src/utils/reactShares.ts
+/** Property under which React 19 exposes its internals object. */
+const REACT_CLIENT_INTERNALS_KEY = "__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE";
+/**
+* Every property React has used for its internals object, newest first. Two
+* module objects that expose the same internals are the same React instance.
+*/
+const REACT_INTERNALS_KEYS = [
+	REACT_CLIENT_INTERNALS_KEY,
+	"__TEST_INTERNALS",
+	"__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"
+];
+/**
+* Importing this share's local fallback registers a DOM renderer as a side
+* effect. An entry-injected leaf must not evaluate its own copy while the host
+* renderer already owns the root, so its wrapper waits for the cache or init.
+*/
+const REACT_DOM_CLIENT_SHARE = "react-dom/client";
+/** React and its subpath exports must bind synchronously for CJS consumers. */
+function isReactCoreShare(pkg) {
+	return pkg === "react" || pkg.startsWith("react/");
+}
+//#endregion
 //#region src/utils/packageUtils.ts
 const dependencyPresenceCache = /* @__PURE__ */ new Map();
 let packageDetectionCwd;
@@ -41,6 +65,7 @@ function getDependencyCacheKey(cwd, dependencyName) {
 	return `${cwd}:${dependencyName}`;
 }
 const installedPackageJsonCache = /* @__PURE__ */ new Map();
+const dependentsLookupCache = /* @__PURE__ */ new Map();
 function setPackageDetectionCwd(cwd) {
 	packageDetectionCwd = cwd;
 }
@@ -129,6 +154,20 @@ function getPackageExportsTarget(pkg, packageName, exportsField) {
 	if (subpath !== ".") return matchExportsSubpath(record, subpath);
 	return record["."] ?? (!Object.keys(record).some((key) => key.startsWith(".")) ? record : void 0);
 }
+/** Whether `pkg` can be located from `opts.cwd` (or the detection cwd). Aliased or non-hoisted packages may still resolve through Vite. */
+function isPackageInstalled(pkg, opts = {}) {
+	return getInstalledPackageJson(getPackageName(pkg), opts) !== void 0;
+}
+/**
+* Whether the installed package's `exports` field permits `pkg`. Lenient when the package cannot
+* be found or has no `exports`: callers that need a hard "is installed" gate use `isPackageInstalled`.
+*/
+function isPackageExportAvailable(pkg, opts = {}) {
+	const packageName = getPackageName(pkg);
+	const installed = getInstalledPackageJson(packageName, opts);
+	if (installed?.packageJson.exports == null) return true;
+	return resolveExportsEntry(getPackageExportsTarget(pkg, packageName, installed.packageJson.exports), opts.conditions) !== void 0;
+}
 /**
 * Escaping rules:
 * Convert using the format __${mapping}__, where _ and $ are not allowed in npm package names but can be used in variable names.
@@ -180,10 +219,9 @@ function getPackageName(packageString) {
 	return match ? match[0] : packageString;
 }
 function getPackageNameFromNodeModulePath(source) {
-	const normalized = source.replace(/\\/g, "/");
-	const nodeModulesIndex = normalized.lastIndexOf("/node_modules/");
-	if (nodeModulesIndex < 0) return;
-	const parts = normalized.slice(nodeModulesIndex + 14).split("/");
+	const suffix = getNodeModulesSuffix(source);
+	if (!suffix) return;
+	const parts = suffix.split("/");
 	if (!parts[0]) return;
 	if (parts[0].startsWith("@")) return parts[1] ? `${parts[0]}/${parts[1]}` : void 0;
 	return parts[0];
@@ -199,7 +237,7 @@ function getSharedCacheKeyParts(input) {
 }
 function getSharedCacheDescriptor(pkg, shareItem) {
 	const parts = getSharedCacheKeyParts({
-		pkg,
+		pkg: shareItem.shareConfig.request !== void 0 || shareItem.shareConfig.shareKey !== void 0 ? getSharedRuntimeKey(pkg, shareItem) : pkg,
 		singleton: shareItem.shareConfig.singleton,
 		version: shareItem.version,
 		scope: shareItem.scope
@@ -265,7 +303,47 @@ const sharedCacheHelperCode = `const __mfGetSharedCacheDescriptor = (pkg, single
           };
           const __mfReadSharedCacheOwner = (cache, descriptor) =>
             cache[__mfSharedCacheOwnersKey]?.[descriptor.canonical];
+          const __mfGetSharedModuleIdentity = (value) => {
+            const candidates = [value, value?.default];
+            for (const candidate of candidates) {
+              if (!candidate || typeof candidate !== "object") continue;
+              for (const key of ${JSON.stringify(REACT_INTERNALS_KEYS)}) {
+                const internals = candidate[key];
+                if (internals && typeof internals === "object") {
+                  return { internals };
+                }
+              }
+              if (typeof candidate.useState === "function") return { hook: candidate.useState };
+            }
+            return undefined;
+          };
+          const __mfIsSameSharedModule = (current, next) => {
+            if (current === next) return true;
+            const currentIdentity = __mfGetSharedModuleIdentity(current);
+            const nextIdentity = __mfGetSharedModuleIdentity(next);
+            if (!currentIdentity || !nextIdentity) return false;
+            const currentInternals = currentIdentity.internals;
+            const nextInternals = nextIdentity.internals;
+            // Internals identity is authoritative when either side exposes it.
+            // Never treat absent fields as equal (undefined === undefined).
+            if (currentInternals !== undefined || nextInternals !== undefined) {
+              return (
+                currentInternals !== undefined &&
+                currentInternals === nextInternals
+              );
+            }
+            // Hook identity is only a fallback when neither side exposes internals.
+            return (
+              typeof currentIdentity.hook === "function" &&
+              currentIdentity.hook === nextIdentity.hook
+            );
+          };
           const __mfWriteSharedCache = (cache, descriptor, value, owner) => {
+            // Rewriting the same instance is a no-op on purpose: the first
+            // provider keeps ownership and subscribers are not re-notified, so
+            // an already-bound renderer never sees its React rebound.
+            const current = __mfReadSharedCache(cache, descriptor);
+            if (current !== undefined && __mfIsSameSharedModule(current, value)) return value;
             cache[descriptor.canonical] = value;
             const aliases = descriptor.aliases || [];
             for (const alias of aliases) {
@@ -364,85 +442,181 @@ function getInstalledPackageJson(pkg, opts) {
 	installedPackageJsonCache.set(cacheKey, result);
 	return result;
 }
+function tryReadPackageJson(packageJsonPath, expectedName) {
+	if (!existsSync(packageJsonPath)) return void 0;
+	try {
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+		if (expectedName !== void 0 && packageJson.name !== expectedName) return void 0;
+		return {
+			path: packageJsonPath,
+			dir: path$1.dirname(packageJsonPath),
+			packageJson
+		};
+	} catch {
+		return;
+	}
+}
 function resolveInstalledPackageJson(pkg, cwd, packageName, opts) {
-	const tryReadPackageJson = (packageJsonPath) => {
-		if (!existsSync(packageJsonPath)) return void 0;
-		try {
-			return {
-				path: packageJsonPath,
-				dir: path$1.dirname(packageJsonPath),
-				packageJson: JSON.parse(readFileSync(packageJsonPath, "utf-8"))
-			};
-		} catch {
-			return;
-		}
-	};
 	const findPackageInPnpmStore = (startDir) => {
-		let currentDir = startDir;
-		while (true) {
-			const pnpmStoreDir = path$1.join(currentDir, "node_modules", ".pnpm");
-			if (existsSync(pnpmStoreDir)) try {
+		for (const dir of ancestorDirs(startDir)) {
+			const pnpmStoreDir = path$1.join(dir, "node_modules", ".pnpm");
+			if (!existsSync(pnpmStoreDir)) continue;
+			try {
 				for (const entry of readdirSync(pnpmStoreDir, { withFileTypes: true })) {
 					if (!entry.isDirectory()) continue;
 					const candidate = tryReadPackageJson(path$1.join(pnpmStoreDir, entry.name, "node_modules", packageName, "package.json"));
 					if (candidate?.packageJson.name === packageName) return candidate;
 				}
 			} catch {}
-			const parentDir = path$1.dirname(currentDir);
-			if (parentDir === currentDir) break;
-			currentDir = parentDir;
 		}
 	};
 	let resolvedPath;
 	try {
-		const projectRequire = createRequire(pathToFileURL(path$1.join(cwd, "package.json")));
+		const rootPackageJson = path$1.join(cwd, "package.json");
 		if (opts?.fromResolvedEntry) resolvedPath = opts.fromResolvedEntry;
 		else try {
-			resolvedPath = projectRequire.resolve(pkg);
+			resolvedPath = resolveModulePath(pkg, rootPackageJson);
 		} catch {
-			resolvedPath = projectRequire.resolve(packageName);
+			resolvedPath = resolveModulePath(packageName, rootPackageJson);
 		}
 	} catch {
 		resolvedPath = void 0;
 	}
 	if (resolvedPath !== void 0 && !path$1.isAbsolute(resolvedPath)) resolvedPath = void 0;
-	if (resolvedPath !== void 0) try {
-		let currentDir = path$1.dirname(resolvedPath);
-		let matchingPackage;
-		while (true) {
-			const packageJsonPath = path$1.join(currentDir, "package.json");
-			if (existsSync(packageJsonPath)) {
-				const packageJsonContent = readFileSync(packageJsonPath, "utf-8");
-				try {
-					const packageJson = JSON.parse(packageJsonContent);
-					if (packageJson.name === packageName) {
-						const packageInfo = {
-							path: packageJsonPath,
-							dir: currentDir,
-							packageJson
-						};
-						if (currentDir.endsWith(path$1.join("node_modules", packageName))) return packageInfo;
-						matchingPackage ??= packageInfo;
-					}
-				} catch (error) {
-					if (!(error instanceof SyntaxError)) throw error;
+	if (resolvedPath !== void 0) {
+		const owner = findOwningPackageJson(path$1.dirname(resolvedPath), packageName);
+		if (owner) return owner;
+	}
+	for (const dir of ancestorDirs(cwd)) {
+		const directCandidate = tryReadPackageJson(path$1.join(dir, "node_modules", packageName, "package.json"), packageName);
+		if (directCandidate) return directCandidate;
+	}
+	return findPackageInDependents(packageName, cwd) ?? findPackageInPnpmStore(cwd);
+}
+/**
+* A package installed only under a dependent is invisible to the walks above.
+* Resolving it from each dependent in turn follows the same links that dependent
+* does, so the copy found is the version it is installed against rather than
+* whichever one the pnpm store happens to list first.
+*/
+function findPackageInDependents(packageName, cwd) {
+	const cacheKey = `${cwd}\0${packageName}`;
+	if (!dependentsLookupCache.has(cacheKey)) dependentsLookupCache.set(cacheKey, walkDependents(packageName, cwd));
+	return dependentsLookupCache.get(cacheKey);
+}
+function walkDependents(packageName, cwd) {
+	const root = tryReadPackageJson(path$1.join(cwd, "package.json"));
+	if (!root) return void 0;
+	const visited = /* @__PURE__ */ new Set();
+	const rootDependencyGroups = [getDependencyNames(root.packageJson), getDependencyNames(root.packageJson, ["devDependencies"])];
+	for (const rootDependencies of rootDependencyGroups) {
+		let level = rootDependencies.map((name) => ({
+			name,
+			fromDir: cwd
+		}));
+		while (level.length) {
+			const candidates = [];
+			const nextLevel = [];
+			for (const { name, fromDir } of level) {
+				if (name === packageName) continue;
+				const dependent = findPackageFrom(name, fromDir);
+				if (!dependent || visited.has(dependent.dir)) continue;
+				visited.add(dependent.dir);
+				const dependencies = getDependencyNames(dependent.packageJson);
+				if (dependencies.includes(packageName)) {
+					const copy = findPackageFrom(packageName, dependent.dir);
+					if (copy) candidates.push({
+						copy,
+						via: name
+					});
 				}
+				for (const dependency of dependencies) nextLevel.push({
+					name: dependency,
+					fromDir: dependent.dir
+				});
 			}
-			const parentDir = path$1.dirname(currentDir);
-			if (parentDir === currentDir) break;
-			currentDir = parentDir;
+			if (candidates.length) {
+				warnOnAmbiguousDependents(packageName, candidates);
+				return candidates[0].copy;
+			}
+			level = nextLevel;
 		}
-		return matchingPackage;
-	} catch {}
-	let currentDir = cwd;
+	}
+}
+function warnOnAmbiguousDependents(packageName, candidates) {
+	const viaByVersion = /* @__PURE__ */ new Map();
+	for (const { copy, via } of candidates) if (!viaByVersion.has(copy.packageJson.version)) viaByVersion.set(copy.packageJson.version, via);
+	if (viaByVersion.size < 2) return;
+	const versions = [...viaByVersion].map(([version, via]) => `${version} (via ${via})`);
+	mfWarn(`Shared package "${packageName}" is not a dependency of the project, and its closest dependents install different versions: ${versions.join(", ")}. The fallback uses ${versions[0]}. Add "${packageName}" to the project's dependencies or set its shared "import" to choose the version.`);
+}
+/** The package Node's `node_modules` lookup finds from `fromDir`, read at its real path. */
+function findPackageFrom(packageName, fromDir) {
+	const entry = findNodeModulesEntry(packageName, fromDir);
+	if (!entry) return void 0;
+	try {
+		return tryReadPackageJson(path$1.join(realpathSync(entry), "package.json"), packageName);
+	} catch {
+		return;
+	}
+}
+/**
+* Walks up from `startDir` to the package.json named `packageName`, preferring the
+* one at `node_modules/<packageName>` so a nested `package.json` (for example a
+* subpath's `type: module` marker) does not shadow the package root.
+*/
+function findOwningPackageJson(startDir, packageName) {
+	let matchingPackage;
+	for (const dir of ancestorDirs(startDir)) {
+		const candidate = tryReadPackageJson(path$1.join(dir, "package.json"), packageName);
+		if (!candidate) continue;
+		if (dir.endsWith(path$1.join("node_modules", packageName))) return candidate;
+		matchingPackage ??= candidate;
+	}
+	return matchingPackage;
+}
+function* ancestorDirs(startDir) {
+	let dir = startDir;
 	while (true) {
-		const directCandidate = tryReadPackageJson(path$1.join(currentDir, "node_modules", packageName, "package.json"));
-		if (directCandidate?.packageJson.name === packageName) return directCandidate;
-		const parentDir = path$1.dirname(currentDir);
-		if (parentDir === currentDir) break;
-		currentDir = parentDir;
+		yield dir;
+		const parentDir = path$1.dirname(dir);
+		if (parentDir === dir) return;
+		dir = parentDir;
+	}
+}
+/** The first `node_modules/<packageName>` that Node's lookup reaches from `fromDir`. */
+function findNodeModulesEntry(packageName, fromDir) {
+	for (const dir of ancestorDirs(fromDir)) {
+		const entry = path$1.join(dir, "node_modules", packageName);
+		if (existsSync(entry)) return entry;
+	}
+}
+/**
+* `require.resolve(specifier)` from the file `from`, limited to the `node_modules` lookup
+* bundlers perform. Node also searches NODE_PATH, which pnpm's bin shims point at the
+* store's hoisted `node_modules`, so it can find packages the bundler cannot.
+*/
+function resolveModulePath(specifier, from) {
+	const resolved = createRequire(pathToFileURL(from)).resolve(specifier);
+	if (!path$1.isAbsolute(resolved) || specifier.startsWith(".") || path$1.isAbsolute(specifier) || process.versions.pnp) return resolved;
+	if (findNodeModulesEntry(getPackageName(specifier), path$1.dirname(from))) return resolved;
+	const error = /* @__PURE__ */ new Error(`Cannot find module '${specifier}' from '${from}'`);
+	error.code = "MODULE_NOT_FOUND";
+	throw error;
+}
+function getDependencyNames(packageJson, fields = [
+	"dependencies",
+	"peerDependencies",
+	"optionalDependencies"
+]) {
+	if (!packageJson) return [];
+	const names = /* @__PURE__ */ new Set();
+	for (const field of fields) {
+		const deps = packageJson[field];
+		if (!deps || typeof deps !== "object") continue;
+		for (const dep of Object.keys(deps)) names.add(dep);
 	}
-	return findPackageInPnpmStore(cwd);
+	return [...names];
 }
 function getInstalledPackageEntry(pkg, opts) {
 	const installed = getInstalledPackageJson(pkg, opts);
@@ -451,7 +625,7 @@ function getInstalledPackageEntry(pkg, opts) {
 	const packageName = opts?.packageName || getPackageName(pkg);
 	const packageJson = installed.packageJson;
 	if (pkg !== packageName && (opts?.resolveSubpathWithRequire !== false || packageJson.exports === void 0)) try {
-		return createRequire(pathToFileURL(path$1.join(cwd, "package.json"))).resolve(pkg);
+		return resolveModulePath(pkg, path$1.join(cwd, "package.json"));
 	} catch {}
 	const explicitEntry = resolveExportsEntry(getPackageExportsTarget(pkg, packageName, packageJson.exports), opts?.conditions) || (typeof packageJson.module === "string" ? packageJson.module : void 0) || (typeof packageJson.main === "string" ? packageJson.main : void 0) || "index.js";
 	return path$1.join(installed.dir, explicitEntry);
@@ -465,6 +639,18 @@ function getIsRolldown(ctx) {
 	const viteMajor = Number(String(viteVersion ?? "").split(".")[0]);
 	return Number.isFinite(viteMajor) && viteMajor >= 8 || !!ctx?.meta?.rolldownVersion;
 }
+/**
+* Rolldown 1.2.10 added `codeSplitting.groups[].debugName` and warns when a group's
+* `name` is a function without one. Older versions reject it as an unknown option.
+*/
+function supportsCodeSplittingGroupDebugName(ctx) {
+	const rolldownVersion = ctx?.meta?.rolldownVersion;
+	if (typeof rolldownVersion !== "string") return false;
+	const [major = 0, minor = 0, patch = 0] = rolldownVersion.split(/[.+-]/, 3).map((part) => parseInt(part, 10) || 0);
+	if (major !== 1) return major > 1;
+	if (minor !== 2) return minor > 2;
+	return patch >= 10;
+}
 /** Walk up from Vite `config.root` (Nuxt may point at `.nuxt` cache dirs). */
 function isNuxtProjectRoot(root) {
 	let dir = root;
@@ -499,4 +685,4 @@ function hasPackageDependency(dependencyName, cwd = packageDetectionCwd || proce
 //#region src/utils/dtsConstants.ts
 const DEFAULT_PUBLIC_TYPES_FOLDER = "@mf-types";
 //#endregion
-export { mfError as _, getPackageDetectionCwd as a, getSharedCacheDescriptor as c, packageNameDecode as d, packageNameEncode as f, createModuleFederationError as g, sharedCacheHelperCode as h, getIsRolldown as i, hasPackageDependency as l, setPackageDetectionCwd as m, getInstalledPackageEntry as n, getPackageName as o, resolveImportPath as p, getInstalledPackageJson as r, getPackageNameFromNodeModulePath as s, DEFAULT_PUBLIC_TYPES_FOLDER as t, isNuxtProjectRoot as u, mfWarn as v };
+export { isReactCoreShare as C, mfWarn as E, REACT_DOM_CLIENT_SHARE as S, mfError as T, resolveModulePath as _, getIsRolldown as a, supportsCodeSplittingGroupDebugName as b, getPackageNameFromNodeModulePath as c, isNuxtProjectRoot as d, isPackageExportAvailable as f, resolveImportPath as g, packageNameEncode as h, getInstalledPackageJson as i, getSharedCacheDescriptor as l, packageNameDecode as m, getDependencyNames as n, getPackageDetectionCwd as o, isPackageInstalled as p, getInstalledPackageEntry as r, getPackageName as s, DEFAULT_PUBLIC_TYPES_FOLDER as t, hasPackageDependency as u, setPackageDetectionCwd as v, createModuleFederationError as w, REACT_CLIENT_INTERNALS_KEY as x, sharedCacheHelperCode as y };

package/lib/index.d.ts

@@ -31,6 +31,12 @@ type ModuleFederationOptions = {
     import: string;
   }> | undefined;
   filename?: string;
+  /**
+   * Exact file name of the SSR remote entry emitted next to `filename`.
+   * Defaults to `<filename base>.ssr<ext>` so it never clobbers the browser
+   * entry when both builds share an output directory. `[hash]` is not supported.
+   */
+  ssrFilename?: string;
   library?: any;
   name: string;
   remotes?: Record<string, string | RemoteObjectConfig> | undefined;
@@ -57,10 +63,13 @@ type ModuleFederationOptions = {
     name?: string;
     version?: string;
     shareScope?: string;
+    request?: moduleFederationPlugin.SharedConfig['request'];
+    shareKey?: moduleFederationPlugin.SharedConfig['shareKey'];
     singleton?: boolean;
     eager?: boolean;
     requiredVersion?: moduleFederationPlugin.SharedConfig['requiredVersion'];
     strictVersion?: boolean;
+    allowNodeModulesSuffixMatch?: boolean;
     /** Suppress the missing local dependency warning for `import: false` shares. */
     suppressMissingImportWarning?: boolean;
     treeShaking?: TreeShakingConfig;
@@ -122,8 +131,11 @@ type ModuleFederationOptions = {
   disableSnapshot?: boolean;
   /**
    * Additional packages to mark as external in the SSR remote entry build.
-   * Shared packages and MF runtime packages are always external. Use this to
+   * Shared packages and MF runtime packages are external by default. Use this to
    * add any other Node-only packages that should not be bundled into the SSR entry.
+   * To emit a self-contained SSR entry (loadable by hosts that cannot resolve the
+   * MF runtime from Node, such as the `@module-federation/sdk` reference loader),
+   * opt the MF runtime packages back in through Vite's `ssr.noExternal`.
    */
   ssrExternals?: string[];
   /**
@@ -230,6 +242,7 @@ interface DtsRemoteOptions {
   extractRemoteTypes?: boolean;
   abortOnError?: boolean;
   deleteTsConfig?: boolean;
+  afterGenerate?: (options: moduleFederationPlugin.DtsGenerateTypesHookOptions) => Promise<void> | void;
 }
 interface DtsHostOptions {
   typesFolder?: string;