npm - @module-federation/vite - Versions diffs - 1.21.3 → 1.21.4 - Mend

@module-federation/vite 1.21.3 → 1.21.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/lib/{dtsConstants-CScOzmdO.js → dtsConstants-BsaLBaaK.js} +21 -17
package/lib/index.js +580 -131
package/lib/{pluginDts-C2bUY8h9.js → pluginDts-BhONN9dR.js} +1 -1
package/lib/sharedKeyMatcher-DiUzRVH1.js +198 -0
package/lib/{ssrEntryLoader-BMtjS_Vl.js → ssrEntryLoader-CqtaiDUp.js} +35 -10
package/lib/{ssrVmStrategy-tpI6we9Q.js → ssrVmStrategy-D4KB-y3H.js} +3 -16
package/lib/utils/ssrEntryLoader.js +1 -1
package/package.json +1 -1
package/lib/pathNormalization-CHct3UwV.js +0 -115

package/lib/index.js CHANGED Viewed

@@ -1,10 +1,10 @@
 import { n as normalizePathForImport, r as rebaseImport } from "./buildPaths-BkaQHrd2.js";
-import { a as getPackageDetectionCwd, c as getSharedCacheDescriptor, d as packageNameDecode, f as packageNameEncode, g as createModuleFederationError, h as sharedCacheHelperCode, i as getIsRolldown, l as hasPackageDependency, m as setPackageDetectionCwd, n as getInstalledPackageEntry, o as getPackageName, p as resolveImportPath, r as getInstalledPackageJson, s as getPackageNameFromNodeModulePath, u as isNuxtProjectRoot, v as mfWarn } from "./dtsConstants-CScOzmdO.js";
-import { a as getCommonSharedSubpaths, c as isNodeModulePath, d as normalizeNodeModulePath, f as resolvePublicPath, i as getCommonSharedSubpathFromNodeModulePath, l as isNuxtClientBase, n as filterId, o as getMatchingNodeModuleSubpath, r as getBasePath$1, s as isAssetLikeImport, t as ensureTrailingSlash, u as isViteOptimizableEntry } from "./pathNormalization-CHct3UwV.js";
+import { a as getPackageDetectionCwd, c as getSharedCacheDescriptor, d as packageNameDecode, f as packageNameEncode, g as createModuleFederationError, h as sharedCacheHelperCode, i as getIsRolldown, l as hasPackageDependency, m as setPackageDetectionCwd, n as getInstalledPackageEntry, o as getPackageName, p as resolveImportPath, r as getInstalledPackageJson, s as getPackageNameFromNodeModulePath, u as isNuxtProjectRoot, v as mfWarn } from "./dtsConstants-BsaLBaaK.js";
+import { a as filterId, c as getCommonSharedSubpaths, d as isNodeModulePath, f as isNuxtClientBase, h as resolvePublicPath, i as ensureTrailingSlash, l as getMatchingNodeModuleSubpath, m as normalizeNodeModulePath, n as invalidateSharedKeyMatcher, o as getBasePath$1, p as isViteOptimizableEntry, r as matchesSharedSource, s as getCommonSharedSubpathFromNodeModulePath, t as findSharedKey, u as isAssetLikeImport } from "./sharedKeyMatcher-DiUzRVH1.js";
 import { createRequire } from "node:module";
 import * as fs$2 from "fs";
-import { existsSync, readFileSync, realpathSync, statSync, writeFileSync } from "fs";
-import { createRequire as createRequire$1 } from "module";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "fs";
+import { createRequire as createRequire$1, isBuiltin } from "module";
 import * as path$1 from "node:path";
 import path, { basename } from "node:path";
 import { fileURLToPath, pathToFileURL } from "url";
@@ -13,6 +13,7 @@ import { createHash } from "node:crypto";
 import * as fs$1 from "node:fs";
 import { existsSync as existsSync$1, readFileSync as readFileSync$1 } from "node:fs";
 import { pathToFileURL as pathToFileURL$1 } from "node:url";
