@module-federation/vite 1.21.5 → 1.22.0

package/README.md

@@ -242,6 +242,27 @@ You can specify the place the host initialization file is injected with the **ho
 The **moduleParseTimeout** option allows you to configure the maximum time to wait for module parsing during the build process.
 The **moduleParseIdleTimeout** option is an alternative that resets the timer on every parsed module. It only fires when there has been no module activity for the configured duration, making it suitable for large codebases where the total build time exceeds the fixed timeout.
 
+## SSR entry loading strategy
+
+SSR hosts can choose how HTTP ESM remote entries are evaluated during build and preview:
+
+```ts
+federation({
+  name: "host",
+  remotes: {
+    // ...
+  },
+  ssrEntryLoader: {
+    strategy: "vm",
+  },
+});
+```
+
+- `"temp-file"` (default) fetches the remote graph, rewrites imports to host-resolved shared packages, writes temporary files, and loads them with `import()`.
+- `"vm"` evaluates the graph in memory with `vm.SourceTextModule` and resolves shared packages through the Module Federation share scope.
+
+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.
+
 ## Runtime capability optimization
 
 Runtime features that a build never uses can be removed at build time:
@@ -326,9 +347,9 @@ This deployment step is separate from the local Vite build; the plugin only emit
 
 ## External runtime (`experiments`)
 
-Share one `@module-federation/runtime-core` instance from a pure consumer host so remotes do not bundle their own copy. Pair the flags — remotes with `externalRuntime` require a host that provides the global.
+Share one `@module-federation/runtime-core` instance from the host so remotes do not bundle their own copy. Pair the flags — remotes with `externalRuntime` require a host that provides the global.
 
-**Host (pure consumer, no `exposes`):**
+**Host:**
 
 ```ts
 federation({
@@ -361,14 +382,14 @@ federation({
 });
 ```
 
-`provideExternalRuntime` injects a local runtime plugin that publishes `runtime-core` on `globalThis._FEDERATION_RUNTIME_CORE`. `externalRuntime` rewrites imports of `@module-federation/runtime-core` to read that global. Using `provideExternalRuntime` together with `exposes` throws — only pure consumers may provide the runtime.
+`provideExternalRuntime` injects a local runtime plugin that publishes `runtime-core` on `globalThis._FEDERATION_RUNTIME_CORE`. `externalRuntime` rewrites imports of `@module-federation/runtime-core` to read that global. A container that also `exposes` (e.g. a host consumed by its own remotes) may provide the runtime too, as long as exactly one container on the page does and it is loaded before any `externalRuntime` remote evaluates (a second provider is ignored with a `Detect multiple module federation runtime!` warning; a remote evaluated before the provider throws `_FEDERATION_RUNTIME_CORE is missing`).
 The `externalRuntime` rewrite applies to the browser remote graph; SSR remote entries continue to resolve `@module-federation/runtime-core` from Node so they do not depend on the browser global.
 
 ## ⚠️ `codeSplitting` is managed by the plugin
 
 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 `loadShare` and `runtimeInitStatus` stay isolated for correct bootstrap order.
+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.
 
 ### `codeSplitting.groups` (Vite 8+ / Rolldown)
 

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

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

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

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, readdirSync } from "fs";
 import { createRequire } from "module";
 import * as path$1 from "node:path";
 import { fileURLToPath, pathToFileURL } from "url";
