@module-federation/vite 1.23.4 → 1.23.5

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

@@ -1,5 +1,5 @@
-import { d as getNodeModulesSuffix, r as getSharedRuntimeKey } from "./sharedKeyMatcher-Od_nYxJA.js";
-import { r as mfWarn, t as createModuleFederationError } from "./logger-DOwfTlw5.js";
+import { d as getNodeModulesSuffix, r as getSharedRuntimeKey } from "./sharedKeyMatcher-CHp4QRNq.js";
+import { l as normalizePathForImport, r as mfWarn, t as createModuleFederationError } from "./logger-DOwfTlw5.js";
 import { existsSync, readFileSync, readdirSync, realpathSync } from "fs";
 import { createRequire } from "module";
 import * as path$1 from "node:path";
@@ -93,22 +93,34 @@ function substituteExportsWildcard(target, patternMatch) {
 	}
 	return target;
 }
+/** Splits an exports pattern at its wildcard. Node substitutes only the first one, so a second never matches. */
+function splitExportsPattern(pattern) {
+	const wildcardIndex = pattern.indexOf("*");
+	if (wildcardIndex === -1) return void 0;
+	const trailer = pattern.slice(wildcardIndex + 1);
+	if (trailer.includes("*")) return void 0;
+	return {
+		base: pattern.slice(0, wildcardIndex),
+		trailer
+	};
+}
+/** The text `value` substitutes for the wildcard of a pattern split by `splitExportsPattern`. */
+function matchExportsPatternPart(value, { base, trailer }) {
+	if (!value.startsWith(base) || !value.endsWith(trailer)) return void 0;
+	if (value.length <= base.length + trailer.length) return void 0;
+	return value.slice(base.length, value.length - trailer.length);
+}
 function matchExportsSubpath(record, subpath) {
 	if (subpath in record) return record[subpath];
 	let bestKey;
 	let bestBaseLength = -1;
 	let bestKeyLength = -1;
 	for (const key of Object.keys(record)) {
-		const wildcardIndex = key.indexOf("*");
-		if (wildcardIndex === -1) continue;
-		const patternBase = key.slice(0, wildcardIndex);
-		const patternTrailer = key.slice(wildcardIndex + 1);
-		if (patternTrailer.includes("*")) continue;
-		if (!subpath.startsWith(patternBase) || !subpath.endsWith(patternTrailer)) continue;
-		if (subpath.length <= patternBase.length + patternTrailer.length) continue;
-		if (patternBase.length > bestBaseLength || patternBase.length === bestBaseLength && key.length > bestKeyLength) {
+		const pattern = splitExportsPattern(key);
+		if (!pattern || matchExportsPatternPart(subpath, pattern) === void 0) continue;
+		if (pattern.base.length > bestBaseLength || pattern.base.length === bestBaseLength && key.length > bestKeyLength) {
 			bestKey = key;
-			bestBaseLength = patternBase.length;
+			bestBaseLength = pattern.base.length;
 			bestKeyLength = key.length;
 		}
 	}
@@ -139,6 +151,74 @@ function isPackageExportAvailable(pkg, opts = {}) {
 	if (installed?.packageJson.exports == null) return true;
 	return resolveExportsEntry(getPackageExportsTarget(pkg, packageName, installed.packageJson.exports), opts.conditions) !== void 0;
 }
+function stripRelativePrefix(target) {
+	return normalizePathForImport(target).replace(/^\.\//, "");
+}
+/**
+* Specifiers the installed package publishes for the file at `relFilePath` — a path below the
+* package root, such as `dist/button.js` — ordered most specific first.
+*
+* `exports` maps specifiers to files, so a specifier rebuilt from a resolved path is only valid
+* when the package happens to publish its files at the paths they occupy on disk. A package that
+* remaps directories (`"./*": "./dist/*.js"`) publishes `pkg/button` and never
+* `pkg/dist/button.js`, so the rebuilt specifier names a file the package does not export.
+* Reversing the map recovers the specifiers that do resolve back to that file.
+*
+* Candidates are ordered by the same precedence `matchExportsSubpath` applies when resolving
+* forwards — exact keys, then the longest pattern prefix, then the longest key — so a caller
+* that takes the first match picks the same specifier for a file in every build, and in every
+* container that shares the package.
+*
+* Empty when the package exports nothing that resolves to the file, which is the case for its
+* internals and for subpaths an explicit `null` blocks. Lenient when the package cannot be found
+* or has no `exports`, matching `isPackageExportAvailable`: every file is then reachable at its
+* own path, so the path is the specifier.
+*/
+function getPackageExportSpecifiersForFile(packageName, relFilePath, opts = {}) {
+	const file = `./${stripRelativePrefix(relFilePath)}`;
+	const toSpecifier = (subpath) => subpath === "." ? packageName : `${packageName}${subpath.slice(1)}`;
+	const exportsField = getInstalledPackageJson(packageName, opts)?.packageJson.exports;
+	if (exportsField == null) return [toSpecifier(file)];
+	if (typeof exportsField === "string") return stripRelativePrefix(exportsField) === stripRelativePrefix(file) ? [packageName] : [];
+	if (typeof exportsField !== "object") return [];
+	const record = exportsField;
+	const subpathKeys = Object.keys(record).filter((key) => key.startsWith("."));
+	if (subpathKeys.length === 0) {
+		const target = resolveExportsEntry(record, opts.conditions);
+		return typeof target === "string" && stripRelativePrefix(target) === stripRelativePrefix(file) ? [packageName] : [];
+	}
+	const candidates = [];
+	for (const key of subpathKeys) {
+		if (!key.includes("*")) {
+			candidates.push({
+				subpath: key,
+				isPattern: false,
+				baseLength: key.length,
+				keyLength: key.length
+			});
+			continue;
+		}
+		const keyPattern = splitExportsPattern(key);
+		if (!keyPattern) continue;
+		const target = resolveExportsEntry(record[key], opts.conditions);
+		const targetPattern = typeof target === "string" ? splitExportsPattern(target) : void 0;
+		if (!targetPattern) continue;
+		const patternMatch = matchExportsPatternPart(file, targetPattern);
+		if (patternMatch === void 0) continue;
+		candidates.push({
+			subpath: keyPattern.base + patternMatch + keyPattern.trailer,
+			isPattern: true,
+			baseLength: keyPattern.base.length,
+			keyLength: key.length
+		});
+	}
+	const verified = candidates.filter((candidate) => {
+		const target = resolveExportsEntry(getPackageExportsTarget(toSpecifier(candidate.subpath), packageName, record), opts.conditions);
+		return typeof target === "string" && stripRelativePrefix(target) === stripRelativePrefix(file);
+	});
+	verified.sort((a, b) => Number(a.isPattern) - Number(b.isPattern) || b.baseLength - a.baseLength || b.keyLength - a.keyLength || (a.subpath < b.subpath ? -1 : a.subpath > b.subpath ? 1 : 0));
+	return [...new Set(verified.map((candidate) => toSpecifier(candidate.subpath)))];
+}
 /**
 * Escaping rules:
 * Convert using the format __${mapping}__, where _ and $ are not allowed in npm package names but can be used in variable names.
@@ -664,4 +744,4 @@ function hasPackageDependency(dependencyName, cwd = packageDetectionCwd || proce
 //#region src/utils/dtsConstants.ts
 const DEFAULT_PUBLIC_TYPES_FOLDER = "@mf-types";
 //#endregion
-export { isReactCoreShare as C, REACT_DOM_CLIENT_SHARE as S, resolveModulePath as _, getIsRolldown as a, supportsCodeSplittingGroupDebugName as b, getPackageNameFromNodeModulePath as c, isNuxtProjectRoot as d, isPackageExportAvailable as f, resolveImportPath as g, packageNameEncode as h, getInstalledPackageJson as i, getSharedCacheDescriptor as l, packageNameDecode as m, getDependencyNames as n, getPackageDetectionCwd as o, isPackageInstalled as p, getInstalledPackageEntry as r, getPackageName as s, DEFAULT_PUBLIC_TYPES_FOLDER as t, hasPackageDependency as u, setPackageDetectionCwd as v, REACT_CLIENT_INTERNALS_KEY as x, sharedCacheHelperCode as y };
+export { REACT_DOM_CLIENT_SHARE as C, REACT_CLIENT_INTERNALS_KEY as S, resolveImportPath as _, getIsRolldown as a, sharedCacheHelperCode as b, getPackageName as c, hasPackageDependency as d, isNuxtProjectRoot as f, packageNameEncode as g, packageNameDecode as h, getInstalledPackageJson as i, getPackageNameFromNodeModulePath as l, isPackageInstalled as m, getDependencyNames as n, getPackageDetectionCwd as o, isPackageExportAvailable as p, getInstalledPackageEntry as r, getPackageExportSpecifiersForFile as s, DEFAULT_PUBLIC_TYPES_FOLDER as t, getSharedCacheDescriptor as u, resolveModulePath as v, isReactCoreShare as w, supportsCodeSplittingGroupDebugName as x, setPackageDetectionCwd as y };

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 { _ as removeTrailingSlash, a as matchesSharedSource, b as stripViteFsPrefix, 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 resolvePublicPath, y as stripQueryAndHash } from "./sharedKeyMatcher-CHp4QRNq.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-DSTzyKSG.js";
+import { C as REACT_DOM_CLIENT_SHARE, S as REACT_CLIENT_INTERNALS_KEY, _ as resolveImportPath, a as getIsRolldown, b as sharedCacheHelperCode, c as getPackageName, d as hasPackageDependency, f as isNuxtProjectRoot, g as packageNameEncode, h as packageNameDecode, i as getInstalledPackageJson, l as getPackageNameFromNodeModulePath, m as isPackageInstalled, n as getDependencyNames, o as getPackageDetectionCwd, p as isPackageExportAvailable, r as getInstalledPackageEntry, s as getPackageExportSpecifiersForFile, u as getSharedCacheDescriptor, v as resolveModulePath, w as isReactCoreShare, x as supportsCodeSplittingGroupDebugName, y as setPackageDetectionCwd } from "./dtsConstants-BQdFpgKb.js";
 import { createRequire } from "node:module";
 import * as fs$2 from "fs";
 import { existsSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "fs";
@@ -977,6 +977,16 @@ function getSsrCapabilities(viteMajor, command, hasRemotes, isSsr = false) {
 	};
 }
 //#endregion
+//#region src/utils/runtimePluginSpecifier.ts
+function getRuntimePluginSpecifier(plugin) {
+	return typeof plugin === "string" ? plugin : plugin[0];
+}
+/** Drop SSR-only plugins from a client graph; a server graph keeps them all. */
+function filterRuntimePluginsForTarget(runtimePlugins, ssrOnlySpecifiers, isServer) {
+	if (isServer) return [...runtimePlugins];
+	return runtimePlugins.filter((plugin) => !ssrOnlySpecifiers.has(getRuntimePluginSpecifier(plugin)));
+}
+//#endregion
 //#region src/utils/serializeRuntimeOptions.ts
 const UNSAFE_JS_CHAR_MAP = {
 	"<": "\\u003C",
@@ -1074,16 +1084,6 @@ function isParsableExpression(source) {
 	}
 }
 //#endregion
-//#region src/utils/runtimePluginSpecifier.ts
-function getRuntimePluginSpecifier(plugin) {
-	return typeof plugin === "string" ? plugin : plugin[0];
-}
-/** Drop SSR-only plugins from a client graph; a server graph keeps them all. */
-function filterRuntimePluginsForTarget(runtimePlugins, ssrOnlySpecifiers, isServer) {
-	if (isServer) return [...runtimePlugins];
-	return runtimePlugins.filter((plugin) => !ssrOnlySpecifiers.has(getRuntimePluginSpecifier(plugin)));
-}
-//#endregion
 //#region src/utils/importAnalysis.ts
 const analysisByBuild = /* @__PURE__ */ new WeakMap();
 /**
@@ -2281,8 +2281,37 @@ function hasCodeMatch(source, regex, codePositions) {
 	while ((match = regex.exec(source)) !== null) if (codePositions[match.index]) return true;
 	return false;
 }
+/**
+* True when the file contains a top-level static `import`/`export` declaration.
+* Local identifiers named `module` or `exports` (webpack/rspack helpers,
+* function parameters, etc.) must not override that module format.
+*/
+function hasEsmModuleSyntax(source, codePositions) {
+	const keywordRegex = /(?<![$\w])(?:import|export)\b/g;
+	let match;
+	let braceDepth = 0;
+	let braceScanIndex = 0;
+	while ((match = keywordRegex.exec(source)) !== null) {
+		for (; braceScanIndex < match.index; braceScanIndex++) {
+			if (!codePositions[braceScanIndex]) continue;
+			if (source[braceScanIndex] === "{") braceDepth++;
+			else if (source[braceScanIndex] === "}") braceDepth--;
+		}
+		if (!codePositions[match.index]) continue;
+		if (braceDepth !== 0) continue;
+		let previousCodeIndex = match.index - 1;
+		while (previousCodeIndex >= 0 && (/\s/.test(source[previousCodeIndex]) || !codePositions[previousCodeIndex])) previousCodeIndex--;
+		if (source[previousCodeIndex] === ".") continue;
+		let nextCodeIndex = match.index + match[0].length;
+		while (nextCodeIndex < source.length && (/\s/.test(source[nextCodeIndex]) || !codePositions[nextCodeIndex])) nextCodeIndex++;
+		if (source[nextCodeIndex] === "(") continue;
+		return true;
+	}
+	return false;
+}
 function hasCommonJsExports(source) {
 	const codePositions = createCodePositionMap(source);
+	if (hasEsmModuleSyntax(source, codePositions)) return false;
 	if (hasCodeMatch(source, /\bmodule\s*(?:\.exports|\[\s*['"]exports['"]\s*\])/g, codePositions)) return true;
 	const exportsRegex = /\bexports\s*(?:\.|\[|[,)]|=(?!=|>))/g;
 	let match;
@@ -2895,7 +2924,15 @@ function getWorkspacePackageJson(pkg) {
 		fromResolvedEntry: resolved
 	})?.packageJson;
 }
+const sharedDependencyGraphPackageJsonCache = /* @__PURE__ */ new Map();
 function getSharedDependencyGraphPackageJson(pkg) {
+	const cacheKey = `${getPackageDetectionCwd()}\0${pkg}`;
+	if (sharedDependencyGraphPackageJsonCache.has(cacheKey)) return sharedDependencyGraphPackageJsonCache.get(cacheKey);
+	const packageJson = resolveSharedDependencyGraphPackageJson(pkg);
+	sharedDependencyGraphPackageJsonCache.set(cacheKey, packageJson);
+	return packageJson;
+}
+function resolveSharedDependencyGraphPackageJson(pkg) {
 	const installedPackageJson = getInstalledPackageJson(pkg, { packageName: getPackageName(pkg) })?.packageJson;
 	if (installedPackageJson) return installedPackageJson;
 	try {
@@ -2904,7 +2941,16 @@ function getSharedDependencyGraphPackageJson(pkg) {
 	} catch {}
 	return getWorkspacePackageJson(pkg);
 }
+const sharedSingletonConsumedByPeerCache = /* @__PURE__ */ new WeakMap();
 function isSharedSingletonConsumedByPeer(pkg, options = getNormalizeModuleFederationOptions(), requireFederationRuntimeDependency = false) {
+	if (!options) return computeSharedSingletonConsumedByPeer(pkg, options, requireFederationRuntimeDependency);
+	let cache = sharedSingletonConsumedByPeerCache.get(options);
+	if (!cache) sharedSingletonConsumedByPeerCache.set(options, cache = /* @__PURE__ */ new Map());
+	const cacheKey = `${getPackageDetectionCwd()}\0${pkg}\0${requireFederationRuntimeDependency}`;
+	if (!cache.has(cacheKey)) cache.set(cacheKey, computeSharedSingletonConsumedByPeer(pkg, options, requireFederationRuntimeDependency));
+	return cache.get(cacheKey);
+}
+function computeSharedSingletonConsumedByPeer(pkg, options, requireFederationRuntimeDependency) {
 	const shared = options?.shared || {};
 	if (!requireFederationRuntimeDependency && Object.entries(shared).some(([key, item]) => key !== pkg && key.startsWith(`${pkg}/`) && item.shareConfig.singleton === true)) return true;
 	const sharedKeyByPackageName = /* @__PURE__ */ new Map();
@@ -3356,6 +3402,7 @@ function generateLazyWorkspaceSingletonExports(edges, namedExports, importSource
 	const trackPendingLoad = `__mfTrackPendingShareLoad(${deferredEntryFallback ? deferredEntryLoad : deferredInitLoad});`;
 	return `${declarations}
     const __mfApplyLazyShareExports = (mod) => {
+      exportModule = mod;
       ${assignments}
     };
     __mfSubscribeSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfApplyLazyShareExports);
@@ -3369,7 +3416,7 @@ function generateLazyWorkspaceSingletonExports(edges, namedExports, importSource
     } else {
       __mfApplyLazyShareExports(exportModule);
     }
-    export { __mf_default as default };${namedExportLine}${mutableExportLine}`;
+    export { __mf_default as default, exportModule as __moduleExports };${namedExportLine}${mutableExportLine}`;
 }
 const WORKSPACE_SINGLETON_SSR_LOCAL_SHARE = "__mfNormalizeShareModule(__mfLocalShare)";
 function prependWorkspaceSingletonSsrImport(code) {
@@ -3769,7 +3816,24 @@ function generateLocalSharedImportMap(options) {
         // A host seed from an older React family is not coherent with the newer cached react
         const cachedVersion = cached?.version ?? cached?.default?.version;
         if (cachedVersion !== undefined && isOlder(cachedVersion)) continue;
-        if (!requiredExport || typeof cached?.[requiredExport] === 'function' || typeof cached?.default?.[requiredExport] === 'function') return cached;
+        if (!requiredExport || typeof cached?.[requiredExport] === 'function' || typeof cached?.default?.[requiredExport] === 'function') {
+          const dom = typeof cached?.[requiredExport] === 'function' ? cached : cached?.default;
+          const internals = dom?.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+          if (!requiredExport || key.endsWith('/client') || !internals) return cached;
+          // React 18 root: mirror react-dom/client.js, or createRoot warns it was imported from "react-dom"
+          const client = {};
+          for (const name of ['createRoot', 'hydrateRoot']) {
+            client[name] = (...args) => {
+              internals.usingClientEntryPoint = true;
+              try {
+                return dom[name](...args);
+              } finally {
+                internals.usingClientEntryPoint = false;
+              }
+            };
+          }
+          return { ...client, default: client };
+        }
       }
       return undefined;
     };
@@ -3992,7 +4056,8 @@ function getMaterializedShares(options) {
 		const dependencies = {
 			...packageJson?.dependencies || {},
 			...packageJson?.peerDependencies || {},
-			...packageJson?.optionalDependencies || {}
+			...packageJson?.optionalDependencies || {},
+			...packageJson?.peerDependenciesMeta || {}
 		};
 		for (const dependency of Object.keys(dependencies)) {
 			const sharedDependency = configured.get(dependency);
@@ -4028,7 +4093,8 @@ function getSharePrerequisites(ordered) {
 		const dependencies = {
 			...packageJson?.dependencies || {},
 			...packageJson?.peerDependencies || {},
-			...packageJson?.optionalDependencies || {}
+			...packageJson?.optionalDependencies || {},
+			...packageJson?.peerDependenciesMeta || {}
 		};
 		const prerequisites = Object.keys(dependencies).map((dependency) => roots.get(dependency)).filter((dependency) => Boolean(dependency));
 		if (pkg !== packageName && (packageName === "react" || packageName === "react-dom")) {
@@ -4072,7 +4138,8 @@ function orderSharedDependenciesFirst(sharedPackages) {
 		const dependencies = {
 			...packageJson?.dependencies || {},
 			...packageJson?.peerDependencies || {},
-			...packageJson?.optionalDependencies || {}
+			...packageJson?.optionalDependencies || {},
+			...packageJson?.peerDependenciesMeta || {}
 		};
 		Object.keys(dependencies).forEach((dependency) => {
 			const sharedDependency = sharedKeyByPackageName.get(dependency);
@@ -4312,21 +4379,33 @@ const externalSharedProviderSelectionHelperCode = `const __mfSelectExternalShare
 /**
 * A consume-only stub never outranks a provider: when registering this container's
 * `import: false` share replaces an unloaded provider of the same version (#1311),
-* the `afterRegisterShare` hook restores the provider. Registered once per instance.
+* the `afterRegisterShare` hook restores the provider, and a provider kept out by an
+* unloaded stub takes its slot. Registered once per instance.
 */
 function generateKeepProvidersOverStubsCode(runtimeVar) {
 	return `if (!${runtimeVar}.__mfKeepAdoptedProviders) {
       ${runtimeVar}.__mfKeepAdoptedProviders = true;
       ${runtimeVar}.sharedHandler?.hooks?.lifecycle?.afterRegisterShare?.on?.((args) => {
         const { shared, previousShared, registeredShared } = args || {};
+        const versions = ${runtimeVar}.shareScopeMap?.[args.scope]?.[args.pkgName];
+        if (!shared || !versions) return;
+        // The reverse: a stub already in the slot (e.g. a loaded-first parent's) keeps a provider
+        // out, and a webpack consumer reading the scope then falls back to its own copy.
+        if (shared.shareConfig?.import !== false) {
+          if (
+            registeredShared !== shared &&
+            registeredShared?.shareConfig?.import === false &&
+            !registeredShared.loaded &&
+            versions[shared.version] === registeredShared
+          ) versions[shared.version] = shared;
+          return;
+        }
         if (
-          shared?.shareConfig?.import !== false ||
           registeredShared !== shared ||
           !previousShared ||
           previousShared.shareConfig?.import === false
         ) return;
-        const versions = ${runtimeVar}.shareScopeMap?.[args.scope]?.[args.pkgName];
-        if (versions && versions[shared.version] === shared) versions[shared.version] = previousShared;
+        if (versions[shared.version] === shared) versions[shared.version] = previousShared;
       });
     }`;
 }
@@ -4510,7 +4589,7 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy, options, command = "b
     var __mfDeferredSeedKeys = __mfSeedKeys.filter(
       (pkg) => __mfPreInitBlockedSeedKeys.has(__mfSeedIndex.get(pkg))
     );
-    await __mfSeedLocalShared(__mfImmediateSeedKeys);`;
+    await __mfSeedLocalShared(__mfImmediateSeedKeys).catch(__mfRejectInit);`;
 }
 function getBrowserImportPath(importPath) {
 	if (/^(?:[a-zA-Z]:[\\/]|\/)/.test(importPath) && !importPath.startsWith("/@")) return `/@fs/${importPath}`;
@@ -4761,7 +4840,12 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   ${runtimeHelperImports.length ? `import {${runtimeHelperImports.join(", ")}} from "@module-federation/runtime/helpers";` : ""}
   ${pluginImportNames.filter((item) => !isSsrOnlyPlugin(item[1])).map((item) => item[1]).join("\n")}
   import __mfExposesMap from "${virtualExposesId}"
-  ${command === "build" ? getRuntimeInitResolveBootstrapCode(false, getRuntimeInitStatusImportId(options)) : getRuntimeInitBootstrapCode(false, getRuntimeInitStatusImportId(options), void 0, void 0, exportConditions) + "\n  const { initResolve } = globalThis[globalKey];"}
+  ${command === "build" ? getRuntimeInitResolveBootstrapCode(false, getRuntimeInitStatusImportId(options)) + "\n  const { initReject } = __mfResolveState;" : getRuntimeInitBootstrapCode(false, getRuntimeInitStatusImportId(options), void 0, void 0, exportConditions) + "\n  const { initResolve, initReject } = globalThis[globalKey];"}
+  // A failed seed must settle initPromise, or every pending share load hangs forever.
+  const __mfRejectInit = (err) => {
+    initReject(err);
+    throw err;
+  };
   ${getRuntimeModuleCacheBootstrapCode(exportConditions)}
   const initTokens = {}
   const shareScopeNames = Array.isArray(${toSafeJsLiteral(options.shareScope)}) ? ${toSafeJsLiteral(options.shareScope)} : [${toSafeJsLiteral(options.shareScope)}]
@@ -5655,7 +5739,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
     __mfReadyDeferredSeedKeys.push(...__mfDeferredSeedKeys.filter(
       (pkg) => !__mfBlockedSeedKeys.has(__mfSeedIndex.get(pkg))
     ));
-    await __mfSeedLocalShared(__mfReadyDeferredSeedKeys);
+    await __mfSeedLocalShared(__mfReadyDeferredSeedKeys).catch(__mfRejectInit);
     ${command === "build" ? `// A consume-only share reached only through import() is bridged when that import runs
     // (see pluginLazyConsumeOnlyShares), through the same provider selection init() uses.
     const __mfLazyShareLoads = new Map();
@@ -8266,7 +8350,7 @@ function ${helperName}(names) {
 }
 //#endregion
 //#region package.json
-var version$1 = "1.23.4";
+var version$1 = "1.23.5";
 //#endregion
 //#region src/virtualModules/virtualExposesSSR.ts
 /**
@@ -8988,43 +9072,89 @@ function getStatsFileName(manifestFileName) {
 //#endregion
 //#region src/utils/sharedSource.ts
 const pendingEntryLookups = /* @__PURE__ */ new Map();
+const pendingLookupImporters = /* @__PURE__ */ new Map();
+const increment = (map, key) => map.set(key, (map.get(key) ?? 0) + 1);
+const decrement = (map, key) => {
+	const remaining = map.get(key) - 1;
+	if (remaining) map.set(key, remaining);
+	else map.delete(key);
+};
 const getEntryLookupKey = (source, importer) => `${source}\0${importer}`;
+/**
+* Rolldown saves each this.resolve() call's options under the map's current size and deletes the
+* entry when the call settles, so an overlapping call can receive the wrong `custom` metadata.
+* Taking the first free key keeps every in-flight entry intact. A no-op when the internals differ.
+*/
+function patchRolldownResolveOptionKeys(context) {
+	const data = context?.data;
+	const map = data?.resolveOptionsMap;
+	if (!data || !(map instanceof Map) || typeof data.saveResolveOptions !== "function") return;
+	if (data.__mfFreeKeyPatch) return;
+	data.saveResolveOptions = (options) => {
+		let index = map.size;
+		while (map.has(index)) index++;
+		map.set(index, options);
+		return index;
+	};
+	data.__mfFreeKeyPatch = true;
+}
 /** Whether a resolveId call is one of the shared source resolver's own entry lookups. */
 function isSharedEntryLookup(source, importer, options) {
-	return options.custom?.__mfSharedEntryLookup === true || pendingEntryLookups.has(getEntryLookupKey(source, importer));
+	if (pendingEntryLookups.has(getEntryLookupKey(source, importer))) return true;
+	return options?.custom?.__mfSharedEntryLookupImporter === importer && pendingLookupImporters.has(importer);
 }
 /**
 * Runs one of the plugin's own `this.resolve()` calls (a shared entry lookup, a
-* parse-barrier external probe), marked so `isSharedEntryLookup` recognizes it
+* parse-barrier external probe), tracked so `isSharedEntryLookup` recognizes it
 * and the share hooks neither proxy it nor register a used share for it.
 */
 async function resolveInternally(context, source, importer, options = {}) {
 	const lookupKey = getEntryLookupKey(source, importer);
-	pendingEntryLookups.set(lookupKey, (pendingEntryLookups.get(lookupKey) ?? 0) + 1);
+	increment(pendingEntryLookups, lookupKey);
+	increment(pendingLookupImporters, importer);
 	try {
 		return await context.resolve(source, importer, {
 			...options,
-			skipSelf: true,
 			custom: {
 				...options.custom,
-				__mfSharedEntryLookup: true
-			}
+				__mfSharedEntryLookupImporter: importer
+			},
+			skipSelf: true
 		});
 	} finally {
-		const remaining = pendingEntryLookups.get(lookupKey) - 1;
-		if (remaining) pendingEntryLookups.set(lookupKey, remaining);
-		else pendingEntryLookups.delete(lookupKey);
+		decrement(pendingEntryLookups, lookupKey);
+		decrement(pendingLookupImporters, importer);
 	}
 }
 /** Identify shared entries through Vite, with a cache scoped to this federation instance. */
 function createSharedSourceResolver(shared, getResolutionConfig) {
 	const caches = /* @__PURE__ */ new Map();
-	async function matchEntry(source, suffix, resolveEntry) {
+	const wildcardSubpathCaches = /* @__PURE__ */ new Map();
+	async function resolveEntry(context, request, options, { root, conditions }) {
+		if (!path$1.isAbsolute(request) && !isPackageExportAvailable(request, {
+			cwd: root,
+			conditions
+		})) return void 0;
+		const importer = path$1.join(root, "package.json");
+		try {
+			const resolved = await resolveInternally(context, request, importer, options);
+			return resolved && !resolved.external ? resolved.id : void 0;
+		} catch {
+			return;
+		}
+	}
+	async function matchEntry(source, suffix, entryOptions, resolveEntry) {
 		const packageName = getPackageNameFromNodeModulePath(source);
 		if (!packageName) return;
 		const candidates = /* @__PURE__ */ new Set();
 		if (findSharedKey(packageName, shared)) candidates.add(packageName);
-		if (findSharedKey(suffix, shared)) candidates.add(suffix);
+		const packageSubpath = suffix.slice(packageName.length + 1);
+		if (packageSubpath) {
+			for (const specifier of getPackageExportSpecifiersForFile(packageName, packageSubpath, {
+				...entryOptions,
+				fromResolvedEntry: source
+			})) if (findSharedKey(specifier, shared)) candidates.add(specifier);
+		}
 		for (const key of Object.keys(shared)) {
 			const request = getSharedRequest(key, shared[key]);
 			if (getPackageName(request) !== packageName) continue;
@@ -9044,6 +9174,7 @@ function createSharedSourceResolver(shared, getResolutionConfig) {
 	return {
 		clear() {
 			caches.clear();
+			wildcardSubpathCaches.clear();
 		},
 		async resolve(context, source, options = {}) {
 			if (source.startsWith("\0") || source.includes("#")) return;
@@ -9054,32 +9185,39 @@ function createSharedSourceResolver(shared, getResolutionConfig) {
 				"t",
 				"import"
 			].includes(key))) return;
-			if (findSharedKey(source, shared)) return source;
-			const suffix = getNodeModulesSuffix(source);
-			if (!suffix) return;
-			const normalizedSource = stripViteFsPrefix(normalizeNodeModulePath(source));
 			const environment = context.environment ?? !!options.ssr;
 			const cacheable = !options.isEntry && !options.scan && (!options.kind || options.kind === "import-statement") && Object.keys(options.attributes ?? {}).length === 0 && Object.keys(options.custom ?? {}).length === 0;
-			let cache = cacheable ? caches.get(environment) : void 0;
-			if (cacheable && !cache) {
-				cache = /* @__PURE__ */ new Map();
-				caches.set(environment, cache);
+			const getCache = (byEnvironment) => {
+				if (!cacheable) return;
+				let cache = byEnvironment.get(environment);
+				if (!cache) {
+					cache = /* @__PURE__ */ new Map();
+					byEnvironment.set(environment, cache);
+				}
+				return cache;
+			};
+			const directKey = findSharedKey(source, shared);
+			if (directKey) {
+				const request = getSharedRequest(directKey, shared[directKey]);
+				if (!(request.endsWith("/") && source !== removeTrailingSlash(request) && !getCommonSharedSubpaths(request).includes(source))) return source;
+				const cache = getCache(wildcardSubpathCaches);
+				let resolvable = cache?.get(source);
+				if (resolvable === void 0) {
+					resolvable = await resolveEntry(context, source, options, getResolutionConfig(context, options)) !== void 0;
+					cache?.set(source, resolvable);
+				}
+				return resolvable ? source : void 0;
 			}
+			const suffix = getNodeModulesSuffix(source);
+			if (!suffix) return;
+			const normalizedSource = stripViteFsPrefix(normalizeNodeModulePath(source));
+			const cache = getCache(caches);
 			if (cache?.has(normalizedSource)) return cache.get(normalizedSource);
-			const { root, conditions } = getResolutionConfig(context, options);
-			const result = await matchEntry(normalizedSource, suffix, async (request) => {
-				if (!path$1.isAbsolute(request) && !isPackageExportAvailable(request, {
-					cwd: root,
-					conditions
-				})) return void 0;
-				const importer = path$1.join(root, "package.json");
-				try {
-					const resolved = await resolveInternally(context, request, importer, options);
-					return resolved && !resolved.external ? resolved.id : void 0;
-				} catch {
-					return;
-				}
-			});
+			const config = getResolutionConfig(context, options);
+			const result = await matchEntry(normalizedSource, suffix, {
+				cwd: config.root,
+				conditions: config.conditions
+			}, (request) => resolveEntry(context, request, options, config));
 			cache?.set(normalizedSource, result);
 			return result;
 		}
@@ -9195,8 +9333,7 @@ function pluginModuleParseEnd_default(excludeFn, options, controller = createMod
 		},
 		async buildStart() {
 			resetParseState(controller);
-			if (idleTimeout) resetIdleTimeout(controller, idleTimeout);
-			else if (options.moduleParseTimeout) setParseTimeout(controller, options.moduleParseTimeout);
+			if (!idleTimeout && options.moduleParseTimeout) setParseTimeout(controller, options.moduleParseTimeout);
 			const entryImports = /* @__PURE__ */ new Set([...options.exposedModuleImports || [], ...configuredInputImports]);
 			for (const importSource of entryImports) {
 				const resolved = await this.resolve(importSource);
@@ -10079,6 +10216,7 @@ function proxySharedModule(options) {
 			},
 			buildStart() {
 				sharedSourceResolver.clear();
+				patchRolldownResolveOptionKeys(this);
 				if (_command !== "build") return;
 				if (hasAnalyzableShares) getBuildImportAnalysis(this.environment).clear();
 				resetTreeShakingExports(federationOptions);
@@ -10479,8 +10617,15 @@ function pluginRemoteNamedExports(options) {
 			if (id.includes("__loadRemote__") || id.includes("__loadShare__")) return;
 			if (!JS_EXTENSIONS_RE.test(id)) return;
 			if (!remoteNames.some((name) => code.includes(name))) return;
-			const matchesRemoteImport = (source) => isRemoteImport(source, id);
-			for (const { kind, source, typeOnly } of findModuleImportDescriptors(code)) if (kind === "static" && !typeOnly && matchesRemoteImport(source)) markStaticRemote(source, options);
+			const descriptors = findModuleImportDescriptors(code);
+			const resolvedElsewhere = /* @__PURE__ */ new Set();
+			for (const source of new Set(descriptors.map((d) => d.source))) {
+				if (source.includes("__loadRemote__") || !isRemoteImport(source, id)) continue;
+				const resolved = await this.resolve(source, id);
+				if (resolved && !resolved.id.includes("__loadRemote__")) resolvedElsewhere.add(source);
+			}
+			const matchesRemoteImport = (source) => !resolvedElsewhere.has(source) && isRemoteImport(source, id);
+			for (const { kind, source, typeOnly } of descriptors) if (kind === "static" && !typeOnly && matchesRemoteImport(source)) markStaticRemote(source, options);
 			let imports;
 			try {
 				imports = await collectFromAST(this.parse(code), code, matchesRemoteImport);
@@ -12132,7 +12277,7 @@ function withoutDynamicRemoteTypeHints(options) {
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-CVyHPAEq.js").then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-DShMdjzR.js").then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {

package/lib/{pluginDts-CVyHPAEq.js → pluginDts-DShMdjzR.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-DSTzyKSG.js";
+import { _ as resolveImportPath, d as hasPackageDependency } from "./dtsConstants-BQdFpgKb.js";
 import fs from "fs";
 import * as path$1 from "node:path";
 import { normalizeOptions } from "@module-federation/sdk";

package/lib/{sharedKeyMatcher-Od_nYxJA.js → sharedKeyMatcher-CHp4QRNq.js}

@@ -218,4 +218,4 @@ function getSharedKeyMatcher(shared) {
 	return matcher;
 }
 //#endregion
-export { resolvePublicPath as _, matchesSharedSource as a, filterId as c, getNodeModulesSuffix as d, isAssetLikeImport as f, normalizeNodeModulePath as g, isViteOptimizableEntry as h, invalidateSharedKeyMatcher as i, getBasePath as l, isNuxtClientBase as m, getSharedRequest as n, VITE_FS_PREFIX as o, isNodeModulePath as p, getSharedRuntimeKey as r, ensureTrailingSlash as s, findSharedKey as t, getCommonSharedSubpaths as u, stripQueryAndHash as v, stripViteFsPrefix as y };
+export { removeTrailingSlash as _, matchesSharedSource as a, stripViteFsPrefix as b, filterId as c, getNodeModulesSuffix as d, isAssetLikeImport as f, normalizeNodeModulePath as g, isViteOptimizableEntry as h, invalidateSharedKeyMatcher as i, getBasePath as l, isNuxtClientBase as m, getSharedRequest as n, VITE_FS_PREFIX as o, isNodeModulePath as p, getSharedRuntimeKey as r, ensureTrailingSlash as s, findSharedKey as t, getCommonSharedSubpaths as u, resolvePublicPath as v, stripQueryAndHash as y };

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

@@ -146,7 +146,23 @@ async function nodeImport(id) {
 const isNodeServer = () => {
 	return import.meta.env?.SSR ?? typeof globalThis.process?.versions?.node === "string";
 };
-const runnerCache = /* @__PURE__ */ new Map();
+const SSR_ENTRY_LOADER_STATE_KEY = Symbol.for("module-federation.vite.ssrEntryLoader.state");
+function getLoaderState() {
+	const holder = globalThis;
+	const state = holder[SSR_ENTRY_LOADER_STATE_KEY] ??= {};
+	state.runnerCache ??= /* @__PURE__ */ new Map();
+	state.unversionedGenerations ??= /* @__PURE__ */ new Map();
+	state.unversionedGlobalGeneration ??= 0;
+	state.ssrEntryCache ??= /* @__PURE__ */ new Map();
+	state.manifestFetchCache ??= /* @__PURE__ */ new Map();
+	state.tempFileCache ??= /* @__PURE__ */ new Map();
+	state.tempFilePathCache ??= /* @__PURE__ */ new Map();
+	state.tempFileRecords ??= /* @__PURE__ */ new Map();
+	state.scheduledTempFileCleanup ??= /* @__PURE__ */ new Set();
+	return state;
+}
+const loaderState = getLoaderState();
+const runnerCache = loaderState.runnerCache;
 function getSortedRecordEntries(record) {
 	return Object.entries(record).sort(([left], [right]) => left.localeCompare(right));
 }
@@ -271,10 +287,9 @@ function parseRunnerInvokeResult(data) {
 * advance a process-local generation so the next import is fresh.
 */
 const UNVERSIONED = "unversioned";
-const unversionedGenerations = /* @__PURE__ */ new Map();
-let unversionedGlobalGeneration = 0;
+const unversionedGenerations = loaderState.unversionedGenerations;
 function getUnversionedVersionKey(remoteEntryUrl) {
-	return `${UNVERSIONED}-${unversionedGlobalGeneration}-${unversionedGenerations.get(remoteEntryUrl) ?? 0}`;
+	return `${UNVERSIONED}-${loaderState.unversionedGlobalGeneration}-${unversionedGenerations.get(remoteEntryUrl) ?? 0}`;
 }
 function bumpUnversionedGeneration(remoteEntryUrl) {
 	unversionedGenerations.set(remoteEntryUrl, (unversionedGenerations.get(remoteEntryUrl) ?? 0) + 1);
@@ -292,8 +307,8 @@ function computeManifestVersionKey(manifest) {
 	const contentHash = hashString(JSON.stringify(manifest));
 	return buildVersion ? `${buildVersion}-${contentHash}` : contentHash;
 }
-const ssrEntryCache = /* @__PURE__ */ new Map();
-const manifestFetchCache = /* @__PURE__ */ new Map();
+const ssrEntryCache = loaderState.ssrEntryCache;
+const manifestFetchCache = loaderState.manifestFetchCache;
 function makeUrlCacheKey(url, fetchTimeoutMs, fetchMaxBytes) {
 	return `${fetchTimeoutMs}::${fetchMaxBytes}::${url}`;
 }
@@ -514,8 +529,8 @@ function invalidateRemoteCaches(remoteEntryUrl) {
 * static import cycle between the two SSR strategies.
 */
 function scheduleVmCacheCleanup(remoteEntryUrl) {
-	if (!vmStrategyModulePromise) return;
-	vmStrategyModulePromise.then(({ clearVmStrategyCaches }) => clearVmStrategyCaches(remoteEntryUrl)).catch(() => {});
+	if (!loaderState.vmStrategyModulePromise) return;
+	loaderState.vmStrategyModulePromise.then(({ clearVmStrategyCaches }) => clearVmStrategyCaches(remoteEntryUrl)).catch(() => {});
 }
 /**
 * A dev-mode ModuleRunner is created per origin (one Vite dev server) and is
@@ -575,7 +590,7 @@ function revalidate(remoteEntryUrl) {
 		for (const key of manifestFetchCache.keys()) if (key.endsWith(`::${manifestUrl}`)) manifestFetchCache.delete(key);
 		invalidateRemoteCaches(remoteEntryUrl);
 	} else {
-		unversionedGlobalGeneration += 1;
+		loaderState.unversionedGlobalGeneration += 1;
 		ssrEntryCache.clear();
 		manifestFetchCache.clear();
 		invalidateAllRemoteCaches();
@@ -585,11 +600,11 @@ function revalidate(remoteEntryUrl) {
 		instance?.moduleCache?.clear?.();
 	} catch {}
 }
-const tempFileCache = /* @__PURE__ */ new Map();
-const tempFilePathCache = /* @__PURE__ */ new Map();
+const tempFileCache = loaderState.tempFileCache;
+const tempFilePathCache = loaderState.tempFilePathCache;
 const TEMP_FILE_CLEANUP_DELAY_MS = 3e4;
-const tempFileRecords = /* @__PURE__ */ new Map();
-const scheduledTempFileCleanup = /* @__PURE__ */ new Set();
+const tempFileRecords = loaderState.tempFileRecords;
+const scheduledTempFileCleanup = loaderState.scheduledTempFileCleanup;
 function scheduleTempFileCleanup(records) {
 	for (const record of records) {
 		if (scheduledTempFileCleanup.has(record.cacheKey)) continue;
@@ -832,10 +847,9 @@ async function importTempModule(filePath, versionKey) {
 );
 }
 let warnedVmUnavailable = false;
-let vmStrategyModulePromise;
 function getVmStrategyModule() {
-	if (!vmStrategyModulePromise) vmStrategyModulePromise = import("./ssrVmStrategy-Dk5xXVvR.js");
-	return vmStrategyModulePromise;
+	if (!loaderState.vmStrategyModulePromise) loaderState.vmStrategyModulePromise = import("./ssrVmStrategy-BkyvcG4s.js");
+	return loaderState.vmStrategyModulePromise;
 }
 /**
 * Non-HTTP failures keep falling back (to temp-file after vm, to the federation
@@ -954,4 +968,4 @@ function ssrEntryLoaderPlugin(options = {}) {
 	};
 }
 //#endregion
-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 };
+export { ssrEntryLoaderPlugin as a, fetchWithTimeout as c, revalidate as i, readResponseTextBounded as l, SsrEntryHttpError as n, DEFAULT_SSR_FETCH_MAX_BYTES as o, neutralizeBrowserPreloadHelpers as r, DEFAULT_SSR_FETCH_TIMEOUT_MS as s, SSR_ENTRY_LOADER_STATE_KEY as t };

package/lib/{ssrVmStrategy-Dk5xXVvR.js → ssrVmStrategy-BkyvcG4s.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-DjZj-5Lw.js";
+import { t as findSharedKey } from "./sharedKeyMatcher-CHp4QRNq.js";
+import { c as fetchWithTimeout, l as readResponseTextBounded, n as SsrEntryHttpError, r as neutralizeBrowserPreloadHelpers } from "./ssrEntryLoader-CHdWk8Yg.js";
 //#region src/utils/ssrVmStrategy.ts
 /**
 * vm.SourceTextModule strategy for loading remote SSR entries.

package/lib/utils/ssrEntryLoader.d.ts

@@ -1,5 +1,6 @@
 import { i as SsrEntryLoaderConfig } from "../normalizeModuleFederationOptions-DNUlv-AL.js";
 //#region src/utils/ssrEntryLoader.d.ts
+declare const SSR_ENTRY_LOADER_STATE_KEY: unique symbol;
 interface RemoteInfo {
   name: string;
   entry: string;
@@ -64,4 +65,4 @@ declare function ssrEntryLoaderPlugin(options?: SsrEntryLoaderOptions): {
   } | undefined>;
 };
 //#endregion
-export { SsrEntryHttpError, ssrEntryLoaderPlugin as default, neutralizeBrowserPreloadHelpers, revalidate };
+export { SSR_ENTRY_LOADER_STATE_KEY, SsrEntryHttpError, ssrEntryLoaderPlugin as default, neutralizeBrowserPreloadHelpers, revalidate };

package/lib/utils/ssrEntryLoader.js

@@ -1,2 +1,2 @@
-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 };
+import { a as ssrEntryLoaderPlugin, i as revalidate, n as SsrEntryHttpError, r as neutralizeBrowserPreloadHelpers, t as SSR_ENTRY_LOADER_STATE_KEY } from "../ssrEntryLoader-CHdWk8Yg.js";
+export { SSR_ENTRY_LOADER_STATE_KEY, SsrEntryHttpError, ssrEntryLoaderPlugin as default, neutralizeBrowserPreloadHelpers, revalidate };

package/package.json

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