@module-federation/vite 1.23.1 → 1.23.3

package/lib/{logger--uKHOVjR.js → logger-DOwfTlw5.js}

@@ -363,4 +363,4 @@ const moduleFederationConsole = {
 const mfWarn = moduleFederationConsole.warn;
 const mfError = moduleFederationConsole.error;
 //#endregion
-export { CodeRewriter as a, normalizePathForImport as c, createCodePositionMap as i, rebaseImport as l, mfError as n, createSourceMap as o, mfWarn as r, EXTERNAL_URL_RE as s, createModuleFederationError as t, resolveHashPlaceholderFileName as u };
+export { CodeRewriter as a, isAbsoluteUrl as c, resolveHashPlaceholderFileName as d, createCodePositionMap as i, normalizePathForImport as l, mfError as n, createSourceMap as o, mfWarn as r, EXTERNAL_URL_RE as s, createModuleFederationError as t, rebaseImport as u };

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-DxgS2FEd.js → pluginDts-CVyHPAEq.js}

@@ -1,9 +1,9 @@
-import { c as normalizePathForImport, n as mfError, t as createModuleFederationError } from "./logger--uKHOVjR.js";
-import { g as resolveImportPath, u as hasPackageDependency } from "./dtsConstants-Bs4FukGL.js";
+import { l as normalizePathForImport, n as mfError, t as createModuleFederationError } from "./logger-DOwfTlw5.js";
+import { g as resolveImportPath, u as hasPackageDependency } from "./dtsConstants-DSTzyKSG.js";
 import fs from "fs";
 import * as path$1 from "node:path";
-import os from "os";
 import { normalizeOptions } from "@module-federation/sdk";
+import os from "os";
 import { consumeTypesAPI, generateTypesAPI, isTSProject, normalizeConsumeTypesOptions, normalizeDtsOptions, normalizeGenerateTypesOptions } from "@module-federation/dts-plugin";
 import { rpc } from "@module-federation/dts-plugin/core";
 //#region src/plugins/pluginDts.ts

package/lib/{ssrEntryLoader-DmqLXUmm.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--uKHOVjR.js";
+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)
 	};
