@module-federation/vite 1.23.2 → 1.23.3

package/README.md

@@ -278,6 +278,21 @@ 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.
 
+`ssrEntryLoader` also accepts network and cache options:
+
+```ts
+federation({
+  // ...
+  ssrEntryLoader: {
+    maxAgeMs: 60_000, // re-check each remote's manifest after 60s; omit to cache until process exit
+    fetchTimeoutMs: 5_000, // per-request timeout, default 10s, 0 disables it
+    fetchMaxBytes: 5 * 1024 * 1024, // per-response size limit, default 10 MiB, 0 disables it
+  },
+});
+```
+
+With `maxAgeMs`, a remote redeployed at the same URL is picked up once its manifest version changes. Only manifest-resolved entries can be revalidated.
+
 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

package/lib/{dtsConstants-r5OfegUr.js → dtsConstants-DSTzyKSG.js}

@@ -36,6 +36,7 @@ function getDependencyCacheKey(cwd, dependencyName) {
 }
 const installedPackageJsonCache = /* @__PURE__ */ new Map();
 const dependentsLookupCache = /* @__PURE__ */ new Map();
+const reachableDependencyNames = /* @__PURE__ */ new Map();
 function setPackageDetectionCwd(cwd) {
 	packageDetectionCwd = cwd;
 }