+import { createHash } from "node:crypto";
 //#region src/utils/logger.ts
 const MODULE_FEDERATION_LOG_PREFIX = "[Module Federation]";
 function formatModuleFederationMessage(message) {
@@ -136,22 +137,37 @@ function getPackageExportsTarget(pkg, packageName, exportsField) {
 *  - => 3
 *  . => 4
 */
+const MF_HASHED_NAME_THRESHOLD = 90;
+const MF_HASHED_NAME_HASH_LENGTH = 16;
+const MF_HASHED_NAME_PREFIX_LENGTH = MF_HASHED_NAME_THRESHOLD - MF_HASHED_NAME_HASH_LENGTH;
+const mfHashedNameMap = /* @__PURE__ */ new Map();
 /**
-* Encodes a package name into a valid file name.
-* @param {string} name - The package name, e.g., "@scope/xx-xx.xx".
+* Encodes a package name (or shared-module specifier, which may include a
+* deep import subpath) into a valid file name, falling back to a
+* readable-prefix + content-hash id when the plain encoding would be too
+* long for a filesystem path segment.
+* @param {string} name - The package name or specifier, e.g., "@scope/xx-xx.xx" or "@scope/pkg/deep/sub-path".
 * @returns {string} - The encoded file name.
 */
 function packageNameEncode(name) {
 	if (typeof name !== "string") throw createModuleFederationError("A string package name is required");
-	return name.replace(/@/g, "_mf_0_").replace(/\//g, "_mf_1_").replace(/-/g, "_mf_2_").replace(/\./g, "_mf_3_");
+	const encoded = name.replace(/@/g, "_mf_0_").replace(/\//g, "_mf_1_").replace(/-/g, "_mf_2_").replace(/\./g, "_mf_3_");
+	if (encoded.length <= MF_HASHED_NAME_THRESHOLD) return encoded;
+	const hashedName = `${encoded.slice(0, MF_HASHED_NAME_PREFIX_LENGTH)}${createHash("sha256").update(name).digest("hex").slice(0, MF_HASHED_NAME_HASH_LENGTH)}`;
+	mfHashedNameMap.set(hashedName, name);
+	return hashedName;
 }
 /**
-* Decodes an encoded file name back to the original package name.
+* Decodes an encoded file name back to the original package name or
+* shared-module specifier, whether it was plainly substituted or hashed
+* down by `packageNameEncode`.
 * @param {string} encoded - The encoded file name, e.g., "_mf_0_scope_mf_1_xx_mf_2_xx_mf_3_xx".
-* @returns {string} - The decoded package name.
+* @returns {string} - The decoded package name or specifier.
 */
 function packageNameDecode(encoded) {
 	if (typeof encoded !== "string") throw createModuleFederationError("A string encoded file name is required");
+	const original = mfHashedNameMap.get(encoded);
+	if (original !== void 0) return original;
 	return encoded.replace(/_mf_0_/g, "@").replace(/_mf_1_/g, "/").replace(/_mf_2_/g, "-").replace(/_mf_3_/g, ".");
 }
 /**

package/lib/index.d.ts

@@ -126,6 +126,13 @@ type ModuleFederationOptions = {
    * add any other Node-only packages that should not be bundled into the SSR entry.
    */
   ssrExternals?: string[];
+  /**
+   * Options for the auto-injected `@module-federation/vite/ssrEntryLoader`.
+   * When omitted, the loader uses the `'temp-file'` strategy. Set
+   * `strategy: 'vm'` to opt into `vm.SourceTextModule` evaluation while keeping
+   * the computed `resolvedShared` map.
+   */
+  ssrEntryLoader?: SsrEntryLoaderConfig;
   /**
    * Experimental Module Federation capabilities.
    *
@@ -141,13 +148,28 @@ interface PluginExperimentsOptions {
    */
   externalRuntime?: boolean;
   /**
-   * Pure-consumer only (no `exposes`). Injects a local runtime plugin that
-   * publishes `runtime-core` on `globalThis._FEDERATION_RUNTIME_CORE`.
+   * Injects a local runtime plugin that publishes `runtime-core` on
+   * `globalThis._FEDERATION_RUNTIME_CORE`. Set it on exactly one container
+   * per page; that container may also `exposes`.
    */
   provideExternalRuntime?: boolean;
   /** Generate the React SSR/hydration island capability for eligible exposes. */
   ssrMode?: 'ISLAND';
 }
+type SsrEntryLoaderStrategy = 'temp-file' | 'vm';
+type SsrEntryLoaderConfig = {
+  /**
+   * How the auto-injected `@module-federation/vite/ssrEntryLoader` evaluates
+   * remote SSR entries.
+   *
+   * - `'temp-file'` (default when omitted): fetch the ESM graph, rewrite
+   *   specifiers, write temp files and `import()` them.
+   * - `'vm'`: evaluate the graph with `vm.SourceTextModule`. Requires
+   *   `--experimental-vm-modules`; the loader emits a single warning and
+   *   falls back to `'temp-file'` when that API is unavailable.
+   */
+  strategy?: SsrEntryLoaderStrategy;
+};
 type HostInitInjectLocationOptions = 'entry' | 'html';
 interface PluginDevOptions {
   disableLiveReload?: boolean;
@@ -227,4 +249,4 @@ interface DtsHostOptions {
 declare function federation(mfUserOptions: ModuleFederationOptions): any[];
 declare function createModuleFederationConfig<T extends ModuleFederationOptions>(options: T): T;
 //#endregion
-export { type ModuleFederationOptions, type PluginExperimentsOptions, type PluginManifestOptions, type TreeShakingConfig, createModuleFederationConfig, federation };
+export { type ModuleFederationOptions, type PluginExperimentsOptions, type PluginManifestOptions, type SsrEntryLoaderConfig, type SsrEntryLoaderStrategy, type TreeShakingConfig, createModuleFederationConfig, federation };