@@ -483,25 +483,30 @@ async function getSSREntry(remoteEntryUrl, maxAgeMs, fetchTimeoutMs, fetchMaxByt
 	return record.promise;
 }
 /**
-* Drop per-remote temp-file caches after a version change so old artifacts stop
-* being reused. Temp-file cache keys hold SSR entry/chunk URLs (not the
-* browser entry URL), so scope the invalidation by origin.
+* Drop a remote graph's temp-file caches after a version change so old
+* artifacts stop being reused. A generated module can be shared by multiple
+* remote graphs, so cleanup is scoped by graph owner rather than URL origin.
 */
 function dropRemoteTempFileCaches(remoteEntryUrl) {
-	const origin = getUrlOrigin(remoteEntryUrl);
-	if (!origin) return;
-	const staleRecords = [...tempFileRecords.values()].filter((record) => record.remoteOrigin === origin);
-	for (const [key] of tempFileCache) if (JSON.parse(key).find((part) => typeof part === "string" && /^https?:\/\//.test(part))?.startsWith(origin)) {
+	const staleRecords = [];
+	for (const [key, record] of tempFileRecords) {
+		if (!record.owners.delete(remoteEntryUrl) || record.owners.size > 0) continue;
 		tempFileCache.delete(key);
 		tempFilePathCache.delete(key);
+		staleRecords.push(record);
 	}
 	scheduleTempFileCleanup(staleRecords);
 }
-/** Invalidate all SSR loader caches owned by a remote. */
-async function invalidateRemoteCaches(remoteEntryUrl) {
+/**
+* Invalidate all SSR loader caches owned by a remote. The runtime loading map
+* is cleared synchronously so `revalidate()` can safely clear module caches
+* immediately after invoking this function.
+*/
+function invalidateRemoteCaches(remoteEntryUrl) {
+	invalidateRuntimeRemoteEntry(remoteEntryUrl);
 	dropRemoteTempFileCaches(remoteEntryUrl);
 	scheduleVmCacheCleanup(remoteEntryUrl);
-	await clearRunnerCaches(remoteEntryUrl);
+	return clearRunnerCaches(remoteEntryUrl);
 }
 /**
 * The VM strategy owns separate in-memory module-graph caches. Keep their
@@ -512,6 +517,12 @@ function scheduleVmCacheCleanup(remoteEntryUrl) {
 	if (!vmStrategyModulePromise) return;
 	vmStrategyModulePromise.then(({ clearVmStrategyCaches }) => clearVmStrategyCaches(remoteEntryUrl)).catch(() => {});
 }
+/**
+* A dev-mode ModuleRunner is created per origin (one Vite dev server) and is
+* shared by every remote that server hosts, so its module cache can only be
+* cleared as a whole. Origin scoping is therefore the finest granularity here;
+* clearing only costs a re-evaluation, no generated files are removed.
+*/
 async function clearRunnerCaches(remoteEntryUrl) {
 	let remoteOrigin;
 	if (remoteEntryUrl) {
@@ -526,7 +537,9 @@ async function clearRunnerCaches(remoteEntryUrl) {
 }
 /** Invalidate all SSR loader caches across every remote. */
 function invalidateAllRemoteCaches() {
+	invalidateRuntimeRemoteEntry();
 	const staleRecords = [...tempFileRecords.values()];
+	for (const record of staleRecords) record.owners.clear();
 	tempFileCache.clear();
 	tempFilePathCache.clear();
 	scheduleTempFileCleanup(staleRecords);
@@ -534,6 +547,17 @@ function invalidateAllRemoteCaches() {
 	clearRunnerCaches();
 }
 /**
+* runtime-core deduplicates remote entry loads in a process-global map. The
+* SSR loader's module cache invalidation must evict the matching runtime entry
+* too, otherwise the next loadRemote() returns the pre-revalidation container
+* without invoking this loader again.
+*/
+function invalidateRuntimeRemoteEntry(remoteEntryUrl) {
+	const globalLoading = globalThis.__GLOBAL_LOADING_REMOTE_ENTRY__;
+	if (!globalLoading) return;
+	for (const key of Object.keys(globalLoading)) if (remoteEntryUrl === void 0 || key === remoteEntryUrl || key.endsWith(`:${remoteEntryUrl}`)) delete globalLoading[key];
+}
+/**
 * Drop the loader's caches so the next `loadEntry` re-resolves and re-fetches
 * remote SSR entries. Pass a remote entry URL to scope the invalidation to one
 * remote; call with no arguments to invalidate everything.
@@ -579,6 +603,7 @@ function scheduleTempFileCleanup(records) {
 async function cleanupTempFileRecord(record) {
 	try {
 		await record.promise.catch(() => void 0);
+		if (record.owners.size > 0) return;
 		if (tempFileRecords.get(record.cacheKey) !== record) return;
 		const filePath = await record.filePathPromise;
 		const { rmSync } = await _fs();
@@ -733,7 +758,7 @@ function getTempFileImportUrl(filePath, versionKey) {
 * a remote redeploy (new manifest → new key) produces new files and bypasses
 * Node's ESM module cache instead of serving the stale build.
 */
-async function fetchEsmToTempFile(url, tmpDir, visited, pending, sharedPkgMap, versionKey = UNVERSIONED, fetchTimeoutMs = DEFAULT_SSR_FETCH_TIMEOUT_MS, contextKey = "default", fetchMaxBytes = DEFAULT_SSR_FETCH_MAX_BYTES, extension = ".mjs") {
+async function fetchEsmToTempFile(url, tmpDir, visited, pending, sharedPkgMap, versionKey = UNVERSIONED, fetchTimeoutMs = DEFAULT_SSR_FETCH_TIMEOUT_MS, contextKey = "default", fetchMaxBytes = DEFAULT_SSR_FETCH_MAX_BYTES, extension = ".mjs", owner) {
 	const cacheKey = JSON.stringify([
 		fetchTimeoutMs,
 		fetchMaxBytes,
@@ -745,6 +770,7 @@ async function fetchEsmToTempFile(url, tmpDir, visited, pending, sharedPkgMap, v
 	if (visited.has(url)) return visited.get(url);
 	const cached = tempFileCache.get(cacheKey);
 	if (cached) {
+		if (owner) tempFileRecords.get(cacheKey)?.owners.add(owner);
 		pending.add(cached);
 		const reserved = tempFilePathCache.get(cacheKey);
 		const tmpFile = reserved ? await reserved : await cached;
@@ -768,7 +794,7 @@ async function fetchEsmToTempFile(url, tmpDir, visited, pending, sharedPkgMap, v
 		const relImports = specifiers.map(({ value }) => value).filter((value) => isRelativeSpecifier(value) && !isVitePreloadHelperSpecifier(value)).map((value) => new URL(value, 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, pending, sharedPkgMap, versionKey, fetchTimeoutMs, contextKey, fetchMaxBytes, extension);
+			const tmpPath = await fetchEsmToTempFile(u, tmpDir, visited, pending, sharedPkgMap, versionKey, fetchTimeoutMs, contextKey, fetchMaxBytes, extension, owner);
 			subMap.set(u, getTempFileImportUrl(tmpPath, versionKey));
 		}));
 		const requireShimUrl = sharedPkgMap?.size && specifiers.some(({ value }) => isNodeModuleSpecifier(value)) ? await getRequireShimUrl(tmpDir, sharedPkgMap, contextKey) : void 0;
@@ -781,7 +807,7 @@ async function fetchEsmToTempFile(url, tmpDir, visited, pending, sharedPkgMap, v
 		cacheKey,
 		filePathPromise: tmpFilePromise,
 		promise,
-		remoteOrigin: getUrlOrigin(url)
+		owners: owner ? /* @__PURE__ */ new Set([owner]) : /* @__PURE__ */ new Set()
 	};
 	tempFileRecords.set(cacheKey, record);
 	tempFileCache.set(cacheKey, promise);
@@ -793,9 +819,9 @@ async function fetchEsmToTempFile(url, tmpDir, visited, pending, sharedPkgMap, v
 	});
 	return promise;
 }
-async function fetchEsmGraphToTempFile(url, tmpDir, sharedPkgMap, versionKey = UNVERSIONED, fetchTimeoutMs = DEFAULT_SSR_FETCH_TIMEOUT_MS, contextKey = "default", fetchMaxBytes = DEFAULT_SSR_FETCH_MAX_BYTES, extension = ".mjs") {
+async function fetchEsmGraphToTempFile(url, tmpDir, sharedPkgMap, versionKey = UNVERSIONED, fetchTimeoutMs = DEFAULT_SSR_FETCH_TIMEOUT_MS, contextKey = "default", fetchMaxBytes = DEFAULT_SSR_FETCH_MAX_BYTES, extension = ".mjs", owner) {
 	const pending = /* @__PURE__ */ new Set();
-	const rootFile = await fetchEsmToTempFile(url, tmpDir, /* @__PURE__ */ new Map(), pending, sharedPkgMap, versionKey, fetchTimeoutMs, contextKey, fetchMaxBytes, extension);
+	const rootFile = await fetchEsmToTempFile(url, tmpDir, /* @__PURE__ */ new Map(), pending, sharedPkgMap, versionKey, fetchTimeoutMs, contextKey, fetchMaxBytes, extension, owner);
 	await Promise.all(pending);
 	return rootFile;
 }
@@ -808,7 +834,7 @@ async function importTempModule(filePath, versionKey) {
 let warnedVmUnavailable = false;
 let vmStrategyModulePromise;
 function getVmStrategyModule() {
-	if (!vmStrategyModulePromise) vmStrategyModulePromise = import("./ssrVmStrategy-B_e3yqa2.js");
+	if (!vmStrategyModulePromise) vmStrategyModulePromise = import("./ssrVmStrategy-Dk5xXVvR.js");
 	return vmStrategyModulePromise;
 }
 /**
@@ -819,7 +845,7 @@ function getVmStrategyModule() {
 function warnStrategyFallback(strategy, url, fallback, error) {
 	mfWarn(`SSR entry loader: strategy "${strategy}" failed to load ${url}; falling back to ${fallback}.`, error);
 }
-async function tryVmStrategy(ssrEntry, options) {
+async function tryVmStrategy(ssrEntry, options, rootEntryUrl) {
 	const { loadViaVmStrategy, isVmStrategyAvailable } = await getVmStrategyModule();
 	if (!await isVmStrategyAvailable()) {
 		if (!warnedVmUnavailable) {
@@ -835,10 +861,11 @@ async function tryVmStrategy(ssrEntry, options) {
 		fetchTimeoutMs: options.fetchTimeoutMs,
 		fetchMaxBytes: options.fetchMaxBytes,
 		cacheContext: options.cacheContext,
-		federationInstance: options.federationInstance
+		federationInstance: options.federationInstance,
+		rootEntryUrl
 	});
 }
-async function loadSSRRemoteEntry(ssrEntry, options) {
+async function loadSSRRemoteEntry(ssrEntry, options, rootEntryUrl) {
 	const { url, type, versionKey } = ssrEntry;
 	const { resolvedShared } = options;
 	if (type === "commonjs-module" || type === "commonjs") {
@@ -865,7 +892,7 @@ async function loadSSRRemoteEntry(ssrEntry, options) {
 			}
 		}
 		if (options.strategy === "vm") try {
-			const fromVm = await tryVmStrategy(ssrEntry, options);
+			const fromVm = await tryVmStrategy(ssrEntry, options, rootEntryUrl);
 			if (fromVm) return fromVm;
 		} catch (error) {
 			if (isSsrEntryHttpError(error) || isSsrFetchBodyTooLargeError(error)) throw error;
@@ -875,9 +902,12 @@ async function loadSSRRemoteEntry(ssrEntry, options) {
 		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), 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);
@@ -914,11 +944,14 @@ 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);
+			const mod = await loadSSRRemoteEntry(ssrEntry.url === remoteInfo.entry && remoteInfo.type ? {
+				...ssrEntry,
+				type: remoteInfo.type
+			} : ssrEntry, loadOptions, remoteInfo.entry);
 			if (!mod) return;
 			return mod;
 		}
 	};
 }
 //#endregion
-export { getUrlOrigin as a, fetchWithTimeout as c, ssrEntryLoaderPlugin as i, readResponseTextBounded as l, neutralizeBrowserPreloadHelpers as n, DEFAULT_SSR_FETCH_MAX_BYTES as o, revalidate as r, DEFAULT_SSR_FETCH_TIMEOUT_MS as s, SsrEntryHttpError as t };
+export { DEFAULT_SSR_FETCH_MAX_BYTES as a, readResponseTextBounded as c, ssrEntryLoaderPlugin as i, neutralizeBrowserPreloadHelpers as n, DEFAULT_SSR_FETCH_TIMEOUT_MS as o, revalidate as r, fetchWithTimeout as s, SsrEntryHttpError as t };

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

@@ -1,5 +1,5 @@
 import { t as findSharedKey } from "./sharedKeyMatcher-Od_nYxJA.js";
-import { a as getUrlOrigin, c as fetchWithTimeout, l as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, t as SsrEntryHttpError } from "./ssrEntryLoader-DmqLXUmm.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.
@@ -144,30 +144,24 @@ function addVmCacheOwner(ownersByCacheKey, cacheKey, rootEntryUrl) {
 	owners.add(rootEntryUrl);
 	ownersByCacheKey.set(cacheKey, owners);
 }
-function clearOwnedVmCache(cache, ownersByCacheKey, remoteOrigin) {
+function clearOwnedVmCache(cache, ownersByCacheKey, remoteEntryUrl) {
 	for (const [cacheKey, owners] of ownersByCacheKey) {
-		if (!remoteOrigin) {
-			cache.delete(cacheKey);
-			ownersByCacheKey.delete(cacheKey);
-			continue;
-		}
-		for (const owner of owners) if (getUrlOrigin(owner) === remoteOrigin) owners.delete(owner);
-		if (owners.size === 0) {
-			cache.delete(cacheKey);
-			ownersByCacheKey.delete(cacheKey);
-		}
+		if (remoteEntryUrl !== void 0 && !owners.delete(remoteEntryUrl)) continue;
+		if (remoteEntryUrl !== void 0 && owners.size > 0) continue;
+		cache.delete(cacheKey);
+		ownersByCacheKey.delete(cacheKey);
 	}
 }
 /**
 * Drop cached VM module graphs after a remote revalidation. A module graph can
-* contain URLs from another origin, so ownership is tracked by the root entry
-* rather than inferred from each module URL.
+* contain URLs from another origin, and one origin can serve several remotes,
+* so ownership is tracked by the owning remote entry URL rather than inferred
+* from each module URL. A module shared by several graphs stays cached while
+* another remote still owns it.
 */
 function clearVmStrategyCaches(remoteEntryUrl) {
-	const remoteOrigin = remoteEntryUrl === void 0 ? void 0 : getUrlOrigin(remoteEntryUrl);
-	if (remoteEntryUrl !== void 0 && !remoteOrigin) return;
-	clearOwnedVmCache(httpModuleCache, httpModuleCacheOwners, remoteOrigin);
-	clearOwnedVmCache(namespaceCache, namespaceCacheOwners, remoteOrigin);
+	clearOwnedVmCache(httpModuleCache, httpModuleCacheOwners, remoteEntryUrl);
+	clearOwnedVmCache(namespaceCache, namespaceCacheOwners, remoteEntryUrl);
 }
 function getBodyPreview(body) {
 	return body.slice(0, 240).replace(/\s+/g, " ").trim();
@@ -243,12 +237,13 @@ async function importDynamically(vm, specifier, referencingModule, options) {
 async function loadViaVmStrategy(entryUrl, options) {
 	const vm = await getVmApi();
 	if (!vm) return null;
+	const rootEntryUrl = options.rootEntryUrl ?? entryUrl;
 	const graphOptions = {
 		...options,
-		rootEntryUrl: entryUrl
+		rootEntryUrl
 	};
 	const cacheKey = `${getVmCacheContextKey(options)}::${options.versionKey}::${entryUrl}`;
-	addVmCacheOwner(namespaceCacheOwners, cacheKey, entryUrl);
+	addVmCacheOwner(namespaceCacheOwners, cacheKey, rootEntryUrl);
 	if (!namespaceCache.has(cacheKey)) namespaceCache.set(cacheKey, (async () => {
 		const entryModule = await getHttpModule(vm, entryUrl, graphOptions);
 		const linker = (specifier, referencingModule) => linkModule(vm, specifier, referencingModule, graphOptions);