@@ -471,10 +472,17 @@ function resolveInstalledPackageJson(pkg, cwd, packageName, opts) {
 */
 function findPackageInDependents(packageName, cwd) {
 	const cacheKey = `${cwd}\0${packageName}`;
-	if (!dependentsLookupCache.has(cacheKey)) dependentsLookupCache.set(cacheKey, walkDependents(packageName, cwd));
+	if (!dependentsLookupCache.has(cacheKey)) {
+		if (!reachableDependencyNames.has(cwd)) {
+			const names = /* @__PURE__ */ new Set();
+			walkDependents("", cwd, names);
+			reachableDependencyNames.set(cwd, names);
+		}
+		dependentsLookupCache.set(cacheKey, reachableDependencyNames.get(cwd).has(packageName) ? walkDependents(packageName, cwd) : void 0);
+	}
 	return dependentsLookupCache.get(cacheKey);
 }
-function walkDependents(packageName, cwd) {
+function walkDependents(packageName, cwd, reachedNames) {
 	const root = tryReadPackageJson(path$1.join(cwd, "package.json"));
 	if (!root) return void 0;
 	const visited = /* @__PURE__ */ new Set();
@@ -492,6 +500,7 @@ function walkDependents(packageName, cwd) {
 				const dependent = findPackageFrom(name, fromDir);
 				if (!dependent || visited.has(dependent.dir)) continue;
 				visited.add(dependent.dir);
+				reachedNames?.add(name);
 				const dependencies = getDependencyNames(dependent.packageJson);
 				if (dependencies.includes(packageName)) {
 					const copy = findPackageFrom(packageName, dependent.dir);

package/lib/index.d.ts

@@ -1,280 +1,4 @@
-import { moduleFederationPlugin } from "@module-federation/sdk";
-import { ShareStrategy } from "@module-federation/runtime/types";
-//#region src/utils/normalizeModuleFederationOptions.d.ts
-interface RemoteObjectConfig {
-  type?: string;
-  name: string;
-  internalName?: string;
-  entry: string;
-  entryGlobalName?: string;
-  shareScope?: string | string[];
-}
-interface TreeShakingConfig {
-  mode: 'server-calc' | 'runtime-infer';
-  usedExports?: string[];
-}
-interface PluginManifestOptions {
-  filePath?: string;
-  disableAssetsAnalyze?: boolean;
-  fileName?: string;
-  additionalData?: (options: {
-    stats: Record<string, unknown>;
-    manifest?: Record<string, unknown>;
-    pluginOptions: Record<string, unknown>;
-    compiler?: unknown;
-    compilation?: unknown;
-    bundler: 'vite';
-  }) => Promise<Record<string, unknown> | void> | Record<string, unknown> | void;
-}
-type ModuleFederationOptions = {
-  exposes?: Record<string, string | {
-    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;
-  runtime?: any;
-  shareScope?: string | string[];
-  /**
-   * Override the public path used for remote entries
-   * Defaults to Vite's base config or "auto" if base is empty
-   */
-  publicPath?: string;
-  /**
-   * Controls whether all CSS assets from the bundle should be added to every exposed module.
-   * When false (default), the plugin will not process any CSS assets.
-   * When true, all CSS assets are bundled into every exposed module.
-   */
-  bundleAllCSS?: boolean;
-  /** Directory reserved for deploy-service generated secondary shared artifacts. */
-  treeShakingDir?: string;
-  /** Whether inferred usedExports metadata is injected into generated runtime records. */
-  injectTreeShakingUsedExports?: boolean;
-  treeShakingSharedPlugins?: string[];
-  treeShakingSharedExcludePlugins?: string[];
-  shared?: string[] | Record<string, string | {
-    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;
-    import?: moduleFederationPlugin.SharedConfig['import'];
-  }> | undefined;
-  runtimePlugins?: Array<string | [string, Record<string, unknown>]>;
-  getPublicPath?: string;
-  implementation?: string;
-  manifest?: PluginManifestOptions | boolean;
-  dev?: boolean | PluginDevOptions;
-  dts?: boolean | PluginDtsOptions;
-  shareStrategy?: ShareStrategy;
-  ignoreOrigin?: boolean;
-  virtualModuleDir?: string;
-  hostInitInjectLocation?: HostInitInjectLocationOptions;
-  /**
-   * Timeout for parsing modules in seconds.
-   * Defaults to 10 seconds.
-   */
-  moduleParseTimeout?: number;
-  /**
-   * Idle timeout for parsing modules in seconds. When set, the timeout resets
-   * on every parsed module and only fires when there has been no module activity
-   * for the configured duration. Prefer this over `moduleParseTimeout` for large
-   * codebases where the total build time may exceed the fixed timeout.
-   */
-  moduleParseIdleTimeout?: number;
-  /**
-   * Allows generate additional remoteEntry file for "var" host environment
-   */
-  varFilename?: string;
-  /**
-   * Target environment for the build to enable effective tree-shaking.
-   *
-   * @see https://module-federation.io/configure/experiments#target
-   * @default 'web' (or 'node' if build.ssr is enabled)
-   */
-  target?: 'web' | 'node';
-  /**
-   * Removes remote-consumption support from the federation runtime.
-   * Only enable this for builds that never load remotes.
-   *
-   * @default false
-   */
-  disableRemote?: boolean;
-  /**
-   * Removes shared-dependency support from the federation runtime.
-   * Only enable this when the build has no shared dependencies.
-   *
-   * @default false
-   */
-  disableShared?: boolean;
-  /**
-   * Removes snapshot support, including manifest-based remotes, preload,
-   * dynamic type hints, HMR, and devtools integration.
-   *
-   * @default false (true for Node/SSR builds)
-   */
-  disableSnapshot?: boolean;
-  /**
-   * Additional packages to mark as external in the SSR remote entry build.
-   * 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[];
-  /**
-   * 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.
-   *
-   * @see https://module-federation.io/configure/experiments
-   */
-  experiments?: PluginExperimentsOptions;
-};
-interface PluginExperimentsOptions {
-  /**
-   * Treat `@module-federation/runtime-core` as an external that reads
-   * `globalThis._FEDERATION_RUNTIME_CORE` at runtime. Pair with a host that
-   * sets `provideExternalRuntime: true`.
-   */
-  externalRuntime?: boolean;
-  /**
-   * 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';
-  /**
-   * The host provides every shared dependency; remotes bring none. Shared keys
-   * are resolved by a native browser import map instead of the Module
-   * Federation runtime: the host emits one entry chunk per shared key and
-   * injects `<script type="importmap">`, remotes keep shared imports as bare
-   * specifiers and emit one fixed-name entry per expose plus a standard
-   * `mf-manifest.json` (without `remoteEntry`) the host maps from.
-   *
-   * Shared modules become ordinary static ES imports, so there is no
-   * `loadShare` glue and no `eager` is needed for code that reads a shared
-   * value at module-evaluation time. There is no version negotiation and no
-   * runtime API: `requiredVersion`, `strictVersion`, `shareStrategy`,
-   * `runtimePlugins` and `manifest` are ignored.
-   *
-   * @see https://github.com/module-federation/vite/issues/1381
-   */
-  hostProvidesAllShared?: boolean;
-}
-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;
-  disableHotTypesReload?: boolean;
-  disableDynamicRemoteTypeHints?: boolean;
-  /**
-   * Controls cross-federation HMR for remote modules.
-   *
-   * - `false` / `undefined` — HMR disabled (default).
-   * - `true` — HMR enabled with auto-detected strategy. When a framework
-   *   plugin with cross-federation HMR support is detected, broadcast/relay
-   *   is suppressed and the framework's native HMR handles updates:
-   *     - React (`@vitejs/plugin-react` / `@vitejs/plugin-react-swc`) — the
-   *       plugin serves a `/@react-refresh` proxy on remotes that delegates
-   *       to the host's `RefreshRuntime`, unifying the component registry.
-   *     - Vue (`@vitejs/plugin-vue` / `@vitejs/plugin-vue-jsx`) — the plugin
-   *       injects a `__VUE_HMR_RUNTIME__` guard into the host page so the
-   *       first-loaded (host) Vue runtime is pinned and remote-loaded Vue
-   *       copies cannot overwrite it.
-   *   For any host, the plugin also injects a script that clears the
-   *   federation `moduleCache` on `vite:beforeUpdate` so subsequent
-   *   `loadRemote()` calls return the freshly patched module.
-   *   Other frameworks fall back to full page reloads.
-   * - `'full-reload'` — HMR enabled, always use full page reloads even when
-   *   a framework with native cross-federation HMR is detected.
-   */
-  remoteHmr?: boolean | 'full-reload';
-}
-interface RemoteTypeUrl {
-  alias?: string;
-  api: string;
-  zip: string;
-}
-interface RemoteTypeUrls {
-  [remoteName: string]: RemoteTypeUrl;
-}
-interface PluginDtsOptions {
-  generateTypes?: boolean | DtsRemoteOptions;
-  consumeTypes?: boolean | DtsHostOptions;
-  tsConfigPath?: string;
-  extraOptions?: Record<string, unknown>;
-  implementation?: string;
-  cwd?: string;
-  displayErrorInTerminal?: boolean;
-}
-interface DtsRemoteOptions {
-  tsConfigPath?: string;
-  typesFolder?: string;
-  compiledTypesFolder?: string;
-  deleteTypesFolder?: boolean;
-  additionalFilesToCompile?: string[];
-  compilerInstance?: 'tsc' | 'vue-tsc' | 'tspc' | string;
-  compileInChildProcess?: boolean;
-  generateAPITypes?: boolean;
-  extractThirdParty?: boolean | {
-    exclude?: Array<string | RegExp>;
-  };
-  extractRemoteTypes?: boolean;
-  abortOnError?: boolean;
-  deleteTsConfig?: boolean;
-  afterGenerate?: (options: moduleFederationPlugin.DtsGenerateTypesHookOptions) => Promise<void> | void;
-}
-interface DtsHostOptions {
-  typesFolder?: string;
-  abortOnError?: boolean;
-  remoteTypesFolder?: string;
-  deleteTypesFolder?: boolean;
-  maxRetries?: number;
-  consumeAPITypes?: boolean;
-  runtimePkgs?: string[];
-  remoteTypeUrls?: (() => Promise<RemoteTypeUrls>) | RemoteTypeUrls;
-  timeout?: number;
-  family?: 0 | 4 | 6;
-  typesOnBuild?: boolean;
-}
-//#endregion
+import { a as SsrEntryLoaderStrategy, i as SsrEntryLoaderConfig, n as PluginExperimentsOptions, o as TreeShakingConfig, r as PluginManifestOptions, t as ModuleFederationOptions } from "./normalizeModuleFederationOptions-DNUlv-AL.js";
 //#region src/index.d.ts
 declare function federation(mfUserOptions: ModuleFederationOptions): any[];
 declare function createModuleFederationConfig<T extends ModuleFederationOptions>(options: T): T;

package/lib/index.js

@@ -1,6 +1,6 @@
 import { _ as resolvePublicPath, a as matchesSharedSource, c as filterId, d as getNodeModulesSuffix, f as isAssetLikeImport, g as normalizeNodeModulePath, h as isViteOptimizableEntry, i as invalidateSharedKeyMatcher, l as getBasePath$1, m as isNuxtClientBase, n as getSharedRequest, p as isNodeModulePath, r as getSharedRuntimeKey, s as ensureTrailingSlash, t as findSharedKey, u as getCommonSharedSubpaths, v as stripQueryAndHash, y as stripViteFsPrefix } from "./sharedKeyMatcher-Od_nYxJA.js";
 import { a as CodeRewriter, c as isAbsoluteUrl, d as resolveHashPlaceholderFileName, i as createCodePositionMap, l as normalizePathForImport, o as createSourceMap, r as mfWarn, t as createModuleFederationError, u as rebaseImport } from "./logger-DOwfTlw5.js";
-import { C as isReactCoreShare, S as REACT_DOM_CLIENT_SHARE, _ as resolveModulePath, a as getIsRolldown, b as supportsCodeSplittingGroupDebugName, c as getPackageNameFromNodeModulePath, d as isNuxtProjectRoot, f as isPackageExportAvailable, g as resolveImportPath, h as packageNameEncode, i as getInstalledPackageJson, l as getSharedCacheDescriptor, m as packageNameDecode, n as getDependencyNames, o as getPackageDetectionCwd, p as isPackageInstalled, r as getInstalledPackageEntry, s as getPackageName, u as hasPackageDependency, v as setPackageDetectionCwd, x as REACT_CLIENT_INTERNALS_KEY, y as sharedCacheHelperCode } from "./dtsConstants-r5OfegUr.js";
+import { C as isReactCoreShare, S as REACT_DOM_CLIENT_SHARE, _ as resolveModulePath, a as getIsRolldown, b as supportsCodeSplittingGroupDebugName, c as getPackageNameFromNodeModulePath, d as isNuxtProjectRoot, f as isPackageExportAvailable, g as resolveImportPath, h as packageNameEncode, i as getInstalledPackageJson, l as getSharedCacheDescriptor, m as packageNameDecode, n as getDependencyNames, o as getPackageDetectionCwd, p as isPackageInstalled, r as getInstalledPackageEntry, s as getPackageName, u as hasPackageDependency, v as setPackageDetectionCwd, x as REACT_CLIENT_INTERNALS_KEY, y as sharedCacheHelperCode } from "./dtsConstants-DSTzyKSG.js";
 import { createRequire } from "node:module";
 import * as fs$2 from "fs";
 import { existsSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "fs";
@@ -281,9 +281,17 @@ function isClientEnvironment(ctx) {
 * the legacy root `build.ssr` flag.
 */
 function isServerBuildContext(ctx, config) {
+	return isServerContext(ctx, Boolean(config?.build?.ssr));
+}
+/**
+* Whether a hook runs for a server graph. Hooks without an environment context
+* (Vite 5) use `legacySsr`, such as the root `build.ssr` flag or the load
+* hook's `ssr` option.
+*/
+function isServerContext(ctx, legacySsr) {
 	const target = resolveEnvironmentConsumerTarget(ctx);
 	if (target) return target === "server";
-	return Boolean(config?.build?.ssr);
+	return legacySsr;
 }
 function resolveRemoteConsumer(ctx, hasMultiEnvironment) {
 	if (!hasMultiEnvironment) return "unified";
@@ -730,9 +738,13 @@ function normalizeExperiments(experiments) {
 	};
 }
 function normalizeSsrEntryLoader(ssrEntryLoader) {
-	const strategy = ssrEntryLoader?.strategy;
-	if (strategy !== "temp-file" && strategy !== "vm") return void 0;
-	return { strategy };
+	if (!ssrEntryLoader) return void 0;
+	const normalized = {};
+	if (ssrEntryLoader.strategy === "temp-file" || ssrEntryLoader.strategy === "vm") normalized.strategy = ssrEntryLoader.strategy;
+	if (Number.isFinite(ssrEntryLoader.maxAgeMs)) normalized.maxAgeMs = ssrEntryLoader.maxAgeMs;
+	if (Number.isFinite(ssrEntryLoader.fetchTimeoutMs)) normalized.fetchTimeoutMs = ssrEntryLoader.fetchTimeoutMs;
+	if (Number.isFinite(ssrEntryLoader.fetchMaxBytes)) normalized.fetchMaxBytes = ssrEntryLoader.fetchMaxBytes;
+	return Object.keys(normalized).length > 0 ? normalized : void 0;
 }
 let config;
 let explicitSharedKeys = /* @__PURE__ */ new Set();
@@ -3300,7 +3312,7 @@ function generateEagerWorkspaceSingletonExports(edges, namedExports, importSourc
     __mfApplyEagerShareExportsWhenReady(exportModule);
     export { __mf_default as default };${namedExportLine}${mutableExportLine}`;
 }
-function generateLazyWorkspaceSingletonExports(edges, namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer, serveLocalFallback = false, mutableExports = [], deferredEntryFallback = false) {
+function generateLazyWorkspaceSingletonExports(edges, namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer, serveLocalFallback = false, mutableExports = [], deferredEntryFallback = false, ssrLocalFallback = true) {
 	const copiedExports = namedExports.filter((name) => !mutableExports.includes(name));
 	const namedExportVars = copiedExports.map((_name, i) => `__mf_${i}`);
 	const declarations = namedExports.length > 0 ? ["let __mf_default;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ") : "let __mf_default;";
@@ -3340,7 +3352,7 @@ function generateLazyWorkspaceSingletonExports(edges, namedExports, importSource
             __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});
           });
         })`;
-	const synchronousFallbackConditions = [...deferredEntryFallback ? [] : ["import.meta.env.SSR"], ...serveLocalFallback ? ["(import.meta.env.DEV && typeof __mfLocalShare !== 'undefined')"] : []];
+	const synchronousFallbackConditions = [...ssrLocalFallback ? ["import.meta.env.SSR"] : [], ...serveLocalFallback ? ["(import.meta.env.DEV && typeof __mfLocalShare !== 'undefined')"] : []];
 	const trackPendingLoad = `__mfTrackPendingShareLoad(${deferredEntryFallback ? deferredEntryLoad : deferredInitLoad});`;
 	return `${declarations}
     const __mfApplyLazyShareExports = (mod) => {
@@ -3546,7 +3558,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 		exportLine = generateLazyWorkspaceSingletonExports(edges, namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && !servesRemoteSingletonFallback && (isWorkspaceSingleton || isWorkspacePackage), liveNamedExports);
 	} else if (usesDeferredEntryInjectedSingletonFallback) {
 		importLine = `${getRuntimeInitPromiseBootstrapCode(false, runtimeInitOwnerImportId)}\n    ${importLine}`;
-		exportLine = generateLazyWorkspaceSingletonExports(edges, namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, false, liveNamedExports, true);
+		exportLine = generateLazyWorkspaceSingletonExports(edges, namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, false, liveNamedExports, true, pkg !== REACT_DOM_CLIENT_SHARE);
 	} else if (usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback) exportLine = generateEagerWorkspaceSingletonExports(edges, namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, liveNamedExports);
 	else if (usesDeferredSingletonFallback) {
 		importLine = `${getRuntimeInitPromiseBootstrapCode(false, runtimeInitOwnerImportId)}\n    ${importLine}`;
@@ -6221,9 +6233,23 @@ function getLazyRemotePendingExport() {
 };`;
 }
 function getEagerRemotePendingExport() {
-	return `export const __mf_remote_pending =
+	return `export let __mf_remote_pending =
   __mfRemotePending ??
-  __mfStartRemoteLoad().then(__mfAssignRemoteModule);`;
+  __mfStartRemoteLoad().then(__mfAssignRemoteModule);
+__mf_remote_pending.then(undefined, () => {
+  let attempt;
+  const retry = {
+    then(onFulfilled, onRejected) {
+      attempt ||= __mfStartRemoteLoad().then(__mfAssignRemoteModule, (error) => {
+        attempt = undefined;
+        throw error;
+      });
+      return attempt.then(onFulfilled, onRejected);
+    },
+  };
+  if (__mfRemotePending) __mfRemotePending = retry;
+  __mf_remote_pending = retry;
+});`;
 }
 function getServerThenExport() {
 	return `export function then(onFulfilled, onRejected) {
@@ -6237,7 +6263,15 @@ function getServerThenExport() {
         __moduleExports: exportModule,
         __mf_remote_pending: __mfRemotePending,
       };
-    })
+    }, () => ({
+      get default() {
+        return __mfDefaultExport;
+      },
+      get __moduleExports() {
+        return exportModule;
+      },
+      __mf_remote_pending: { then: (resolve, reject) => __mf_remote_pending.then(resolve, reject) },
+    }))
     .then(onFulfilled, onRejected);
 }`;
 }
@@ -6481,6 +6515,7 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 	let emittedFileName;
 	let skipTransformIds = /* @__PURE__ */ new Set();
 	let injectedTransformIds = /* @__PURE__ */ new Set();
+	const virtualEntryCode = /* @__PURE__ */ new Map();
 	const ignoredHtmlScriptSources = /* @__PURE__ */ new Set();
 	let bootstrapDir = "";
 	function skipSvelteKitSsrBuild() {
@@ -6866,7 +6901,12 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			}
 			if (htmlFilePath) addHtmlScriptEntries(htmlFilePath);
 		},
-		buildStart() {
+		async buildStart() {
+			if (inject === "entry" && waitsForInit && isClientEnvironment(this)) for (const entry of [...entryFiles]) {
+				if (path$1.isAbsolute(entry)) continue;
+				const resolved = await this.resolve(entry, void 0, { skipSelf: true }).catch(() => null);
+				if (resolved && !resolved.external && (_command === "serve" || !resolved.id.startsWith("\0"))) addEntryFile(resolveProjectId(resolved.id));
+			}
 			if (_command === "serve") return;
 			if (skipSvelteKitSsrBuild()) return;
 			if (this.environment?.name === "ssr") return;
@@ -6972,11 +7012,18 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			};
 			setTimeout(retry, 0);
 		},
+		load(id) {
+			return virtualEntryCode.get(id);
+		},
 		transform(code, id) {
 			if (skipSvelteKitSsrBuild()) return;
 			if (viteConfig?.command === "build" && !waitsForInit) return;
 			if (isSvelteKitServerModule(id)) return;
-			if (hasEntryBootstrapParam(id)) return;
+			if (hasEntryBootstrapParam(id)) return {
+				code,
+				map: null,
+				moduleSideEffects: true
+			};
 			if (normalizeModuleId(id).endsWith(".html")) return;
 			const projectId = resolveProjectId(id);
 			if (skipTransformIds.has(projectId)) return;
@@ -7010,7 +7057,11 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 				clientInjected = true;
 				injectedTransformIds.add(projectId);
 				if (!waitsForInit) return mapCodeToCodeWithSourcemap(`import ${JSON.stringify(getEntryPath())};\n` + code);
-				const entrySrc = id.includes("?") ? `${id}&${ENTRY_BOOTSTRAP_QUERY.slice(1)}` : `${id}${ENTRY_BOOTSTRAP_QUERY}`;
+				let entrySrc = id.includes("?") ? `${id}&${ENTRY_BOOTSTRAP_QUERY.slice(1)}` : `${id}${ENTRY_BOOTSTRAP_QUERY}`;
+				if (entrySrc.startsWith("\0")) {
+					virtualEntryCode.set(entrySrc, code);
+					entrySrc = toViteEncodedId(entrySrc.slice(1));
+				}
 				return mapCodeToCodeWithSourcemap(getBootstrapSource(getEntryPath(), entrySrc, false, { skipRemotePreload: _command === "serve" && isNuxtEntryAsyncModule }));
 			}
 		}
@@ -8083,7 +8134,7 @@ function ${helperName}(names) {
 }
 //#endregion
 //#region package.json
-var version$1 = "1.23.2";
+var version$1 = "1.23.3";
 //#endregion
 //#region src/virtualModules/virtualExposesSSR.ts
 /**
@@ -10486,6 +10537,8 @@ function pluginSSRRemoteEntry(options) {
 			return exposeKeys.every((key) => code.includes(JSON.stringify(key)));
 		})?.fileName;
 	};
+	const isNuxtLike = () => isNuxtProject || isNuxtClientBase(getBasePath$1(viteConfig?.base));
+	const findEmittedExposesChunk = (bundle) => Object.values(bundle).find((file) => file.type === "chunk" && file.facadeModuleId === virtualExposesSSRId)?.fileName;
 	return [{
 		name: "mf:ssr-remote-entry:pre",
 		enforce: "pre",
@@ -10528,7 +10581,7 @@ function pluginSSRRemoteEntry(options) {
 			const base = "/__mf_ssr__";
 			const basePath = getBasePath$1(viteConfig?.base);
 			const ssrEntryFileName = getSsrRemoteEntryFileName(options);
-			if (isNuxtProject || isNuxtClientBase(basePath)) server.middlewares.use((req, _res, next) => {
+			if (isNuxtLike()) server.middlewares.use((req, _res, next) => {
 				if (req.url?.replace(/\?.*/, "") === `${basePath}/${ssrEntryFileName}`) req.url = `${basePath}/__mf_ssr__/${ssrEntryFileName}`;
 				next();
 			});
@@ -10615,16 +10668,26 @@ function pluginSSRRemoteEntry(options) {
 				fileName: ssrOutputFilename,
 				preserveSignature: "strict"
 			});