+import { isIPv6 } from "node:net";
 //#region src/utils/bundleHelpers.ts
 function isOutputChunk$1(chunk) {
 	return chunk.type === "chunk";
@@ -639,7 +640,8 @@ function rewriteEntryScripts(html, createProxySrc) {
 }
 function injectEntryScript(html, initSrc) {
 	const src = sanitizeDevEntryPath(initSrc);
-	return html.replace("<head>", `<head><script type="module" src=${JSON.stringify(src)}><\/script>`);
+	const script = `<script type="module" src=${JSON.stringify(src)}><\/script>`;
+	return html.replace(/<head\b[^>]*>/i, (openTag) => `${openTag}${script}`);
 }
 //#endregion
 //#region src/utils/normalizeModuleFederationOptions.ts
@@ -928,7 +930,7 @@ function normalizeModuleFederationOptions(options) {
 		injectTreeShakingUsedExports: options.injectTreeShakingUsedExports,
 		treeShakingSharedPlugins: options.treeShakingSharedPlugins,
 		treeShakingSharedExcludePlugins: options.treeShakingSharedExcludePlugins,
-		moduleParseTimeout: options.moduleParseTimeout || 10,
+		moduleParseTimeout: options.moduleParseTimeout ?? 10,
 		moduleParseIdleTimeout: options.moduleParseIdleTimeout,
 		varFilename: options.varFilename,
 		target: options.target,
@@ -1090,7 +1092,7 @@ function serializeRuntimeOptions(options) {
 		if (type === "number" || type === "boolean") return String(val);
 		if (type === "undefined") return "undefined";
 		if (type === "symbol") return `Symbol(${toSafeJsLiteral(val.description ?? "")})`;
-		if (type === "function") return val.toString();
+		if (type === "function") return functionToExpression(val);
 		if (val instanceof Date) return `new Date(${toSafeJsLiteral(val.toISOString())})`;
 		if (val instanceof RegExp) return `new RegExp(${toSafeJsLiteral(val.source)}, ${toSafeJsLiteral(val.flags)})`;
 		if (type === "object") {
@@ -1113,9 +1115,49 @@ function serializeRuntimeOptions(options) {
 	for (const key in options) if (Object.prototype.hasOwnProperty.call(options, key)) topLevelProps.push(`${toSafeJsLiteral(key)}: ${valueToCode(options[key])}`);
 	return `{${topLevelProps.join(", ")}}`;
 }
+const NATIVE_FUNCTION_SOURCE = /\{\s*\[native code\]\s*\}\s*$/;
+/**
+* Turns `Function#toString()` output into a JS expression that is valid as an
+* object-literal value.
+*
+* Method shorthand (`onError() { … }`) is not a valid expression after a `:`,
+* so it is rewritten as a function expression. Native functions have no
+* reconstructable source (`function parse() { [native code] }`) and serialize
+* as `undefined` so the generated object stays loadable.
+*/
+function functionToExpression(fn) {
+	let source;
+	try {
+		source = Function.prototype.toString.call(fn).trim();
+	} catch {
+		return "undefined";
+	}
+	if (NATIVE_FUNCTION_SOURCE.test(source) || /^(async\s+)?(?:get|set)\s+/.test(source)) return "undefined";
+	if (/^(async\s+)?function\b/.test(source) || /^(async\s*)?\(/.test(source) || /^class\b/.test(source) || /^(async\s+)?[$_\p{ID_Start}][$\p{ID_Continue}]*\s*=>/u.test(source)) return isParsableExpression(source) ? source : "undefined";
+	for (const [pattern, prefix] of [
+		[/^async\s*\*\s*[$_\p{ID_Start}][$\p{ID_Continue}]*\s*(\([\s\S]*)$/u, "async function* "],
+		[/^\*\s*[$_\p{ID_Start}][$\p{ID_Continue}]*\s*(\([\s\S]*)$/u, "function* "],
+		[/^async\s+[$_\p{ID_Start}][$\p{ID_Continue}]*\s*(\([\s\S]*)$/u, "async function "],
+		[/^[$_\p{ID_Start}][$\p{ID_Continue}]*\s*(\([\s\S]*)$/u, "function "]
+	]) {
+		const match = source.match(pattern);
+		if (!match) continue;
+		const expression = `${prefix}${match[1]}`;
+		return isParsableExpression(expression) ? expression : "undefined";
+	}
+	return "undefined";
+}
+function isParsableExpression(source) {
+	try {
+		new Function(`return (${source});`);
+		return true;
+	} catch {
+		return false;
+	}
+}
 //#endregion
 //#region src/utils/reactIsland.ts
-const SOURCE_EXTENSIONS = [
+const SOURCE_EXTENSIONS$1 = [
 	".tsx",
 	".jsx",
 	".ts",
@@ -1134,8 +1176,8 @@ function resolveSourceFile(importPath, root) {
 	const candidate = path$1.isAbsolute(cleanImport) ? cleanImport : path$1.resolve(root, cleanImport);
 	return [
 		candidate,
-		...SOURCE_EXTENSIONS.map((extension) => `${candidate}${extension}`),
-		...SOURCE_EXTENSIONS.map((extension) => path$1.join(candidate, `index${extension}`))
+		...SOURCE_EXTENSIONS$1.map((extension) => `${candidate}${extension}`),
+		...SOURCE_EXTENSIONS$1.map((extension) => path$1.join(candidate, `index${extension}`))
 	].find((filePath) => {
 		try {
 			return fs$1.statSync(filePath).isFile();
@@ -1574,6 +1616,13 @@ function getRuntimeRemoteAlias(alias, options) {
 	if (!options) return alias;
 	return `${getFederationScopeKey(options)}__${alias}`;
 }
+function getSsrRuntimeRemotes(remotes, options) {
+	return Object.entries(remotes).map(([name, item]) => ({
+		name: getRuntimeRemoteAlias(name, options),
+		entry: item.entry,
+		type: item.type ?? "module"
+	}));
+}
 function getRuntimeInitGlobalKey(ownerImportId) {
 	return `__mf_init__${ownerImportId ?? virtualRuntimeInitStatus.getImportId()}__`;
 }
@@ -2044,6 +2093,7 @@ function hasLikelyTypeArgumentFollower(source, end, codePositions, followsNamedE
 	let next = end + 1;
 	while (next < source.length && (!codePositions[next] || /\s/.test(source[next]))) next++;
 	if (next >= source.length || /[([.!?=;,)\]}:|&]/.test(source[next])) return true;
+	if (source.slice(end + 1, next).includes("\n")) return true;
 	const followingToken = source.slice(next).match(/^[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}]*/u)?.[0];
 	return followingToken === "as" || followingToken === "satisfies" || !followsNamedExpression && followingToken !== void 0;
 }
@@ -2412,6 +2462,11 @@ function getAdditionalTopLevelDeclaratorNames(source, start, codePositions) {
 			const tokenStart = index;
 			while (/[$_\u200C\u200D\p{ID_Continue}]/u.test(source[index + 1] || "")) index++;
 			const token = source.slice(tokenStart, index + 1);
+			if (depth === 0 && templateFrames.length === 0 && token === "export") {
+				let previous = tokenStart - 1;
+				while (/\s/.test(source[previous] || "")) previous--;
+				if (source[previous] !== "." && /^\s+(?:(?:async\s+)?function\b|(?:abstract\s+)?class\b|const\b|let\b|var\b|enum\b|namespace\b|module\b|interface\b|type\b|declare\b|default\b|\{|\*)/.test(source.slice(index + 1))) return names;
+			}
 			canStartRegex = /^(?:await|case|delete|in|instanceof|new|return|throw|typeof|void|yield)$/.test(token);
 			continue;
 		}
@@ -2597,8 +2652,14 @@ function getNamedExportsViaRegex(source, filePath, visited, scanState = { comple
 		while (previousCodeIndex >= 0 && (/\s/.test(source[previousCodeIndex]) || !codePositions[previousCodeIndex])) previousCodeIndex--;
 		if (source[previousCodeIndex] === ".") continue;
 		let nextCodeIndex = match.index + match[0].length;
-		while (/\s/.test(source[nextCodeIndex] || "")) nextCodeIndex++;
+		while (nextCodeIndex < source.length && (/\s/.test(source[nextCodeIndex]) || !codePositions[nextCodeIndex])) nextCodeIndex++;
 		if (source[nextCodeIndex] === "(") continue;
+		let memberIndex = nextCodeIndex;
+		if (source[memberIndex] === "?") {
+			memberIndex++;
+			while (memberIndex < source.length && (/\s/.test(source[memberIndex]) || !codePositions[memberIndex])) memberIndex++;
+		}
+		if (source[memberIndex] === ":") continue;
 		scanState.complete = false;
 		break;
 	}
@@ -2760,23 +2821,25 @@ function getDependencyNames(packageJson) {
 	}
 	return Array.from(names);
 }
-function isSharedSingletonConsumedByPeer(pkg, options = getNormalizeModuleFederationOptions()) {
+function isSharedSingletonConsumedByPeer(pkg, options = getNormalizeModuleFederationOptions(), requireFederationRuntimeDependency = false) {
 	const shared = options?.shared || {};
-	if (Object.entries(shared).some(([key, item]) => key !== pkg && key.startsWith(`${pkg}/`) && item.shareConfig.singleton === true)) return true;
+	if (!requireFederationRuntimeDependency && Object.entries(shared).some(([key, item]) => key !== pkg && key.startsWith(`${pkg}/`) && item.shareConfig.singleton === true)) return true;
 	const sharedKeyByPackageName = /* @__PURE__ */ new Map();
 	Object.entries(shared).filter(([, item]) => item.shareConfig.singleton === true).forEach(([key]) => {
 		const packageName = getPackageName(key);
 		if (!sharedKeyByPackageName.get(packageName) || key === packageName) sharedKeyByPackageName.set(packageName, key);
 	});
-	const reachesPkg = (current, seen) => {
-		const packageJson = getSharedDependencyGraphPackageJson(current);
-		for (const dependency of getDependencyNames(packageJson)) {
+	const reachesPkg = (current, seen, hasFederationRuntimeDependency = false) => {
+		const dependencies = getDependencyNames(getSharedDependencyGraphPackageJson(current));
+		const usesFederationRuntime = dependencies.some((dependency) => dependency === "@module-federation/enhanced" || dependency === "@module-federation/runtime" || dependency === "@module-federation/runtime-core");
+		const runtimeIsReachable = hasFederationRuntimeDependency || usesFederationRuntime;
+		for (const dependency of dependencies) {
 			const sharedDependency = sharedKeyByPackageName.get(dependency);
 			if (!sharedDependency) continue;
-			if (sharedDependency === pkg) return true;
+			if (sharedDependency === pkg) return !requireFederationRuntimeDependency || runtimeIsReachable;
 			if (seen.has(sharedDependency)) continue;
 			seen.add(sharedDependency);
-			if (reachesPkg(sharedDependency, seen)) return true;
+			if (reachesPkg(sharedDependency, seen, runtimeIsReachable)) return true;
 		}
 		return false;
 	};
@@ -3107,6 +3170,12 @@ function findCurrentLoadShareForStaleOwnerId(id, shared, findSharedKey, options)
 function getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer) {
 	return treeShakingConsumer ? `__mfReadTreeShakingSharedSelection(__mfModuleCache.share, ${cacheDescriptor}, ${JSON.stringify(treeShakingConsumer)})` : `__mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor})`;
 }
+/**
+* Eager workspace singleton wrapper: reads the shared cache synchronously and falls back to the local
+* namespace. Inside the fallback's own evaluation cycle that namespace is not initialized yet (undefined in
+* a merged chunk, TDZ bindings otherwise), so the exports stay unassigned until the deferred cache write
+* re-applies them; a host-provided copy re-applies them through the cache subscription as before.
+*/
 function generateEagerWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer, mutableExports = []) {
 	const copiedExports = namedExports.filter((name) => !mutableExports.includes(name));
 	const namedExportVars = copiedExports.map((_name, i) => `__mf_${i}`);
@@ -3118,8 +3187,10 @@ function generateEagerWorkspaceSingletonExports(namedExports, importSource, cach
     let exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
     if (exportModule === undefined) {
       Promise.resolve().then(() => {
-        if (__mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor}) === undefined) {
-          __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfNormalizeShareModule(__mfLocalShare), ${cacheOwner});
+        if (__mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor}) !== undefined) return;
+        const localShare = __mfInitializedLocalShare(__mfLocalShare);
+        if (localShare !== undefined) {
+          __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, localShare, ${cacheOwner});
         }
       });
       exportModule = __mfLocalShare;
@@ -3128,8 +3199,16 @@ function generateEagerWorkspaceSingletonExports(namedExports, importSource, cach
     const __mfApplyEagerShareExports = (mod) => {
       ${assignments}
     };
+    const __mfApplyEagerShareExportsWhenReady = (mod) => {
+      if (mod === undefined) return;
+      try {
+        __mfApplyEagerShareExports(mod);
+      } catch (error) {
+        if (!(error instanceof ReferenceError)) throw error;
+      }
+    };
     __mfSubscribeSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfApplyEagerShareExports);
-    __mfApplyEagerShareExports(exportModule);
+    __mfApplyEagerShareExportsWhenReady(exportModule);
     export { __mf_default as default };${namedExportLine}${mutableExportLine}`;
 }
 function generateLazyWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer, serveLocalFallback = false, mutableExports = []) {
@@ -3237,6 +3316,15 @@ const normalizeLocalShareModuleCode = `const __mfNormalizeShareModule = (mod) =>
         ? Object.assign({}, normalized)
         : normalized;
     };`;
+const initializedLocalShareModuleCode = `const __mfInitializedLocalShare = (mod) => {
+      if (mod === undefined) return undefined;
+      try {
+        return __mfNormalizeShareModule(mod);
+      } catch (error) {
+        if (error instanceof ReferenceError) return undefined;
+        throw error;
+      }
+    };`;
 function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exportConditions, importFalseExportUsage) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const { loadShareCacheMap } = getSharedVirtualModuleState(options);
@@ -3284,7 +3372,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	const hasCompleteExportCoverage = detectedNamedExports !== void 0;
 	const isWorkspaceSingleton = isWorkspacePackage && shareItem.shareConfig.singleton === true;
 	const isDefaultShareScope = shareItem.scope === void 0 || shareItem.scope === "default" || Array.isArray(shareItem.scope) && shareItem.scope[0] === "default";
-	const usesDeferredSingletonFallback = hasCompleteExportCoverage && shareItem.shareConfig.eager !== true && (isWorkspacePackage || command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true || command === "build" && isRemoteOnlyContainer(resolvedOptions) && (shareItem.shareConfig.singleton === true || isDefaultShareScope));
+	const usesDeferredSingletonFallback = hasCompleteExportCoverage && shareItem.shareConfig.eager !== true && (isWorkspacePackage || command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true || command === "build" && isRemoteOnlyContainer(resolvedOptions) && (shareItem.shareConfig.singleton === true || isDefaultShareScope) && !isSharedSingletonConsumedByPeer(pkg, resolvedOptions, true));
 	const servesRemoteSingletonFallback = command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true;
 	const isConsumedByPeerSingleton = isSharedSingletonConsumedByPeer(pkg, resolvedOptions);
 	const usesEntryInjectedRemoteFallback = hasCompleteExportCoverage && !isWorkspaceSingleton && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true && resolvedOptions.hostInitInjectLocation === "entry" && (command === "build" || isConsumedByPeerSingleton);
@@ -3370,12 +3458,13 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	}
 	const prebuildImportLine = usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback ? "" : usesDeferredSingletonFallback || usesDeferredTreeShakingFallback ? !servesRemoteSingletonFallback && usesDeferredSingletonFallback && command !== "build" && (isWorkspaceSingleton || isWorkspacePackage) ? `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(lazyLocalFallbackSource)};` : "" : `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(detectedNamedExports === void 0 ? coherentLocalSource : skipServePrebuildWarmup ? devImportSource : sharedImportSource)};`;
 	const devDynamicImportLine = isWorkspacePackage ? "" : usesDeferredSingletonFallback || usesDeferredTreeShakingFallback ? "" : command !== "build" && !skipServePrebuildWarmup ? `;() => import(${escapeGeneratedStringLiteral(devImportSource)}).catch(() => {});` : "";
-	const moduleBody = usesDeferredSingletonFallback || usesDeferredTreeShakingFallback ? `
+	const moduleBody = usesDeferredSingletonFallback || usesDeferredTreeShakingFallback || usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback ? `
     ${prebuildImportLine}
     ${devDynamicImportLine}
     ${importLine}
     ${sharedCacheHelperCode}
     ${normalizeLocalShareModuleCode}
+    ${initializedLocalShareModuleCode}
     ${exportLine}
   ` : `
     ${prebuildImportLine}
@@ -3477,6 +3566,7 @@ function generateLocalSharedImportMap(options) {
 		if (!shareItem?.shareConfig.eager || shareItem.shareConfig.import === false) return "";
 		return `import * as __mfEagerShare_${index} from ${toSafeJsLiteral(getLocalSharedPackagePath(pkg, shareItem, options))};`;
 	}).filter(Boolean).join("\n")}
+    ${normalizeRuntimeShareCode}
     const importMap = {
       ${orderedShares.map((pkg, index) => {
 		const shareItem = getNormalizeShareItem(pkg, resolvedOptions);
@@ -3521,7 +3611,7 @@ function generateLocalSharedImportMap(options) {
               const res = await pkgDynamicImport()
               const exportModule = ${toSafeJsLiteral(useDirectReactImport)} && ${toSafeJsLiteral(key)} === "react"
                 ? (res?.default ?? res)
-                : {...res}
+                : __mfNormalizeRuntimeShare({...res})
               // All npm packages pre-built by vite will be converted to esm
               if (exportModule.__esModule !== true) {
                 Object.defineProperty(exportModule, "__esModule", {
@@ -3637,9 +3727,8 @@ function getMaterializedShares(options) {
 		return priority(a) - priority(b) || a.localeCompare(b);
 	}));
 }
-function getShareBatches(options, materializedOnly = true) {
-	const ordered = materializedOnly ? getMaterializedShares(options) : getOrderedUsedShares(options);
-	const levels = /* @__PURE__ */ new Map();
+/** Shared keys a share's package.json depends on (roots stand in for their subpaths, subpaths for their root), keyed by share. */
+function getSharePrerequisites(ordered) {
 	const roots = /* @__PURE__ */ new Map();
 	const subpaths = /* @__PURE__ */ new Map();
 	for (const pkg of ordered) {
@@ -3647,6 +3736,7 @@ function getShareBatches(options, materializedOnly = true) {
 		if (pkg === packageName) roots.set(packageName, pkg);
 		else subpaths.set(packageName, [...subpaths.get(packageName) ?? [], pkg]);
 	}
+	const prerequisitesByShare = /* @__PURE__ */ new Map();
 	for (const pkg of ordered) {
 		const packageName = getPackageName(pkg);
 		const packageJson = getInstalledPackageJson(pkg)?.packageJson ?? (pkg !== packageName ? getInstalledPackageJson(packageName)?.packageJson : void 0);
@@ -3660,8 +3750,15 @@ function getShareBatches(options, materializedOnly = true) {
 			const root = roots.get(packageName);
 			if (root) prerequisites.push(root);
 		} else if (pkg === packageName && packageName !== "react" && packageName !== "react-dom") prerequisites.push(...subpaths.get(packageName) ?? []);
-		levels.set(pkg, prerequisites.reduce((level, dependency) => Math.max(level, (levels.get(dependency) ?? 0) + 1), 0));
+		prerequisitesByShare.set(pkg, prerequisites);
 	}
+	return prerequisitesByShare;
+}
+function getShareBatches(options, materializedOnly = true) {
+	const ordered = materializedOnly ? getMaterializedShares(options) : getOrderedUsedShares(options);
+	const prerequisitesByShare = getSharePrerequisites(ordered);
+	const levels = /* @__PURE__ */ new Map();
+	for (const pkg of ordered) levels.set(pkg, (prerequisitesByShare.get(pkg) ?? []).reduce((level, dependency) => Math.max(level, (levels.get(dependency) ?? 0) + 1), 0));
 	const batches = [];
 	for (const pkg of ordered) (batches[levels.get(pkg) ?? 0] ??= []).push(pkg);
 	return batches.filter(Boolean);
@@ -3903,9 +4000,14 @@ const externalSharedProviderSelectionHelperCode = `const __mfSelectExternalShare
           };`;
 function generateRuntimeSharedCacheSeedCode(shareStrategy, options) {
 	const seedBatches = getShareBatches(options, false);
+	const seedOrder = seedBatches.flat();
+	const seedIndex = new Map(seedOrder.map((pkg, index) => [pkg, index]));
+	const seedPrerequisites = Object.fromEntries(Array.from(getSharePrerequisites(seedOrder)).filter(([, prerequisites]) => prerequisites.length > 0).map(([pkg, prerequisites]) => [seedIndex.get(pkg), prerequisites.map((prerequisite) => seedIndex.get(prerequisite))]));
 	return `
-    const __mfSeedOrder = ${toSafeJsLiteral(seedBatches.flat())};
+    const __mfSeedOrder = ${toSafeJsLiteral(seedOrder)};
     const __mfSeedBatches = ${toSafeJsLiteral(seedBatches)};
+    const __mfSeedIndex = new Map(__mfSeedOrder.map((pkg, index) => [pkg, index]));
+    const __mfSeedPrerequisites = ${toSafeJsLiteral(seedPrerequisites)};
     // A share is normally skipped here until the dev scanner has observed a real
     // import and set materialize. An import:false share has no local fallback
     // though, so on a cold request (materialize not set yet) it must still be
@@ -4012,15 +4114,30 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy, options) {
         ${toSafeJsLiteral(shareStrategy)}
       ));
     };
-    const __mfFirstRuntimeSeedBarrierIndex = __mfSeedKeys.findIndex(
-      __mfNeedsPreInitSeedBarrier
+    const __mfExpandBlockedSeedKeys = (blocked) => {
+      let changed = true;
+      while (changed) {
+        changed = false;
+        for (const pkg of __mfSeedKeys) {
+          const seedIndex = __mfSeedIndex.get(pkg);
+          if (blocked.has(seedIndex)) continue;
+          if ((__mfSeedPrerequisites[seedIndex] || []).some((dependency) => blocked.has(dependency))) {
+            blocked.add(seedIndex);
+            changed = true;
+          }
+        }
+      }
+      return blocked;
+    };
+    const __mfPreInitBlockedSeedKeys = __mfExpandBlockedSeedKeys(new Set(
+      __mfSeedKeys.filter(__mfNeedsPreInitSeedBarrier).map((pkg) => __mfSeedIndex.get(pkg))
+    ));
+    const __mfImmediateSeedKeys = __mfSeedKeys.filter(
+      (pkg) => !__mfPreInitBlockedSeedKeys.has(__mfSeedIndex.get(pkg))
+    );
+    var __mfDeferredSeedKeys = __mfSeedKeys.filter(
+      (pkg) => __mfPreInitBlockedSeedKeys.has(__mfSeedIndex.get(pkg))
     );
-    const __mfImmediateSeedKeys = __mfFirstRuntimeSeedBarrierIndex === -1
-      ? __mfSeedKeys
-      : __mfSeedKeys.slice(0, __mfFirstRuntimeSeedBarrierIndex);
-    var __mfDeferredSeedKeys = __mfFirstRuntimeSeedBarrierIndex === -1
-      ? []
-      : __mfSeedKeys.slice(__mfFirstRuntimeSeedBarrierIndex);
     await __mfSeedLocalShared(__mfImmediateSeedKeys);`;
 }
 function getBrowserImportPath(importPath) {
@@ -4770,6 +4887,8 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
         const providerEntry = __mfFindSharedProviderEntry(versionMap, provider);
         if (!providerEntry) return;
         if (usedShare.shareConfig?.import === false && __mfMatchesSharedProvider(provider, usedShare)) return;
+        // Another container's consume-only stub has nothing to bridge to: its get() throws by construction.
+        if (provider?.shareConfig?.import === false) return;
         const { version } = providerEntry;
         if (!singleton && version !== usedShare.version) return;
         if (
@@ -4884,6 +5003,8 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
         };
         if (usedShare.canLiveRebind === false) return;
         if (usedShare.shareConfig?.import === false && __mfMatchesSharedProvider(provider, usedShare)) return;
+        // Another container's consume-only stub has nothing to bridge to: its get() throws by construction.
+        if (provider?.shareConfig?.import === false) return;
         // Preserve a singleton already selected by another container. The bridge may
         // only replace the provisional local fallback seeded by this container.
         if (cachedShare !== undefined && cachedShareOwner !== mfName) return;
@@ -5105,11 +5226,13 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       }
     };
     // Resolve runtime-only dependencies and seed local fallbacks in dependency
-    // order. Stop at an unresolved provider so its consumers cannot capture an
-    // undefined or provisional singleton.
+    // order. An unresolved provider blocks its consumers, which would otherwise
+    // capture an undefined or provisional singleton; unrelated shares still seed.
     const __mfReadyDeferredSeedKeys = [];
+    const __mfBlockedSeedKeys = new Set();
     for (const pkg of __mfDeferredSeedKeys) {
       const share = usedShared[pkg];
+      const seedIndex = __mfSeedIndex.get(pkg);
       if (__mfIsRuntimeOnlySharePending(pkg)) {
         try {
           if (share.treeShaking) {
@@ -5118,18 +5241,22 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
             await __mfResolveImportFalseShared(pkg, share);
           }
         } catch (err) {
-          // A rejected provider is an unresolved provider: stop here as the comment above
-          // prescribes, instead of escalating to a container-wide init() failure.
+          // A rejected provider is an unresolved provider: block its consumers as the
+          // comment above prescribes, instead of escalating to a container-wide init() failure.
           console.error(
             \`[Module Federation] Failed to resolve runtime-only shared module "\${pkg}"\`,
             err
           );
-          break;
         }
       }
-      if (__mfIsRuntimeOnlySharePending(pkg)) break;
-      __mfReadyDeferredSeedKeys.push(pkg);
+      if (__mfIsRuntimeOnlySharePending(pkg)) {
+        __mfBlockedSeedKeys.add(seedIndex);
+      }
     }
+    __mfExpandBlockedSeedKeys(__mfBlockedSeedKeys);
+    __mfReadyDeferredSeedKeys.push(...__mfDeferredSeedKeys.filter(
+      (pkg) => !__mfBlockedSeedKeys.has(__mfSeedIndex.get(pkg))
+    ));
     await __mfSeedLocalShared(__mfReadyDeferredSeedKeys);
     initResolve(initRes)
     return initRes
@@ -5275,6 +5402,71 @@ function getHostAutoInitPath(options) {
 function isOwnedHostAutoInitId(id, options) {
 	return VirtualModule.findById(id) === getHostAutoInitState(options).module;
 }
+/**
+* Build-time list of the loadShare wrappers this container bundles a fallback for, plus a function the host
+* bootstrap calls after the remote preloads: a share still unseeded then (behind an unresolved runtime-only
+* share in init()) has a deferred wrapper that only registers its pending load once evaluated. Importing it
+* here puts that load in front of the bootstrap's pendingShareLoads barrier instead of inside the entry's own
+* import graph, where module-scope reads would see it undefined. Kept out of hostInit so that chunk stays
+* free of wrapper references.
+*/
+const PENDING_SHARES_TAG = "__P_S__";
+const legacyPendingSharesState = {
+	module: new VirtualModule("pendingShares", PENDING_SHARES_TAG),
+	command: "build"
+};
+const pendingSharesStates = /* @__PURE__ */ new WeakMap();
+function getPendingSharesState(options) {
+	if (!options) return legacyPendingSharesState;
+	let state = pendingSharesStates.get(options);
+	if (!state) {
+		state = {
+			module: new VirtualModule("pendingShares", PENDING_SHARES_TAG, "", getLocalOwnerKey(options)),
+			command: "build"
+		};
+		pendingSharesStates.set(options, state);
+	}
+	return state;
+}
+function generatePendingSharesCode(command = "build", options) {
+	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
+	const pendingShareImports = command === "build" ? getMaterializedShares(options).filter((pkg) => {
+		const shareItem = resolvedOptions.shared?.[pkg];
+		return Boolean(shareItem) && !pkg.endsWith("/") && shareItem.shareConfig.import !== false && !shareItem.shareConfig.treeShaking;
+	}).map((pkg) => `[${toSafeJsLiteral(pkg)}, () => import(${toSafeJsLiteral(getLoadShareModulePath(pkg, false, options))})]`) : [];
+	return `
+    ${getRuntimeModuleCacheBootstrapCode()}
+    ${sharedCacheHelperCode}
+    const __mfPendingShareImports = [${pendingShareImports.join(", ")}];
+    export async function preloadPendingShares() {
+      if (__mfPendingShareImports.length === 0) return;
+      const {usedShared} = await import("${getLocalSharedImportMapPath(options)}");
+      await Promise.all(__mfPendingShareImports.map(async ([pkg, load]) => {
+        const share = usedShared[pkg];
+        if (!share || share.materialize === false || share.treeShaking || share.shareConfig?.import === false) return;
+        const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
+        if (__mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined) return;
+        await load().catch((err) => console.warn("[module-federation] shared preload failed:", pkg, err));
+      }));
+    }
+  `;
+}
+function writePendingShares(command = "build", options) {
+	const state = getPendingSharesState(options);
+	state.command = command;
+	state.module.writeSync(generatePendingSharesCode(command, options), true);
+}
+function refreshPendingShares(options) {
+	try {
+		writePendingShares(getPendingSharesState(options).command, options);
+	} catch {}
+}
+function getPendingSharesPath(options) {
+	return getPendingSharesState(options).module.getImportId();
+}
+function isOwnedPendingSharesId(id, options) {
+	return VirtualModule.findById(id) === getPendingSharesState(options).module;
+}
 //#endregion
 //#region src/virtualModules/virtualRemotes.ts
 const cacheRemoteMap = /* @__PURE__ */ new WeakMap();
@@ -5568,11 +5760,7 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
 	const remoteRegistration = getRemoteRegistration(id, resolvedOptions.remotes, options);
 	const registerRemoteCode = isLoadedFirst && remoteRegistration ? `runtime.registerRemotes([${JSON.stringify(remoteRegistration)}]);` : "";
 	const hostAutoInitPath = getHostAutoInitPath(options);
-	const ssrRemotes = Object.entries(resolvedOptions.remotes).map(([name, item]) => ({
-		name: getRuntimeRemoteAlias(name, options),
-		entry: item.entry,
-		type: item.type ?? "module"
-	}));
+	const ssrRemotes = getSsrRuntimeRemotes(resolvedOptions.remotes, options);
 	const browserHostInitCode = `import(${JSON.stringify(hostAutoInitPath)})
         .then((mod) => mod.hostInitPromise)
         .then(initResolve, initReject);`;
@@ -5798,6 +5986,7 @@ const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClien
 	let htmlFilePath;
 	let _command;
 	let emitFileId;
+	let pendingSharesEmitId;
 	let viteConfig;
 	let skipHtmlDevFallback = forceClientInjected ?? false;
 	let clientInjected = false;
@@ -5941,12 +6130,15 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
   if (__mfReactServerModuleCache?.pendingShareLoads) {
     await Promise.all(__mfReactServerModuleCache.pendingShareLoads);
   }`;
+		const pendingSharesBlock = waitsForInit && (_command === "build" || viteConfig?.command === "build") ? `
+  const __mfPendingShares = await ${importExpression(options?.pendingSharesSrc ?? getPendingSharesPath(federationOptions))}.catch(() => undefined);
+  if (__mfPendingShares && typeof __mfPendingShares.preloadPendingShares === "function") await __mfPendingShares.preloadPendingShares();` : "";
 		const importCode = `
 (async () => {
   const __mfHostInit = await ${importExpression(initSrc)};
   await __mfHostInit.__tla;
   const { initHost } = __mfHostInit;
-  ${preloadBlock}${sharedPreloadBlock}${pendingShareLoadsAwait}
+  ${preloadBlock}${pendingSharesBlock}${sharedPreloadBlock}${pendingShareLoadsAwait}
 })().then(() => ${entryImportExpression});
 `;
 		return [
@@ -5957,8 +6149,8 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			importCode
 		].join("\n");
 	}
-	function getSystemBootstrapSource(initSrc, entrySrc) {
-		return getBootstrapSource(initSrc, entrySrc, true);
+	function getSystemBootstrapSource(initSrc, entrySrc, pendingSharesSrc) {
+		return getBootstrapSource(initSrc, entrySrc, true, { pendingSharesSrc });
 	}
 	function injectHtml() {
 		return inject === "html" && (htmlFilePath || hasPackageDependency("@sveltejs/kit"));
@@ -6150,6 +6342,12 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			};
 			if (!hasHash) emitFileOptions.fileName = fileName;
 			emitFileId = this.emitFile(emitFileOptions);
+			if (waitsForInit) pendingSharesEmitId = this.emitFile({
+				name: "pendingShares",
+				type: "chunk",
+				id: getPendingSharesPath(federationOptions),
+				preserveSignature: "strict"
+			});
 			if (htmlFilePath) addHtmlScriptEntries(htmlFilePath);
 		},
 		generateBundle(_options, bundle) {
@@ -6164,6 +6362,7 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			if (htmlFileNames.length === 0) return;
 			const file = this.getFileName(emitFileId);
 			emittedFileName = file;
+			const pendingSharesFile = pendingSharesEmitId ? this.getFileName(pendingSharesEmitId) : void 0;
 			const lastSlash = file.lastIndexOf("/");
 			bootstrapDir = lastSlash !== -1 ? file.slice(0, lastSlash + 1) : "";
 			const resolvePath = (builtFileName, htmlFileName) => {
@@ -6199,7 +6398,10 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 					rewritten = true;
 					const strippedInit = stripBase(initPath);
 					const strippedEntry = stripBase(entrySrc);
-					const bootstrapSource = getSystemBootstrapSource(bootstrapDir ? rebaseImport(strippedInit, bootstrapDir) : initPath, bootstrapDir ? rebaseImport(strippedEntry, bootstrapDir) : entrySrc);
+					const rebasedInitPath = bootstrapDir ? rebaseImport(strippedInit, bootstrapDir) : initPath;
+					const rebasedEntrySrc = bootstrapDir ? rebaseImport(strippedEntry, bootstrapDir) : entrySrc;
+					const pendingSharesPath = pendingSharesFile ? resolvePath(pendingSharesFile, fileName) : void 0;
+					const bootstrapSource = getSystemBootstrapSource(rebasedInitPath, rebasedEntrySrc, pendingSharesPath && bootstrapDir ? rebaseImport(stripBase(pendingSharesPath), bootstrapDir) : pendingSharesPath);
 					const bootstrapHash = createHash("sha256").update(bootstrapSource).digest("hex").slice(0, 8);
 					const bootstrapFileName = `${bootstrapDir}mf-entry-bootstrap-${bootstrapIndex++}-${bootstrapHash}.js`;
 					const bootstrapRef = this.emitFile({
@@ -6296,7 +6498,12 @@ function checkAliasConflicts(options) {
 			const matchesSharedKey = (aliasEntry, sharedKey) => {
 				const findPattern = aliasEntry.find;
 				if (typeof findPattern === "string") return findPattern === sharedKey || sharedKey.startsWith(findPattern + "/");
-				if (findPattern instanceof RegExp) return findPattern.test(sharedKey);
+				if (findPattern instanceof RegExp) {
+					findPattern.lastIndex = 0;
+					const matched = findPattern.test(sharedKey);
+					findPattern.lastIndex = 0;
+					return matched;
+				}
 				return false;
 			};
 			for (const sharedKey of sharedKeys) for (const aliasEntry of userAliases) {
@@ -6487,6 +6694,21 @@ const vueAdapter = {
 	} }
 };
 //#endregion
+//#region src/utils/devServerHost.ts
+const UNSPECIFIED_HOSTS = /* @__PURE__ */ new Set(["0.0.0.0", "::"]);
+/**
+* Hostname for client-facing HTTP/WS origins built from Vite `server.host`.
+*
+* Unspecified bind addresses (`0.0.0.0`, `::`) map to `localhost`, matching
+* Vite's own printed local URL. IPv6 addresses are wrapped in brackets so
+* `http://[::1]:5173` / `ws://[::1]:5173` parse as valid URLs.
+*/
+function formatDevServerHostForOrigin(host) {
+	if (typeof host !== "string" || UNSPECIFIED_HOSTS.has(host)) return "localhost";
+	if (host.startsWith("[") && host.endsWith("]")) return host;
+	return isIPv6(host) ? `[${host}]` : host;
+}
+//#endregion
 //#region src/plugins/hmr/fullReload.ts
 const REMOTE_HMR_ENDPOINT = "__mf_hmr";
 const REMOTE_HMR_EVENT = "mf:remote-update";
@@ -6512,10 +6734,10 @@ function getHmrWsPath(base, hmrPath) {
 }
 function getRemoteHmrWsUrl(server) {
 	const hmr = server.config.server.hmr;
-	return `${hmr && typeof hmr === "object" && hmr.protocol ? hmr.protocol : server.config.server.https ? "wss" : "ws"}://${hmr && typeof hmr === "object" && hmr.host ? hmr.host : typeof server.config.server.host === "string" && server.config.server.host !== "0.0.0.0" ? server.config.server.host : "localhost"}:${hmr && typeof hmr === "object" && (hmr.clientPort || hmr.port) ? hmr.clientPort || hmr.port : server.config.server.port}${getHmrWsPath(server.config.base, hmr && typeof hmr === "object" ? hmr.path : "")}?token=${server.config.webSocketToken}`;
+	return `${hmr && typeof hmr === "object" && hmr.protocol ? hmr.protocol : server.config.server.https ? "wss" : "ws"}://${formatDevServerHostForOrigin(hmr && typeof hmr === "object" && hmr.host ? hmr.host : server.config.server.host)}:${hmr && typeof hmr === "object" && (hmr.clientPort || hmr.port) ? hmr.clientPort || hmr.port : server.config.server.port}${getHmrWsPath(server.config.base, hmr && typeof hmr === "object" ? hmr.path : "")}?token=${server.config.webSocketToken}`;
 }
 function getLocalFallbackOrigin(server) {
-	return `${server.config.server.https ? "https" : "http"}://${typeof server.config.server.host === "string" && server.config.server.host !== "0.0.0.0" && server.config.server.host !== "::" ? server.config.server.host : "localhost"}:${server.config.server.port || 5173}`;
+	return `${server.config.server.https ? "https" : "http"}://${formatDevServerHostForOrigin(server.config.server.host)}:${server.config.server.port || 5173}`;
 }
 function getRemoteHmrEndpoint(remoteEntry, server) {
 	try {
@@ -7013,11 +7235,7 @@ function pluginExternalRuntimeCore() {
 function initVirtualModules(command, remoteEntryId, enableSsrInit = false, options) {
 	writeLocalSharedImportMap(options);
 	writeHostAutoInit(remoteEntryId, command, options);
-	writeRuntimeInitStatus(command, enableSsrInit, getHostAutoInitPath(options), options, options ? Object.entries(options.remotes).map(([name, item]) => ({
-		name,
-		entry: item.entry,
-		type: item.type ?? "module"
-	})) : void 0);
+	writeRuntimeInitStatus(command, enableSsrInit, getHostAutoInitPath(options), options, options ? getSsrRuntimeRemotes(options.remotes, options) : void 0);
 }
 //#endregion
 //#region src/utils/cssModuleHelpers.ts
@@ -7240,15 +7458,22 @@ const REMOTE_ENTRY_SSR_ID = "virtual:mf-REMOTE_ENTRY_SSR_ID";
 function getRemoteEntrySSRId(options) {
 	return `${REMOTE_ENTRY_SSR_ID}:${getVirtualModuleScopeKey(options)}`;
 }
+function stripSsrFilenameHashPlaceholder(filename) {
+	if (!filename.includes("[hash")) return filename;
+	filename = filename.replace(/(?:[._-]?\[hash(?::\d+)?\])/g, "");
+	if (!/\.[^.]+$/.test(filename)) filename = `${filename}.js`;
+	return filename;
+}
 function getSsrRemoteEntryFileName(browserFilename) {
-	let filename = browserFilename;
-	if (filename.includes("[hash")) {
-		filename = filename.replace(/(?:[._-]?\[hash(?::\d+)?\])/g, "");
-		if (!/\.[^.]+$/.test(filename)) filename = `${filename}.js`;
-	}
+	const filename = stripSsrFilenameHashPlaceholder(browserFilename);
 	const ext = filename.match(/\.[^.]+$/)?.[0] || ".js";
 	return `${filename.slice(0, filename.length - ext.length)}.ssr${ext}`;
 }
+function getSsrExposesFileName(browserFilename) {
+	const filename = stripSsrFilenameHashPlaceholder(browserFilename);
+	const ext = filename.match(/\.[^.]+$/)?.[0];
+	return `${ext ? filename.slice(0, filename.length - ext.length) : filename}.exposes.js`;
+}
 /** Singleton map for SSR loadShare: expand `pkg/` via usedShares; never serialize the prefix. */
 function getSsrSharedSingletons(options) {
 	const used = getUsedShares(options);
@@ -8138,7 +8363,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 				}
 				if (isHostAutoInitId(id)) {
 					if (_command === "serve") {
-						const host = typeof viteConfig.server?.host === "string" && viteConfig.server.host !== "0.0.0.0" ? viteConfig.server.host : "localhost";
+						const host = formatDevServerHostForOrigin(viteConfig.server?.host);
 						const resolvedPublicPath = resolvePublicPath(options, viteConfig.base, originalConfigBase);
 						const devPublicPath = resolvedPublicPath === "auto" ? "/" : resolvedPublicPath;
 						const remoteEntryFileName = resolveDevHashEntryFileName(options.filename);
@@ -8340,54 +8565,6 @@ function isBuildConfigImporter(importer) {
 	if (!importer) return false;
 	return /(^|\/)(?:nuxt|vite|vitest|webpack|rollup|rspack)\.config\.[cm]?[jt]sx?$/.test(importer.replace(/\\/g, "/"));
 }
-function matchesSharedSource(source, key) {
-	const keyBase = key.endsWith("/") ? key.slice(0, -1) : key;
-	if (keyBase === "vue" && (source === "vue/dist/vue.esm-bundler.js" || source === "vue/dist/vue.runtime.esm-bundler.js")) return true;
-	if (key.endsWith("/")) return source === keyBase || source.startsWith(`${keyBase}/`);
-	if (getCommonSharedSubpaths(keyBase).includes(source)) return true;
-	return source === keyBase;
-}
-function findSharedKey(source, shared) {
-	return getSharedKeyMatcher(shared).find(source);
-}
-const emptySharedKeyMatcher = { find: () => void 0 };
-const sharedKeyMatcherCache = /* @__PURE__ */ new WeakMap();
-function getSharedKeyMatcher(shared) {
-	if (!shared) return emptySharedKeyMatcher;
-	const cached = sharedKeyMatcherCache.get(shared);
-	if (cached) return cached;
-	const keys = Object.keys(shared);
-	const exactKeys = new Set(keys);
-	const commonSubpathKeys = /* @__PURE__ */ new Map();
-	const wildcardKeys = [];
-	let vueKey;
-	for (const key of keys) {
-		const keyBase = key.endsWith("/") ? key.slice(0, -1) : key;
-		const shareItem = shared[key];
-		if (!vueKey && keyBase === "vue") vueKey = key;
-		if (key.endsWith("/")) wildcardKeys.push({
-			key,
-			base: keyBase
-		});
-		if (shareItem.shareConfig?.import !== false) {
-			for (const subpath of getCommonSharedSubpaths(keyBase)) if (!commonSubpathKeys.has(subpath)) commonSubpathKeys.set(subpath, key);
-		}
-	}
-	const sourceCache = /* @__PURE__ */ new Map();
-	const matcher = { find(source) {
-		if (sourceCache.has(source)) return sourceCache.get(source);
-		let result = exactKeys.has(source) ? source : void 0;
-		if (!result && vueKey) {
-			if (source === "vue/dist/vue.esm-bundler.js" || source === "vue/dist/vue.runtime.esm-bundler.js") result = vueKey;
-		}
-		if (!result) result = commonSubpathKeys.get(source);
-		if (!result) result = wildcardKeys.find(({ base }) => source === base || source.startsWith(`${base}/`))?.key;
-		sourceCache.set(source, result);
-		return result;
-	} };
-	sharedKeyMatcherCache.set(shared, matcher);
-	return matcher;
-}
 function findSharedKeyForSource(source, shared) {
 	const key = findSharedKey(source, shared);
 	if (key) return key;
@@ -8433,12 +8610,109 @@ function excludeSharedSubDependencies(shared) {
 				delete shared[depKey];
 				sharedKeys.delete(depKey);
 				sharedKeyByBase.delete(dep);
-				sharedKeyMatcherCache.delete(shared);
+				invalidateSharedKeyMatcher(shared);
 			}
 		}
 	}
 }
 const sharedDependencyCache = /* @__PURE__ */ new Map();
+const sharedPackageDirectoryCache = /* @__PURE__ */ new WeakMap();
+function getSharedPackageFromFile(importer, shared, cwd = getPackageDetectionCwd()) {
+	if (!importer) return;
+	const nodeModulePackage = getPackageNameFromNodeModulePath(importer);
+	if (nodeModulePackage) return nodeModulePackage;
+	let cached = sharedPackageDirectoryCache.get(shared);
+	if (!cached || cached.cwd !== cwd) {
+		const entries = /* @__PURE__ */ new Map();
+		for (const key of Object.keys(shared)) {
+			const packageName = getPackageName(key);
+			const entry = getInstalledPackageEntry(packageName, { cwd });
+			if (entry && !isNodeModulePath(entry)) entries.set(path$1.dirname(normalizePathForImport(entry)), packageName);
+		}
+		cached = {
+			cwd,
+			entries
+		};
+		sharedPackageDirectoryCache.set(shared, cached);
+	}
+	const normalizedImporter = normalizePathForImport(importer);
+	return [...cached.entries].find(([dir]) => normalizedImporter === dir || normalizedImporter.startsWith(`${dir}/`))?.[1] ?? getWorkspacePackageNameFromFile(normalizedImporter);
+}
+const workspacePackageNameCache = /* @__PURE__ */ new Map();
+/** Name from the nearest `package.json` above `file`, for files outside `node_modules`. */
+function getWorkspacePackageNameFromFile(file) {
+	const filePath = file.split("?")[0];
+	if (!path$1.isAbsolute(filePath) || isNodeModulePath(filePath)) return;
+	const visited = [];
+	let dir = path$1.dirname(filePath);
+	let name;
+	while (true) {
+		if (workspacePackageNameCache.has(dir)) {
+			name = workspacePackageNameCache.get(dir);
+			break;
+		}
+		visited.push(dir);
+		const manifestPath = path$1.join(dir, "package.json");
+		if (existsSync(manifestPath)) {
+			try {
+				const manifestName = JSON.parse(readFileSync(manifestPath, "utf-8")).name;
+				if (typeof manifestName !== "string") {
+					const parent = path$1.dirname(dir);
+					if (parent === dir) break;
+					dir = parent;
+					continue;
+				}
+				name = manifestName;
+			} catch {
+				name = void 0;
+			}
+			break;
+		}
+		const parent = path$1.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	for (const visitedDir of visited) workspacePackageNameCache.set(visitedDir, name);
+	return name;
+}
+const dependencyManifestCache = /* @__PURE__ */ new Map();
+/**
+* The manifest of `dep` as seen from `fromDir`: a plain `node_modules` walk-up first, because the
+* cycle walk below visits every package in the tree and `getInstalledPackageJson`'s resolver is
+* far too expensive for that many lookups; it stays the fallback for layouts the walk-up misses.
+*/
+function getDependencyManifest(dep, fromDir) {
+	const cacheKey = `${fromDir}\0${dep}`;
+	if (dependencyManifestCache.has(cacheKey)) return dependencyManifestCache.get(cacheKey);
+	let found;
+	let currentDir = fromDir;
+	while (true) {
+		const packageJsonPath = path$1.join(currentDir, "node_modules", dep, "package.json");
+		if (existsSync(packageJsonPath)) {
+			try {
+				let dir = path$1.dirname(packageJsonPath);
+				try {
+					dir = realpathSync(dir);
+				} catch {}
+				found = {
+					path: packageJsonPath,
+					dir,
+					packageJson: JSON.parse(readFileSync(packageJsonPath, "utf-8"))
+				};
+			} catch {}
+			break;
+		}
+		const parentDir = path$1.dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	found ??= getInstalledPackageJson(dep, {
+		cwd: fromDir,
+		packageName: dep
+	});
+	dependencyManifestCache.set(cacheKey, found);
+	return found;
+}
 /** Whether `dependency` is reachable through the shared package's manifest dependencies. */
 function isSharedPackageDependency(sharedKey, dependency) {
 	const sharedPackage = getPackageName(sharedKey);
@@ -8447,8 +8721,9 @@ function isSharedPackageDependency(sharedKey, dependency) {
 		reachable = /* @__PURE__ */ new Set();
 		const visited = /* @__PURE__ */ new Set();
 		const queue = [getInstalledPackageJson(sharedPackage, { packageName: sharedPackage })];
-		for (let installed = queue.shift(); installed; installed = queue.shift()) {
-			if (visited.has(installed.dir)) continue;
+		while (queue.length) {
+			const installed = queue.shift();
+			if (!installed || visited.has(installed.dir)) continue;
 			visited.add(installed.dir);
 			const manifest = installed.packageJson;
 			for (const dep of Object.keys({
@@ -8457,16 +8732,145 @@ function isSharedPackageDependency(sharedKey, dependency) {
 				...manifest.optionalDependencies
 			})) {
 				reachable.add(dep);
-				queue.push(getInstalledPackageJson(dep, {
-					cwd: installed.dir,
-					packageName: dep
-				}));
+				queue.push(getDependencyManifest(dep, installed.dir));
 			}
 		}
 		sharedDependencyCache.set(sharedPackage, reachable);
 	}
 	return reachable.has(dependency);
 }
+const sharedRuntimeDependencyCache = /* @__PURE__ */ new Map();
+const SOURCE_FILE_RE = /\.(?:[cm]?js|[cm]?ts|jsx|tsx)$/;
+const NON_RUNTIME_SOURCE_RE = /(?:\.d\.[cm]?ts|\.(?:test|spec|stories)\.[cm]?[jt]sx?)$/;
+const NON_RUNTIME_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	"__tests__",
+	"dist",
+	"build"
+]);
+/** Bundled artifacts of a published package never import workspace packages; skip them instead of scanning megabytes. */
+const MAX_SCANNED_SOURCE_BYTES = 256 * 1024;
+const BARE_PACKAGE_SPECIFIER_RE = /^(?:@[^\s'"`()\/]+\/)?[^\s'"`()\/.@][^\s'"`()\/]*(?:\/[^\s'"`()]*)?$/;
+/** Module specifiers evaluated by a source file. */
+function getRuntimeModuleSpecifiers(code) {
+	return findModuleImportDescriptors(code).filter(({ typeOnly }) => !typeOnly).map(({ source }) => source);
+}
+/** Bare specifiers a source file imports at runtime. */
+function getRuntimeImportSpecifiers(code) {
+	return getRuntimeModuleSpecifiers(code).filter((specifier) => BARE_PACKAGE_SPECIFIER_RE.test(specifier) && !isBuiltin(specifier));
+}
+function collectAllRuntimeImports(dir, into) {
+	let entries;
+	try {
+		entries = readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if (entry.isDirectory()) {
+			if (!NON_RUNTIME_DIRS.has(entry.name)) collectAllRuntimeImports(path$1.join(dir, entry.name), into);
+			continue;
+		}
+		if (!SOURCE_FILE_RE.test(entry.name) || NON_RUNTIME_SOURCE_RE.test(entry.name)) continue;
+		const file = path$1.join(dir, entry.name);
+		let code;
+		try {
+			if (statSync(file).size > MAX_SCANNED_SOURCE_BYTES) continue;
+			code = readFileSync(file, "utf-8");
+		} catch {
+			continue;
+		}
+		for (const specifier of getRuntimeImportSpecifiers(code)) into.add(specifier);
+	}
+}
+const SOURCE_EXTENSIONS = [
+	"",
+	".js",
+	".mjs",
+	".cjs",
+	".ts",
+	".mts",
+	".cts",
+	".jsx",
+	".tsx"
+];
+function resolveLocalRuntimeImport(importer, specifier) {
+	if (!specifier.startsWith(".")) return;
+	const resolved = path$1.resolve(path$1.dirname(importer), specifier);
+	return SOURCE_EXTENSIONS.flatMap((extension) => [`${resolved}${extension}`, path$1.join(resolved, `index${extension}`)]).find((candidate) => existsSync(candidate));
+}
+function collectReachableRuntimeImports(entry, dir, into) {
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [entry];
+	let scanned = false;
+	while (queue.length) {
+		const file = queue.shift();
+		const relative = path$1.relative(dir, file);
+		if (relative.startsWith("..") || path$1.isAbsolute(relative) || visited.has(file)) continue;
+		visited.add(file);
+		let code;
+		try {
+			if (statSync(file).size > MAX_SCANNED_SOURCE_BYTES) continue;
+			code = readFileSync(file, "utf-8");
+			scanned = true;
+		} catch {
+			continue;
+		}
+		for (const specifier of getRuntimeModuleSpecifiers(code)) {
+			if (BARE_PACKAGE_SPECIFIER_RE.test(specifier) && !isBuiltin(specifier)) {
+				into.add(specifier);
+				continue;
+			}
+			const local = resolveLocalRuntimeImport(file, specifier);
+			if (local) queue.push(local);
+		}
+	}
+	return scanned;
+}
+/**
+* Whether `dependency` is reachable from the shared package through the imports its source files
+* (and those of the workspace packages they pull in) actually evaluate. Unlike the manifest walk
+* above this ignores `import type` edges and stops at `node_modules` boundaries, so it approximates
+* the fallback's evaluation graph rather than the package's declared closure — in a monorepo the
+* latter covers far more than the module graph ever does.
+*/
+function isSharedPackageRuntimeDependency(sharedKey, dependency) {
+	const sharedPackage = getPackageName(sharedKey);
+	let reachable = sharedRuntimeDependencyCache.get(sharedKey);
+	if (!reachable) {
+		reachable = /* @__PURE__ */ new Set();
+		const visited = /* @__PURE__ */ new Set();
+		const queue = [{
+			request: sharedKey,
+			installed: getInstalledPackageJson(sharedPackage, { packageName: sharedPackage })
+		}];
+		while (queue.length) {
+			const { request, installed } = queue.shift();
+			if (!installed) continue;
+			const visitKey = `${installed.dir}\0${request}`;
+			if (visited.has(visitKey)) continue;
+			visited.add(visitKey);
+			const specifiers = /* @__PURE__ */ new Set();
+			const entry = getInstalledPackageEntry(request, {
+				cwd: installed.dir,
+				packageName: getPackageName(request)
+			});
+			if (!entry || !collectReachableRuntimeImports(entry, installed.dir, specifiers)) collectAllRuntimeImports(installed.dir, specifiers);
+			for (const specifier of specifiers) {
+				const dep = getPackageName(specifier);
+				if (dep === sharedPackage) continue;
+				reachable.add(dep);
+				const manifest = getDependencyManifest(dep, installed.dir);
+				if (manifest && !isNodeModulePath(manifest.dir)) queue.push({
+					request: specifier,
+					installed: manifest
+				});
+			}
+		}
+		sharedRuntimeDependencyCache.set(sharedKey, reachable);
+	}
+	return reachable.has(dependency);
+}
 function proxySharedModule(options) {
 	const { shared = {}, federationOptions, getParsePromise = () => Promise.resolve() } = options;
 	let _config;
@@ -8549,6 +8953,9 @@ function proxySharedModule(options) {
 				resetTreeShakingExports(federationOptions);
 				emittedTreeShakingProviders.clear();
 				sharedDependencyCache.clear();
+				dependencyManifestCache.clear();
+				sharedRuntimeDependencyCache.clear();
+				workspacePackageNameCache.clear();
 				const isVinext = hasPackageDependency("vinext");
 				const isAstro = hasPackageDependency("astro");
 				const isRolldown = getIsRolldown(this);
@@ -8637,9 +9044,11 @@ function proxySharedModule(options) {
 				}
 				const key = findSharedKeyForSource(source, shared);
 				if (!key) return;
-				const importerPackage = importer ? getPackageNameFromNodeModulePath(importer) : void 0;
+				const importerPackage = getSharedPackageFromFile(importer, shared);
 				if (importerPackage === getPackageName(key)) return;
-				if (importerPackage && isSharedPackageDependency(key, importerPackage)) return;
+				if (importerPackage) {
+					if (!isNodeModulePath(importer) && !Object.keys(shared).some((sharedKey) => getPackageName(sharedKey) === importerPackage) ? isSharedPackageRuntimeDependency(key, importerPackage) : isSharedPackageDependency(key, importerPackage)) return;
+				}
 				if (useDirectReactImport && key === "react") return;
 				if (isAssetLikeImport(source)) return;
 				if (isBuildConfigImporter(importer)) return;
@@ -9105,6 +9514,7 @@ function pluginSSRRemoteEntry(options) {
 	const virtualExposesSSRId = getVirtualExposesSSRId(options);
 	let cachedSsrRemoteEntrySource;
 	const ssrOutputFilename = getSsrRemoteEntryFileName(options.filename);
+	const ssrExposesFileName = getSsrExposesFileName(options.filename);
 	let ssrOutputFiles = /* @__PURE__ */ new Set();
 	let ssrOutputDir = "";
 	let clientOutputDir = "";
@@ -9232,13 +9642,13 @@ function pluginSSRRemoteEntry(options) {
 			});
 			const ssrPath = `${base}/${ssrEntryFileName}`;
 			server.middlewares.use(ssrPath, (_req, res) => {
-				const exposesUrl = `${base}/${options.filename.replace(/\.[^.]+$/, "")}.exposes.js`;
+				const exposesUrl = `${base}/${ssrExposesFileName}`;
 				const code = getSsrRemoteEntrySource().replace(JSON.stringify(virtualExposesSSRId), JSON.stringify(exposesUrl));
 				res.setHeader("Content-Type", "application/javascript");
 				res.setHeader("Access-Control-Allow-Origin", "*");
 				res.end(code);
 			});
-			const exposesPath = `${base}/${options.filename.replace(/\.[^.]+$/, "")}.exposes.js`;
+			const exposesPath = `${base}/${ssrExposesFileName}`;
 			server.middlewares.use(exposesPath, (_req, res) => {
 				res.setHeader("Content-Type", "application/javascript");
 				res.setHeader("Access-Control-Allow-Origin", "*");
@@ -9249,7 +9659,7 @@ function pluginSSRRemoteEntry(options) {
 			if (id === remoteEntrySSRId || id.startsWith(remoteEntrySSRId)) return id;
 			if (id === virtualExposesSSRId || id.startsWith(virtualExposesSSRId)) return id;
 			if (id === `/__mf_ssr__/${getSsrRemoteEntryFileName(options.filename)}`) return remoteEntrySSRId;
-			if (id === `/__mf_ssr__/${options.filename.replace(/\.[^.]+$/, "")}.exposes.js`) return virtualExposesSSRId;
+			if (id === `/__mf_ssr__/${ssrExposesFileName}`) return virtualExposesSSRId;
 		},
 		load(id) {
 			if (id === remoteEntrySSRId || id.startsWith(remoteEntrySSRId)) return getSsrRemoteEntrySource();
@@ -9783,6 +10193,22 @@ function isFile(candidate) {
 function isReactRouterBuildClientRouteInput(entry) {
 	return /[?&]__react-router-build-client-route(?:[=&]|$)/.test(entry);
 }
+/**
+* Files whose JSX the compiler rewrites to an automatic-runtime import.
+* Vite only applies the JSX transform to these extensions by default.
+*/
+const JSX_SOURCE_EXTENSIONS = [".jsx", ".tsx"];
+function getAutomaticJsxRuntime(config) {
+	for (const candidate of [config.oxc, config.esbuild]) {
+		if (!candidate || typeof candidate !== "object") continue;
+		const transform = candidate;
+		const jsx = transform.jsx;
+		const runtime = typeof jsx === "object" ? jsx.runtime : jsx;
+		if (runtime && runtime !== "automatic") return void 0;
+		if (runtime !== "automatic") continue;
+		return `${(typeof jsx === "object" ? jsx.importSource : void 0) ?? transform.jsxImportSource ?? "react"}/${(typeof jsx === "object" ? jsx.development : void 0) ?? transform.jsxDev ?? true ? "jsx-dev-runtime" : "jsx-runtime"}`;
+	}
+}
 function registerEntryImports(options, projectRoot, recordShared = true, entryFiles = []) {
 	const sourceExtensions = [
 		".mjs",
@@ -9797,6 +10223,7 @@ function registerEntryImports(options, projectRoot, recordShared = true, entryFi
 	const root = path$1.resolve(projectRoot);
 	const pending = [];
 	const visited = /* @__PURE__ */ new Map();
+	let hasJsxSource = false;
 	const enqueue = (request, importer = path$1.join(root, "index.html"), preloadRemotes = false) => {
 		const cleanRequest = request.replace(/[?#].*$/, "");
 		if (!cleanRequest.startsWith(".") && !cleanRequest.startsWith("/") && !path$1.isAbsolute(cleanRequest)) return;
@@ -9829,6 +10256,7 @@ function registerEntryImports(options, projectRoot, recordShared = true, entryFi
 		if (visited.get(file) || visited.has(file) && !preloadRemotes) continue;
 		visited.set(file, preloadRemotes);
 		const code = getScannableModuleSource(file, readFileSync(file, "utf8"));
+		if (JSX_SOURCE_EXTENSIONS.some((extension) => file.endsWith(extension))) hasJsxSource = true;
 		for (const { source: request, kind, typeOnly } of findModuleImportDescriptors(code)) {
 			const isStatic = kind === "static" && !typeOnly;
 			const remoteKey = preloadRemotes && isStatic && request ? Object.keys(options.remotes).find((name) => request === name || request.startsWith(`${name}/`)) : void 0;
@@ -9841,6 +10269,14 @@ function registerEntryImports(options, projectRoot, recordShared = true, entryFi
 			else if (request && !typeOnly) enqueue(request, file, preloadRemotes && isStatic);
 		}
 	}
+	return hasJsxSource;
+}
+function materializeAutomaticJsxRuntime(options, runtime) {
+	if (!findSharedKey(runtime, options.shared)) return false;
+	addUsedShares(runtime, options);
+	const packageName = getPackageName(runtime);
+	if (packageName !== runtime && findSharedKey(packageName, options.shared)) addUsedShares(packageName, options);
+	return true;
 }
 /**
 * Plugin that runs FIRST to register generated virtual modules in the config hook.
@@ -9850,6 +10286,7 @@ function registerEntryImports(options, projectRoot, recordShared = true, entryFi
 function createEarlyVirtualModulesPlugin(options) {
 	const { shared, remotes } = options;
 	const isLitShare = (pkg) => pkg === "lit" || pkg.startsWith("lit/");
+	let hasClientJsxSource = false;
 	return {
 		name: "vite:module-federation-early-init",
 		enforce: "pre",
@@ -9872,7 +10309,10 @@ function createEarlyVirtualModulesPlugin(options) {
 					config.optimizeDeps.exclude.push(...Object.keys(remotes || {}));
 				}
 			}
-			if (!config.build?.ssr && (Object.keys(shared ?? {}).length > 0 || Object.keys(remotes ?? {}).length > 0)) registerEntryImports(options, root, _command === "serve", resolvedConfiguredEntryFiles);
+			if (!config.build?.ssr && (Object.keys(shared ?? {}).length > 0 || Object.keys(remotes ?? {}).length > 0)) {
+				const hasJsxSource = registerEntryImports(options, root, _command === "serve", resolvedConfiguredEntryFiles);
+				if (_command === "serve") hasClientJsxSource = hasJsxSource;
+			}
 			if (shared && Object.keys(shared).length > 0) {
 				if (_command === "serve") {
 					excludeSharedSubDependencies(shared);
@@ -9900,6 +10340,8 @@ function createEarlyVirtualModulesPlugin(options) {
 								if (isSharedResolverInternalImporter(importer)) return;
 								const key = findSharedKey(source, shared);
 								if (!key) return;
+								const importerPackage = getSharedPackageFromFile(importer, shared, root);
+								if (!isReactDomSelfReference(source, importer) && (importerPackage === getPackageName(key) || importerPackage && isSharedPackageDependency(key, importerPackage))) return;
 								if (isAssetLikeImport(source)) return;
 								const shareItem = shared[key];
 								const isReactSingleton = source === "react" && key === "react" && shareItem.shareConfig?.singleton === true;
@@ -9938,7 +10380,9 @@ function createEarlyVirtualModulesPlugin(options) {
 									if (isSharedResolverInternalImporter(args.importer)) return;
 									const key = findSharedKey(args.path, shared);
 									if (!key || isAssetLikeImport(args.path)) return;
-									if (getPackageNameFromNodeModulePath(args.importer) === getPackageName(args.path) && !isReactDomSelfReference(args.path, args.importer)) return;
+									const importerPackage = getSharedPackageFromFile(args.importer, shared, root);
+									if (importerPackage === getPackageName(args.path) && !isReactDomSelfReference(args.path, args.importer)) return;
+									if (importerPackage && isSharedPackageDependency(key, importerPackage)) return;
 									addUsedShares(args.path, options);
 									if (args.kind === "import-statement" || args.kind === "dynamic-import") {
 										const shareItem = shared[key];
@@ -10038,6 +10482,10 @@ export default __mfShared.default ?? __mfShared;`
 			}
 		},
 		configResolved(config) {
+			if (hasClientJsxSource) {
+				const automaticJsxRuntime = getAutomaticJsxRuntime(config);
+				if (automaticJsxRuntime && materializeAutomaticJsxRuntime(options, automaticJsxRuntime)) writeLocalSharedImportMap(options);
+			}
 			const viteMajor = parseInt(version, 10);
 			const hasRemotes = Object.keys(options.remotes).length > 0;
 			if (!getSsrCapabilities(viteMajor, config.command, hasRemotes).injectSsrEntryLoader) return;
@@ -10083,7 +10531,7 @@ function applyBuildTimeRuntimeDefines(define, options, { target, isAstro, defaul
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-C2bUY8h9.js").then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-BhONN9dR.js").then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {
@@ -10124,7 +10572,7 @@ function federation(mfUserOptions) {
 	const virtualExposesId = getVirtualExposesId(options);
 	const moduleParseController = createModuleParseController();
 	const moduleParsePlugins = pluginModuleParseEnd_default((id) => {
-		return id.includes(getHostAutoInitPath(options)) || id.includes(remoteEntryId) || id.includes(virtualExposesId) || id.includes("virtual:mf-localSharedImportMap") || id.includes("__loadShare__") || id.includes("__prebuild__") || id.includes("__treeShakingProvider__") || id.includes("__mf_tree_shaking_graph__");
+		return id.includes(getHostAutoInitPath(options)) || id.includes(getPendingSharesPath(options)) || id.includes(remoteEntryId) || id.includes(virtualExposesId) || id.includes("virtual:mf-localSharedImportMap") || id.includes("__loadShare__") || id.includes("__prebuild__") || id.includes("__treeShakingProvider__") || id.includes("__mf_tree_shaking_graph__");
 	}, {
 		moduleParseTimeout: options.moduleParseTimeout,
 		moduleParseIdleTimeout: options.moduleParseIdleTimeout,
@@ -10226,6 +10674,7 @@ function federation(mfUserOptions) {
 				}
 				if (id.includes("__prebuild__") && refreshPreBuildModuleForEnvironment(id, this, loadOptions) === "not-owned") return;
 				if (id.includes("__H_A_I__") && isOwnedHostAutoInitId(id, options)) refreshHostAutoInit(options, getLoadHookExportConditions(this, loadOptions));
+				if (id.includes("__P_S__") && isOwnedPendingSharesId(id, options)) refreshPendingShares(options);
 				const virtualModule = VirtualModule.findById(id);
 				if (!virtualModule) return;
 				if (command === "build" && (id.includes("__loadShare__") || id.includes("__loadRemote__"))) return;