+			else if (Object.keys(options.exposes).length > 0 && !isNuxtLike()) this.emitFile({
+				type: "chunk",
+				id: virtualExposesSSRId,
+				name: "ssrExposes",
+				preserveSignature: "strict"
+			});
 		},
 		generateBundle: {
 			order: "post",
 			handler(_options, bundle) {
 				const isRolldown = getIsRolldown(this);
 				const environment = this.environment;
-				const exposesChunk = findNuxtExposesChunk(bundle);
+				const exposesChunk = findNuxtExposesChunk(bundle) ?? findEmittedExposesChunk(bundle);
 				if (!isRolldown && isSsrRemoteEntryBuild(environment)) {
 					let source = getSsrRemoteEntrySource();
-					if (exposesChunk) source = source.replace(/import\("virtual:mf-exposes-ssr:[^"]+"\)/g, `import("./${exposesChunk}")`);
+					if (exposesChunk) {
+						let exposesImport = path$1.posix.relative(path$1.posix.dirname(ssrOutputFilename), exposesChunk);
+						if (!exposesImport.startsWith(".")) exposesImport = `./${exposesImport}`;
+						source = source.replace(/import\("virtual:mf-exposes-ssr:[^"]+"\)/g, `import("${exposesImport}")`);
+					}
 					this.emitFile({
 						type: "asset",
 						fileName: ssrOutputFilename,
@@ -11898,7 +11961,7 @@ export default __mfShared.default ?? __mfShared;`
 				resolveImportPath(ssrEntryLoaderSpecifier);
 				options.runtimePlugins.push([ssrEntryLoaderSpecifier, {
 					resolvedShared,
-					...options.ssrEntryLoader?.strategy ? { strategy: options.ssrEntryLoader.strategy } : {}
+					...options.ssrEntryLoader
 				}]);
 			} catch {}
 		}
@@ -11927,7 +11990,7 @@ function withoutDynamicRemoteTypeHints(options) {
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-DnEX3cp_.js").then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-CVyHPAEq.js").then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {
@@ -12077,7 +12140,11 @@ function federation(mfUserOptions) {
 				const virtualModule = VirtualModule.findById(id);
 				if (!virtualModule) return;
 				if (command === "build" && (id.includes("__loadShare__") || id.includes("__loadRemote__"))) return;
-				return virtualModule.code;
+				const code = virtualModule.code;
+				if (code && id.includes("__loadShare__")) {
+					if (isServerContext(this, loadOptions?.ssr === true)) return prependWorkspaceSingletonSsrImport(code);
+				}
+				return code;
 			}
 		},
 		...options.experiments.externalRuntime ? [pluginExternalRuntimeCore()] : [],
@@ -12337,8 +12404,7 @@ function federation(mfUserOptions) {
 					const virtualModule = VirtualModule.findById(id);
 					if (!virtualModule?.code) return null;
 					let code = virtualModule.code;
-					const consumerTarget = resolveEnvironmentConsumerTarget(this);
-					if (consumerTarget === "server" || !consumerTarget && isSsrBuild) {
+					if (isServerContext(this, isSsrBuild)) {
 						const withSsrImport = prependWorkspaceSingletonSsrImport(code);
 						if (withSsrImport !== code) {
 							const pkg = getCachedLoadSharePkg(id);

package/lib/normalizeModuleFederationOptions-DNUlv-AL.d.ts

@@ -0,0 +1,303 @@
+import { moduleFederationPlugin } from "@module-federation/sdk";
+import { ShareStrategy } from "@module-federation/runtime/types";
+//#region src/utils/normalizeModuleFederationOptions.d.ts
+interface RemoteObjectConfig {
+  type?: string;
+  name: string;
+  internalName?: string;
+  entry: string;
+  entryGlobalName?: string;
+  shareScope?: string | string[];
+}
+interface TreeShakingConfig {
+  mode: 'server-calc' | 'runtime-infer';
+  usedExports?: string[];
+}
+interface PluginManifestOptions {
+  filePath?: string;
+  disableAssetsAnalyze?: boolean;
+  fileName?: string;
+  additionalData?: (options: {
+    stats: Record<string, unknown>;
+    manifest?: Record<string, unknown>;
+    pluginOptions: Record<string, unknown>;
+    compiler?: unknown;
+    compilation?: unknown;
+    bundler: 'vite';
+  }) => Promise<Record<string, unknown> | void> | Record<string, unknown> | void;
+}
+type ModuleFederationOptions = {
+  exposes?: Record<string, string | {
+    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;
+  runtime?: any;
+  shareScope?: string | string[];
+  /**
+   * Override the public path used for remote entries
+   * Defaults to Vite's base config or "auto" if base is empty
+   */
+  publicPath?: string;
+  /**
+   * Controls whether all CSS assets from the bundle should be added to every exposed module.
+   * When false (default), the plugin will not process any CSS assets.
+   * When true, all CSS assets are bundled into every exposed module.
+   */
+  bundleAllCSS?: boolean;
+  /** Directory reserved for deploy-service generated secondary shared artifacts. */
+  treeShakingDir?: string;
+  /** Whether inferred usedExports metadata is injected into generated runtime records. */
+  injectTreeShakingUsedExports?: boolean;
+  treeShakingSharedPlugins?: string[];
+  treeShakingSharedExcludePlugins?: string[];
+  shared?: string[] | Record<string, string | {
+    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;
+    import?: moduleFederationPlugin.SharedConfig['import'];
+  }> | undefined;
+  runtimePlugins?: Array<string | [string, Record<string, unknown>]>;
+  getPublicPath?: string;
+  implementation?: string;
+  manifest?: PluginManifestOptions | boolean;
+  dev?: boolean | PluginDevOptions;
+  dts?: boolean | PluginDtsOptions;
+  shareStrategy?: ShareStrategy;
+  ignoreOrigin?: boolean;
+  virtualModuleDir?: string;
+  hostInitInjectLocation?: HostInitInjectLocationOptions;
+  /**
+   * Timeout for parsing modules in seconds.
+   * Defaults to 10 seconds.
+   */
+  moduleParseTimeout?: number;
+  /**
+   * Idle timeout for parsing modules in seconds. When set, the timeout resets
+   * on every parsed module and only fires when there has been no module activity
+   * for the configured duration. Prefer this over `moduleParseTimeout` for large
+   * codebases where the total build time may exceed the fixed timeout.
+   */
+  moduleParseIdleTimeout?: number;
+  /**
+   * Allows generate additional remoteEntry file for "var" host environment
+   */
+  varFilename?: string;
+  /**
+   * Target environment for the build to enable effective tree-shaking.
+   *
+   * @see https://module-federation.io/configure/experiments#target
+   * @default 'web' (or 'node' if build.ssr is enabled)
+   */
+  target?: 'web' | 'node';
+  /**
+   * Removes remote-consumption support from the federation runtime.
+   * Only enable this for builds that never load remotes.
+   *
+   * @default false
+   */
+  disableRemote?: boolean;
+  /**
+   * Removes shared-dependency support from the federation runtime.
+   * Only enable this when the build has no shared dependencies.
+   *
+   * @default false
+   */
+  disableShared?: boolean;
+  /**
+   * Removes snapshot support, including manifest-based remotes, preload,
+   * dynamic type hints, HMR, and devtools integration.
+   *
+   * @default false (true for Node/SSR builds)
+   */
+  disableSnapshot?: boolean;
+  /**
+   * Additional packages to mark as external in the SSR remote entry build.
+   * 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[];
+  /**
+   * 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. Optional `maxAgeMs`, `fetchTimeoutMs`,
+   * and `fetchMaxBytes` are forwarded to the loader when set.
+   */
+  ssrEntryLoader?: SsrEntryLoaderConfig;
+  /**
+   * Experimental Module Federation capabilities.
+   *
+   * @see https://module-federation.io/configure/experiments
+   */
+  experiments?: PluginExperimentsOptions;
+};
+interface PluginExperimentsOptions {
+  /**
+   * Treat `@module-federation/runtime-core` as an external that reads
+   * `globalThis._FEDERATION_RUNTIME_CORE` at runtime. Pair with a host that
+   * sets `provideExternalRuntime: true`.
+   */
+  externalRuntime?: boolean;
+  /**
+   * 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';
+  /**
+   * The host provides every shared dependency; remotes bring none. Shared keys
+   * are resolved by a native browser import map instead of the Module
+   * Federation runtime: the host emits one entry chunk per shared key and
+   * injects `<script type="importmap">`, remotes keep shared imports as bare
+   * specifiers and emit one fixed-name entry per expose plus a standard
+   * `mf-manifest.json` (without `remoteEntry`) the host maps from.
+   *
+   * Shared modules become ordinary static ES imports, so there is no
+   * `loadShare` glue and no `eager` is needed for code that reads a shared
+   * value at module-evaluation time. There is no version negotiation and no
+   * runtime API: `requiredVersion`, `strictVersion`, `shareStrategy`,
+   * `runtimePlugins` and `manifest` are ignored.
+   *
+   * @see https://github.com/module-federation/vite/issues/1381
+   */
+  hostProvidesAllShared?: boolean;
+}
+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. 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`; the
+   *   loader emits a single warning and falls back to `'temp-file'` when that
+   *   API is unavailable.
+   */
+  strategy?: SsrEntryLoaderStrategy;
+  /**
+   * 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;
+  /**
+   * Maximum time in milliseconds for each SSR network request. Defaults to
+   * 10 seconds. Set to `0` to disable the timeout.
+   */
+  fetchTimeoutMs?: number;
+  /**
+   * Maximum response body size in bytes for each SSR network request. Defaults
+   * to 10 MiB. Set to `0` to disable the limit.
+   */
+  fetchMaxBytes?: number;
+};
+type HostInitInjectLocationOptions = 'entry' | 'html';
+interface PluginDevOptions {
+  disableLiveReload?: boolean;
+  disableHotTypesReload?: boolean;
+  disableDynamicRemoteTypeHints?: boolean;
+  /**
+   * Controls cross-federation HMR for remote modules.
+   *
+   * - `false` / `undefined` — HMR disabled (default).
+   * - `true` — HMR enabled with auto-detected strategy. When a framework
+   *   plugin with cross-federation HMR support is detected, broadcast/relay
+   *   is suppressed and the framework's native HMR handles updates:
+   *     - React (`@vitejs/plugin-react` / `@vitejs/plugin-react-swc`) — the
+   *       plugin serves a `/@react-refresh` proxy on remotes that delegates
+   *       to the host's `RefreshRuntime`, unifying the component registry.
+   *     - Vue (`@vitejs/plugin-vue` / `@vitejs/plugin-vue-jsx`) — the plugin
+   *       injects a `__VUE_HMR_RUNTIME__` guard into the host page so the
+   *       first-loaded (host) Vue runtime is pinned and remote-loaded Vue
+   *       copies cannot overwrite it.
+   *   For any host, the plugin also injects a script that clears the
+   *   federation `moduleCache` on `vite:beforeUpdate` so subsequent
+   *   `loadRemote()` calls return the freshly patched module.
+   *   Other frameworks fall back to full page reloads.
+   * - `'full-reload'` — HMR enabled, always use full page reloads even when
+   *   a framework with native cross-federation HMR is detected.
+   */
+  remoteHmr?: boolean | 'full-reload';
+}
+interface RemoteTypeUrl {
+  alias?: string;
+  api: string;
+  zip: string;
+}
+interface RemoteTypeUrls {
+  [remoteName: string]: RemoteTypeUrl;
+}
+interface PluginDtsOptions {
+  generateTypes?: boolean | DtsRemoteOptions;
+  consumeTypes?: boolean | DtsHostOptions;
+  tsConfigPath?: string;
+  extraOptions?: Record<string, unknown>;
+  implementation?: string;
+  cwd?: string;
+  displayErrorInTerminal?: boolean;
+}
+interface DtsRemoteOptions {
+  tsConfigPath?: string;
+  typesFolder?: string;
+  compiledTypesFolder?: string;
+  deleteTypesFolder?: boolean;
+  additionalFilesToCompile?: string[];
+  compilerInstance?: 'tsc' | 'vue-tsc' | 'tspc' | string;
+  compileInChildProcess?: boolean;
+  generateAPITypes?: boolean;
+  extractThirdParty?: boolean | {
+    exclude?: Array<string | RegExp>;
+  };
+  extractRemoteTypes?: boolean;
+  abortOnError?: boolean;
+  deleteTsConfig?: boolean;
+  afterGenerate?: (options: moduleFederationPlugin.DtsGenerateTypesHookOptions) => Promise<void> | void;
+}
+interface DtsHostOptions {
+  typesFolder?: string;
+  abortOnError?: boolean;
+  remoteTypesFolder?: string;
+  deleteTypesFolder?: boolean;
+  maxRetries?: number;
+  consumeAPITypes?: boolean;
+  runtimePkgs?: string[];
+  remoteTypeUrls?: (() => Promise<RemoteTypeUrls>) | RemoteTypeUrls;
+  timeout?: number;
+  family?: 0 | 4 | 6;
+  typesOnBuild?: boolean;
+}
+//#endregion
+export { SsrEntryLoaderStrategy as a, SsrEntryLoaderConfig as i, PluginExperimentsOptions as n, TreeShakingConfig as o, PluginManifestOptions as r, ModuleFederationOptions as t };

package/lib/{pluginDts-DnEX3cp_.js → pluginDts-CVyHPAEq.js}

@@ -1,5 +1,5 @@
 import { l as normalizePathForImport, n as mfError, t as createModuleFederationError } from "./logger-DOwfTlw5.js";
-import { g as resolveImportPath, u as hasPackageDependency } from "./dtsConstants-r5OfegUr.js";
+import { g as resolveImportPath, u as hasPackageDependency } from "./dtsConstants-DSTzyKSG.js";
 import fs from "fs";
 import * as path$1 from "node:path";
 import { normalizeOptions } from "@module-federation/sdk";

package/lib/{ssrEntryLoader-DEH3eV1e.js → ssrEntryLoader-DjZj-5Lw.js}

@@ -1,4 +1,5 @@
 import { a as CodeRewriter, i as createCodePositionMap, r as mfWarn, s as EXTERNAL_URL_RE } from "./logger-DOwfTlw5.js";
+import { simpleJoinRemoteEntry } from "@module-federation/sdk";
 //#region src/utils/fetchWithTimeout.ts
 const DEFAULT_SSR_FETCH_TIMEOUT_MS = 1e4;
 const DEFAULT_SSR_FETCH_MAX_BYTES = 10 * 1024 * 1024;
@@ -361,15 +362,14 @@ function getEntryFilename(entryUrl) {
 }
 function resolveEntryAssetUrl(entry, manifestUrl) {
 	const base = manifestUrl.replace(/\/[^/]+$/, "/");
-	return new URL(`${entry.path || ""}${entry.name}`, base).href;
+	return new URL(simpleJoinRemoteEntry(entry.path || "", entry.name), base).href;
 }
 function resolveSSREntryUrl(manifest, manifestUrl) {
 	const entry = parseManifestEntry(manifest.metaData?.ssrRemoteEntry);
 	if (!entry) return null;
 	const base = manifestUrl.replace(/\/[^/]+$/, "/");
-	const entryPath = entry.path + entry.name;
 	return {
-		url: new URL(entryPath, base).href,
+		url: new URL(simpleJoinRemoteEntry(entry.path, entry.name), base).href,
 		type: entry.type,
 		versionKey: computeManifestVersionKey(manifest)
 	};
@@ -834,7 +834,7 @@ async function importTempModule(filePath, versionKey) {
 let warnedVmUnavailable = false;
 let vmStrategyModulePromise;
 function getVmStrategyModule() {
-	if (!vmStrategyModulePromise) vmStrategyModulePromise = import("./ssrVmStrategy-COMHOCN2.js");
+	if (!vmStrategyModulePromise) vmStrategyModulePromise = import("./ssrVmStrategy-Dk5xXVvR.js");
 	return vmStrategyModulePromise;
 }
 /**
@@ -902,9 +902,12 @@ async function loadSSRRemoteEntry(ssrEntry, options, rootEntryUrl) {
 		const cacheDir = await getSSRCacheDir();
 		mkdirSync(cacheDir, { recursive: true });
 		const sharedPkgMap = new Map(Object.entries(resolvedShared));
-		const extension = type === "commonjs-module" || type === "commonjs" ? ".js" : ".mjs";
+		const isCommonJs = type === "commonjs-module" || type === "commonjs";
+		const extension = isCommonJs ? ".cjs" : ".mjs";
 		try {
-			return await importTempModule(await fetchEsmGraphToTempFile(url, cacheDir, sharedPkgMap, versionKey, options.fetchTimeoutMs, getSsrTransformContextKey(resolvedShared, options.shareScopeName), options.fetchMaxBytes, extension, rootEntryUrl), versionKey);
+			const tmpFile = await fetchEsmGraphToTempFile(url, cacheDir, sharedPkgMap, versionKey, options.fetchTimeoutMs, getSsrTransformContextKey(resolvedShared, options.shareScopeName), options.fetchMaxBytes, extension, rootEntryUrl);
+			if (isCommonJs) return (await _module()).createRequire(import.meta.url)(tmpFile);
+			return await importTempModule(tmpFile, versionKey);
 		} catch (error) {
 			if (isSsrEntryHttpError(error) || isSsrFetchBodyTooLargeError(error)) throw error;
 			warnStrategyFallback("temp-file", url, "the federation runtime's loader", error);
@@ -941,7 +944,10 @@ function ssrEntryLoaderPlugin(options = {}) {
 			} : resolved;
 			const ssrEntry = await getSSREntry(remoteInfo.entry, loadOptions.maxAgeMs, loadOptions.fetchTimeoutMs, loadOptions.fetchMaxBytes);
 			if (!ssrEntry) return;
-			const mod = await loadSSRRemoteEntry(ssrEntry, loadOptions, remoteInfo.entry);
+			const mod = await loadSSRRemoteEntry(ssrEntry.url === remoteInfo.entry && remoteInfo.type ? {
+				...ssrEntry,
+				type: remoteInfo.type
+			} : ssrEntry, loadOptions, remoteInfo.entry);
 			if (!mod) return;
 			return mod;
 		}

package/lib/{ssrVmStrategy-COMHOCN2.js → ssrVmStrategy-Dk5xXVvR.js}

@@ -1,5 +1,5 @@
 import { t as findSharedKey } from "./sharedKeyMatcher-Od_nYxJA.js";
-import { c as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, s as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-DEH3eV1e.js";
+import { c as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, s as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-DjZj-5Lw.js";
 //#region src/utils/ssrVmStrategy.ts
 /**
 * vm.SourceTextModule strategy for loading remote SSR entries.

package/lib/utils/ssrEntryLoader.d.ts

@@ -1,30 +1,5 @@
+import { i as SsrEntryLoaderConfig } from "../normalizeModuleFederationOptions-DNUlv-AL.js";
 //#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 (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 by this integration because the
- *    cross-process `fetchModule` proxy uses Vite 8's environment APIs.
- *    `ModuleRunner` itself is available in earlier Vite versions, but an older
- *    remote needs a different transport and server endpoint.
- *
- * 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;
@@ -63,7 +38,7 @@ declare function neutralizeBrowserPreloadHelpers(code: string): string;
  *
  * The plugin is also injected automatically for SSR contexts by the vite plugin.
  */
-interface SsrEntryLoaderOptions {
+interface SsrEntryLoaderOptions extends SsrEntryLoaderConfig {
   /**
    * Pre-resolved absolute file paths for common shared packages, keyed by
    * bare specifier. Populated at build time by the Vite plugin from the MF
@@ -72,43 +47,11 @@ 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;
-  /**
-   * Maximum time in milliseconds for each SSR network request. Defaults to
-   * 10 seconds. Set to `0` to disable the timeout.
-   */
-  fetchTimeoutMs?: number;
-  /**
-   * Maximum response body size in bytes for each SSR network request. Defaults
-   * to 10 MiB. Set to `0` to disable the limit.
-   */
-  fetchMaxBytes?: number;
 }
 declare function ssrEntryLoaderPlugin(options?: SsrEntryLoaderOptions): {
   name: string;

package/lib/utils/ssrEntryLoader.js

@@ -1,2 +1,2 @@
-import { i as ssrEntryLoaderPlugin, n as neutralizeBrowserPreloadHelpers, r as revalidate, t as SsrEntryHttpError } from "../ssrEntryLoader-DEH3eV1e.js";
+import { i as ssrEntryLoaderPlugin, n as neutralizeBrowserPreloadHelpers, r as revalidate, t as SsrEntryHttpError } from "../ssrEntryLoader-DjZj-5Lw.js";
 export { SsrEntryHttpError, ssrEntryLoaderPlugin as default, neutralizeBrowserPreloadHelpers, revalidate };

package/package.json

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