npm - @module-federation/vite - Versions diffs - 1.20.5 → 1.20.6 - Mend

@module-federation/vite 1.20.5 → 1.20.6

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 (7) hide show

package/lib/dtsConstants-DyJrx8ah.js +476 -0
package/lib/index.js +482 -939
package/lib/pluginDts-BNCg4Gri.js +312 -0
package/lib/{ssrEntryLoader-Ccr0zMrr.js → ssrEntryLoader-0NnTjWR1.js} +11 -8
package/lib/{ssrVmStrategy-DTJITp2Z.js → ssrVmStrategy-B0fCaHs5.js} +1 -1
package/lib/utils/ssrEntryLoader.js +1 -1
package/package.json +1 -1

package/lib/index.js CHANGED Viewed

@@ -1,8 +1,9 @@
 import { n as normalizePathForImport, r as rebaseImport } from "./buildPaths-BkaQHrd2.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$2, s as isAssetLikeImport, t as ensureTrailingSlash, u as isViteOptimizableEntry } from "./pathNormalization-DvgU8LIp.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-DyJrx8ah.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-DvgU8LIp.js";
 import { createRequire } from "node:module";
 import * as fs$2 from "fs";
-import fs, { existsSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "fs";
+import { existsSync, readFileSync, realpathSync, statSync, writeFileSync } from "fs";
 import { createRequire as createRequire$1 } from "module";
 import * as path$1 from "node:path";
 import path, { basename } from "node:path";
@@ -12,21 +13,6 @@ 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 { normalizeOptions } from "@module-federation/sdk";
-import { consumeTypesAPI, generateTypesAPI, isTSProject, normalizeConsumeTypesOptions, normalizeDtsOptions, normalizeGenerateTypesOptions } from "@module-federation/dts-plugin";
-import { rpc } from "@module-federation/dts-plugin/core";
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
 //#region src/utils/codeRewriter.ts
 const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var CodeRewriter = class {
@@ -338,475 +324,6 @@ function injectEntryScript(html, initSrc) {
 	return html.replace("<head>", `<head><script type="module" src=${JSON.stringify(src)}><\/script>`);
 }
 //#endregion
-//#region src/utils/logger.ts
-const MODULE_FEDERATION_LOG_PREFIX = "[Module Federation]";
-function formatModuleFederationMessage(message) {
-	return `${MODULE_FEDERATION_LOG_PREFIX} ${message}`;
-}
-function createModuleFederationError(message) {
-	return new Error(formatModuleFederationMessage(message));
-}
-function toConsoleArgs(message, rest = []) {
-	if (typeof message === "string") return [formatModuleFederationMessage(message), ...rest];
-	if (message === void 0) return [MODULE_FEDERATION_LOG_PREFIX, ...rest];
-	return [
-		MODULE_FEDERATION_LOG_PREFIX,
-		message,
-		...rest
-	];
-}
-const moduleFederationConsole = {
-	log(message, ...rest) {
-		console.log(...toConsoleArgs(message, rest));
-	},
-	warn(message, ...rest) {
-		console.warn(...toConsoleArgs(message, rest));
-	},
-	error(message, ...rest) {
-		console.error(...toConsoleArgs(message, rest));
-	}
-};
-moduleFederationConsole.log;
-const mfWarn = moduleFederationConsole.warn;
-const mfError = moduleFederationConsole.error;
-//#endregion
-//#region src/utils/packageUtils.ts
-const dependencyPresenceCache = /* @__PURE__ */ new Map();
-let packageDetectionCwd;
-function getDependencyCacheKey(cwd, dependencyName) {
-	return `${cwd}:${dependencyName}`;
-}
-const installedPackageJsonCache = /* @__PURE__ */ new Map();
-function setPackageDetectionCwd(cwd) {
-	packageDetectionCwd = cwd;
-}
-function getPackageDetectionCwd() {
-	return packageDetectionCwd || process.cwd();
-}
-function resolveImportPath(specifier) {
-	const resolved = import.meta.resolve(specifier);
-	if (!resolved.startsWith("file:")) return resolved;
-	const filePath = fileURLToPath(resolved);
-	if (!existsSync(filePath)) {
-		const error = /* @__PURE__ */ new Error(`Cannot find module '${specifier}'`);
-		error.code = "MODULE_NOT_FOUND";
-		throw error;
-	}
-	return filePath;
-}
-const DEFAULT_EXPORT_CONDITIONS = [
-	"browser",
-	"import",
-	"module",
-	"default"
-];
-function resolveExportsEntry(exportsField, conditions = DEFAULT_EXPORT_CONDITIONS) {
-	return resolveExportsEntryWithConditions(exportsField, new Set(conditions));
-}
-function resolveExportsEntryWithConditions(exportsField, conditions) {
-	if (typeof exportsField === "string") return exportsField;
-	if (!exportsField || typeof exportsField !== "object") return void 0;
-	if (Array.isArray(exportsField)) {
-		for (const target of exportsField) {
-			const resolved = resolveExportsEntryWithConditions(target, conditions);
-			if (resolved) return resolved;
-		}
-		return;
-	}
-	const record = exportsField;
-	const rootExport = record["."];
-	if (rootExport) return resolveExportsEntryWithConditions(rootExport, conditions);
-	for (const [condition, value] of Object.entries(record)) {
-		if (condition !== "default" && !conditions.has(condition)) continue;
-		const target = resolveExportsEntryWithConditions(value, conditions);
-		if (target) return target;
-	}
-}
-function substituteExportsWildcard(target, patternMatch) {
-	if (typeof target === "string") return target.split("*").join(patternMatch);
-	if (Array.isArray(target)) return target.map((entry) => substituteExportsWildcard(entry, patternMatch));
-	if (target && typeof target === "object") {
-		const source = target;
-		const out = {};
-		for (const key of Object.keys(source)) out[key] = substituteExportsWildcard(source[key], patternMatch);
-		return out;
-	}
-	return target;
-}
-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) {
-			bestKey = key;
-			bestBaseLength = patternBase.length;
-			bestKeyLength = key.length;
-		}
-	}
-	if (bestKey === void 0) return void 0;
-	const patternTrailer = bestKey.slice(bestKey.indexOf("*") + 1);
-	const patternMatch = subpath.slice(bestBaseLength, subpath.length - patternTrailer.length);
-	return substituteExportsWildcard(record[bestKey], patternMatch);
-}
-function getPackageExportsTarget(pkg, packageName, exportsField) {
-	if (typeof exportsField === "string") return pkg === packageName ? exportsField : void 0;
-	if (!exportsField || typeof exportsField !== "object") return void 0;
-	const record = exportsField;
-	const subpath = pkg === packageName ? "." : `.${pkg.slice(packageName.length)}`;
-	if (subpath !== ".") return matchExportsSubpath(record, subpath);
-	return record["."] ?? (!Object.keys(record).some((key) => key.startsWith(".")) ? record : void 0);
-}
-/**
-* Escaping rules:
-* Convert using the format __${mapping}__, where _ and $ are not allowed in npm package names but can be used in variable names.
-*  @ => 1
-*  / => 2
-*  - => 3
-*  . => 4
-*/
-/**
-* Encodes a package name into a valid file name.
-* @param {string} name - The package name, e.g., "@scope/xx-xx.xx".
-* @returns {string} - The encoded file name.
-*/
-function packageNameEncode(name) {
-	if (typeof name !== "string") throw createModuleFederationError("A string package name is required");
-	return name.replace(/@/g, "_mf_0_").replace(/\//g, "_mf_1_").replace(/-/g, "_mf_2_").replace(/\./g, "_mf_3_");
-}
-/**
-* Decodes an encoded file name back to the original package name.
-* @param {string} encoded - The encoded file name, e.g., "_mf_0_scope_mf_1_xx_mf_2_xx_mf_3_xx".
-* @returns {string} - The decoded package name.
-*/
-function packageNameDecode(encoded) {
-	if (typeof encoded !== "string") throw createModuleFederationError("A string encoded file name is required");
-	return encoded.replace(/_mf_0_/g, "@").replace(/_mf_1_/g, "/").replace(/_mf_2_/g, "-").replace(/_mf_3_/g, ".");
-}
-/**
-* Removes any subpath from an npm package specifier and returns the package name only.
-* @param {string} packageString - The package specifier, e.g., "@scope/pkg/runtime" or "react/jsx-runtime".
-* @returns {string} - The base npm package name.
-*/
-function getPackageName(packageString) {
-	const match = packageString.match(/^(?:@[^/]+\/)?[^/]+/);
-	return match ? match[0] : packageString;
-}
-function getPackageNameFromNodeModulePath(source) {
-	const normalized = source.replace(/\\/g, "/");
-	const nodeModulesIndex = normalized.lastIndexOf("/node_modules/");
-	if (nodeModulesIndex < 0) return;
-	const parts = normalized.slice(nodeModulesIndex + 14).split("/");
-	if (!parts[0]) return;
-	if (parts[0].startsWith("@")) return parts[1] ? `${parts[0]}/${parts[1]}` : void 0;
-	return parts[0];
-}
-function getSharedCacheKeyParts(input) {
-	const scope = (Array.isArray(input.scope) ? input.scope[0] : input.scope) || "default";
-	const id = input.singleton || !input.version ? input.pkg : `${input.pkg}@${input.version}`;
-	return {
-		scope,
-		id,
-		key: `${scope}:${id}`
-	};
-}
-function getSharedCacheDescriptor(pkg, shareItem) {
-	const parts = getSharedCacheKeyParts({
-		pkg,
-		singleton: shareItem.shareConfig.singleton,
-		version: shareItem.version,
-		scope: shareItem.scope
-	});
-	return {
-		canonical: parts.key,
-		...parts.scope === "default" ? { aliases: [parts.id] } : {}
-	};
-}
-const sharedCacheHelperCode = `const __mfGetSharedCacheDescriptor = (pkg, singleton, version, scope) => {
-            const normalizedScope = Array.isArray(scope) ? scope[0] : scope;
-            const scopeName = normalizedScope || "default";
-            const id = singleton || !version ? pkg : pkg + "@" + version;
-            const descriptor = { canonical: scopeName + ":" + id };
-            if (scopeName === "default") descriptor.aliases = [id];
-            return descriptor;
-          };
-          const __mfReadSharedCache = (cache, descriptor) => {
-            const value = cache[descriptor.canonical];
-            if (value !== undefined) return value;
-            const aliases = descriptor.aliases || [];
-            for (const alias of aliases) {
-              if (!Object.prototype.hasOwnProperty.call(cache, alias)) continue;
-              const aliasValue = cache[alias];
-              if (aliasValue !== undefined) {
-                cache[descriptor.canonical] = aliasValue;
-                return aliasValue;
-              }
-            }
-            return undefined;
-          };
-          const __mfSharedCacheListenersKey = Symbol.for("module-federation.shared-cache-listeners");
-          const __mfGetSharedCacheListeners = (cache) => {
-            let listeners = cache[__mfSharedCacheListenersKey];
-            if (listeners === undefined) {
-              listeners = Object.create(null);
-              Object.defineProperty(cache, __mfSharedCacheListenersKey, {
-                value: listeners,
-                enumerable: false,
-                configurable: false,
-                writable: false
-              });
-            }
-            return listeners;
-          };
-          const __mfSubscribeSharedCache = (cache, descriptor, listener) => {
-            const listeners = __mfGetSharedCacheListeners(cache);
-            (listeners[descriptor.canonical] ||= new Set()).add(listener);
-          };
-          const __mfSharedCacheOwnersKey = Symbol.for("module-federation.shared-cache-owners");
-          const __mfGetSharedCacheOwners = (cache) => {
-            let owners = cache[__mfSharedCacheOwnersKey];
-            if (owners === undefined) {
-              owners = Object.create(null);
-              Object.defineProperty(cache, __mfSharedCacheOwnersKey, {
-                value: owners,
-                enumerable: false,
-                configurable: false,
-                writable: false
-              });
-            }
-            return owners;
-          };
-          const __mfReadSharedCacheOwner = (cache, descriptor) =>
-            cache[__mfSharedCacheOwnersKey]?.[descriptor.canonical];
-          const __mfWriteSharedCache = (cache, descriptor, value, owner) => {
-            cache[descriptor.canonical] = value;
-            const aliases = descriptor.aliases || [];
-            for (const alias of aliases) {
-              Object.defineProperty(cache, alias, {
-                value,
-                enumerable: true,
-                configurable: true,
-                writable: true
-              });
-            }
-            const owners = cache[__mfSharedCacheOwnersKey];
-            if (owner === undefined) {
-              if (owners) delete owners[descriptor.canonical];
-            } else {
-              __mfGetSharedCacheOwners(cache)[descriptor.canonical] = owner;
-            }
-            const listeners = cache[__mfSharedCacheListenersKey]?.[descriptor.canonical];
-            if (listeners) {
-              for (const listener of listeners) listener(value);
-            }
-            return value;
-          };
-          const __mfTreeShakingSharedCacheKey = Symbol.for("module-federation.tree-shaking-shared-cache");
-          const __mfGetTreeShakingSharedCache = (cache) => {
-            let metadata = cache[__mfTreeShakingSharedCacheKey];
-            if (metadata === undefined) {
-              metadata = Object.create(null);
-              Object.defineProperty(cache, __mfTreeShakingSharedCacheKey, {
-                value: metadata,
-                enumerable: false,
-                configurable: false,
-                writable: false
-              });
-            }
-            return metadata;
-          };
-          const __mfReadTreeShakingSharedCache = (cache, descriptor, requiredExports) => {
-            const fullModule = __mfReadSharedCache(cache, descriptor);
-            if (fullModule !== undefined) return fullModule;
-            if (!Array.isArray(requiredExports)) return undefined;
-            const metadata = cache[__mfTreeShakingSharedCacheKey];
-            const entries = metadata?.[descriptor.canonical] || [];
-            let compatibleEntry;
-            for (const entry of entries) {
-              if (!requiredExports.every((name) => entry.providedExports.includes(name))) continue;
-              if (!compatibleEntry || entry.providedExports.length < compatibleEntry.providedExports.length) {
-                compatibleEntry = entry;
-              }
-            }
-            return compatibleEntry?.value;
-          };
-          const __mfWriteTreeShakingSharedCache = (cache, descriptor, providedExports, value) => {
-            if (!Array.isArray(providedExports)) return value;
-            const normalizedExports = [...new Set(providedExports)].sort();
-            const metadata = __mfGetTreeShakingSharedCache(cache);
-            const entries = (metadata[descriptor.canonical] ||= []);
-            const existing = entries.find((entry) =>
-              entry.providedExports.length === normalizedExports.length &&
-              entry.providedExports.every((name, index) => name === normalizedExports[index])
-            );
-            if (existing) existing.value = value;
-            else entries.push({ providedExports: normalizedExports, value });
-            return value;
-          };
-          const __mfTreeShakingSelectionCacheKey = Symbol.for("module-federation.tree-shaking-shared-selection-cache");
-          const __mfGetTreeShakingSelectionCache = (cache) => {
-            let selections = cache[__mfTreeShakingSelectionCacheKey];
-            if (selections === undefined) {
-              selections = Object.create(null);
-              Object.defineProperty(cache, __mfTreeShakingSelectionCacheKey, {
-                value: selections,
-                enumerable: false,
-                configurable: false,
-                writable: false
-              });
-            }
-            return selections;
-          };
-          const __mfReadTreeShakingSharedSelection = (cache, descriptor, consumer) => {
-            const fullModule = __mfReadSharedCache(cache, descriptor);
-            if (fullModule !== undefined) return fullModule;
-            return cache[__mfTreeShakingSelectionCacheKey]?.[descriptor.canonical]?.[consumer];
-          };
-          const __mfWriteTreeShakingSharedSelection = (cache, descriptor, consumer, value) => {
-            const selections = __mfGetTreeShakingSelectionCache(cache);
-            const byConsumer = (selections[descriptor.canonical] ||= Object.create(null));
-            byConsumer[consumer] = value;
-            return value;
-          };`;
-function getInstalledPackageJson(pkg, opts) {
-	const cwd = opts?.cwd || getPackageDetectionCwd();
-	const packageName = opts?.packageName || getPackageName(pkg);
-	const cacheKey = `${cwd}\0${pkg}\0${packageName}\0${opts?.fromResolvedEntry ?? ""}`;
-	if (installedPackageJsonCache.has(cacheKey)) return installedPackageJsonCache.get(cacheKey);
-	const result = resolveInstalledPackageJson(pkg, cwd, packageName, opts);
-	installedPackageJsonCache.set(cacheKey, result);
-	return result;
-}
-function resolveInstalledPackageJson(pkg, cwd, packageName, opts) {
-	const tryReadPackageJson = (packageJsonPath) => {
-		if (!existsSync(packageJsonPath)) return void 0;
-		try {
-			return {
-				path: packageJsonPath,
-				dir: path$1.dirname(packageJsonPath),
-				packageJson: JSON.parse(readFileSync(packageJsonPath, "utf-8"))
-			};
-		} catch {
-			return;
-		}
-	};
-	const findPackageInPnpmStore = (startDir) => {
-		let currentDir = startDir;
-		const rootDir = path$1.parse(currentDir).root;
-		while (true) {
-			const pnpmStoreDir = path$1.join(currentDir, "node_modules", ".pnpm");
-			if (existsSync(pnpmStoreDir)) try {
-				for (const entry of readdirSync(pnpmStoreDir, { withFileTypes: true })) {
-					if (!entry.isDirectory()) continue;
-					const candidate = tryReadPackageJson(path$1.join(pnpmStoreDir, entry.name, "node_modules", packageName, "package.json"));
-					if (candidate?.packageJson.name === packageName) return candidate;
-				}
-			} catch {}
-			if (currentDir === rootDir) break;
-			currentDir = path$1.dirname(currentDir);
-		}
-	};
-	try {
-		const projectRequire = createRequire$1(pathToFileURL(path$1.join(cwd, "package.json")));
-		let resolvedPath;
-		if (opts?.fromResolvedEntry) resolvedPath = opts.fromResolvedEntry;
-		else try {
-			resolvedPath = projectRequire.resolve(pkg);
-		} catch {
-			resolvedPath = projectRequire.resolve(packageName);
-		}
-		let currentDir = path$1.dirname(resolvedPath);
-		const rootDir = path$1.parse(currentDir).root;
-		while (true) {
-			const packageJsonPath = path$1.join(currentDir, "package.json");
-			if (existsSync(packageJsonPath)) {
-				const packageJsonContent = readFileSync(packageJsonPath, "utf-8");
-				try {
-					const packageJson = JSON.parse(packageJsonContent);
-					if (packageJson.name === packageName) return {
-						path: packageJsonPath,
-						dir: currentDir,
-						packageJson
-					};
-				} catch (error) {
-					if (!(error instanceof SyntaxError)) throw error;
-				}
-			}
-			if (currentDir === rootDir) break;
-			currentDir = path$1.dirname(currentDir);
-		}
-	} catch {
-		let currentDir = cwd;
-		const rootDir = path$1.parse(currentDir).root;
-		while (true) {
-			const directCandidate = tryReadPackageJson(path$1.join(currentDir, "node_modules", packageName, "package.json"));
-			if (directCandidate?.packageJson.name === packageName) return directCandidate;
-			if (currentDir === rootDir) break;
-			currentDir = path$1.dirname(currentDir);
-		}
-		return findPackageInPnpmStore(cwd);
-	}
-}
-function getInstalledPackageEntry(pkg, opts) {
-	const installed = getInstalledPackageJson(pkg, opts);
-	if (!installed) return void 0;
-	const cwd = opts?.cwd || getPackageDetectionCwd();
-	const packageName = opts?.packageName || getPackageName(pkg);
-	const packageJson = installed.packageJson;
-	if (pkg !== packageName && (opts?.resolveSubpathWithRequire !== false || packageJson.exports === void 0)) try {
-		return createRequire$1(pathToFileURL(path$1.join(cwd, "package.json"))).resolve(pkg);
-	} catch {}
-	const explicitEntry = resolveExportsEntry(getPackageExportsTarget(pkg, packageName, packageJson.exports), opts?.conditions) || (typeof packageJson.module === "string" ? packageJson.module : void 0) || (typeof packageJson.main === "string" ? packageJson.main : void 0) || "index.js";
-	return path$1.join(installed.dir, explicitEntry);
-}
-/**
-* Detect whether the current runtime is Vite 8+ by checking for a Vite version flag
-* on the plugin hook context, with Rolldown metadata kept as a compatibility fallback.
-*/
-function getIsRolldown(ctx) {
-	const viteVersion = ctx?.meta?.viteVersion;
-	const viteMajor = Number(String(viteVersion ?? "").split(".")[0]);
-	return Number.isFinite(viteMajor) && viteMajor >= 8 || !!ctx?.meta?.rolldownVersion;
-}
-/** Walk up from Vite `config.root` (Nuxt may point at `.nuxt` cache dirs). */
-function isNuxtProjectRoot(root) {
-	let dir = root;
-	for (let i = 0; i < 8; i++) {
-		if (hasPackageDependency("nuxt", dir) || hasPackageDependency("nuxt-nightly", dir)) return true;
-		const parent = path$1.dirname(dir);
-		if (parent === dir) break;
-		dir = parent;
-	}
-	return false;
-}
-function hasPackageDependency(dependencyName, cwd = packageDetectionCwd || process.cwd()) {
-	const cacheKey = getDependencyCacheKey(cwd, dependencyName);
-	const cached = dependencyPresenceCache.get(cacheKey);
-	if (cached !== void 0) return cached;
-	try {
-		const packageJson = JSON.parse(readFileSync(path$1.join(cwd, "package.json"), "utf8"));
-		const hasDependency = [
-			packageJson.dependencies,
-			packageJson.devDependencies,
-			packageJson.peerDependencies,
-			packageJson.optionalDependencies
-		].some((deps) => !!deps?.[dependencyName]);
-		dependencyPresenceCache.set(cacheKey, hasDependency);
-		return hasDependency;
-	} catch {
-		dependencyPresenceCache.set(cacheKey, false);
-		return false;
-	}
-}
-//#endregion
 //#region src/utils/normalizeModuleFederationOptions.ts
 const INTERNAL_NAME_PREFIX = "__mfe_internal__";
 function toInternalModuleFederationName(name) {
@@ -1148,6 +665,8 @@ var VirtualModule = class VirtualModule {
 //#region src/utils/ssrCapabilities.ts
 /** A browser-safe generated expression that is true only in Node.js. */
 const SERVER_ENV_GUARD = "import.meta.env.SSR";
+const SSR_ENTRY_LOADER_SPECIFIER = "@module-federation/vite/ssrEntryLoader";
+const SSR_ONLY_RUNTIME_PLUGINS = /* @__PURE__ */ new Set([SSR_ENTRY_LOADER_SPECIFIER]);
 /**
 * Single source of truth for SSR-related feature gates.
 *
@@ -1454,27 +973,40 @@ function loadReactIslandConsumerModule(id) {
 	if (clientRemoteId !== void 0) return generateReactIslandConsumerClient(clientRemoteId);
 }
 //#endregion
+//#region src/virtualModules/virtualModuleScope.ts
+function getVirtualModuleScopeKey(options) {
+	return `${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+//#endregion
 //#region src/virtualModules/virtualExposes.ts
 const EXPOSES_CSS_MAP_PLACEHOLDER = "__MF_EXPOSES_CSS_MAP__";
 function getExposesCssMapPlaceholder() {
 	return EXPOSES_CSS_MAP_PLACEHOLDER;
 }
 function getVirtualExposesId(options) {
-	return `virtual:mf-exposes:${`${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+	return `virtual:mf-exposes:${getVirtualModuleScopeKey(options)}`;
 }
 function generateExposes(options, remoteDependencyMap = {}, command = "build", reactIslandExposes = /* @__PURE__ */ new Set()) {
 	return `
     const cssAssetMap = ${JSON.stringify(options.bundleAllCSS ? EXPOSES_CSS_MAP_PLACEHOLDER : {})};
     const injectedCssHrefs = new Set();
-    let exposeLoadQueue = Promise.resolve();
+    const exposeLoadPromises = new Map();
-    async function importExposedModule(loader) {
-      const currentLoad = exposeLoadQueue.then(loader, loader);
-      exposeLoadQueue = currentLoad.then(
-        () => undefined,
-        () => undefined
-      );
-      return currentLoad;
+    // Shared and remote readiness is handled by explicit Promise barriers below
+    // and by remoteEntry's pendingShareLoads barrier. Keep this map scoped to a
+    // single expose: unrelated exposes must stay independent and load in parallel.
+    function loadExposedModule(exposeKey, loader) {
+      let load = exposeLoadPromises.get(exposeKey);
+      if (!load) {
+        load = Promise.resolve()
+          .then(loader)
+          .catch((error) => {
+            exposeLoadPromises.delete(exposeKey);
+            throw error;
+          });
+        exposeLoadPromises.set(exposeKey, load);
+      }
+      return load;
     }
     async function injectCssAssets(exposeKey) {
@@ -1529,7 +1061,8 @@ function generateExposes(options, remoteDependencyMap = {}, command = "build", r
         ${JSON.stringify(key)}: async () => {
           await injectCssAssets(${JSON.stringify(key)})
           await Promise.all([${remoteDependencyPreloads}])
-          const importModule = await importExposedModule(
+          const importModule = await loadExposedModule(
+            ${JSON.stringify(key)},
             () => import(${JSON.stringify(options.exposes[key].import)})
           )
           const dependencyPending = importModule && importModule.__mf_remote_dependency_pending;
@@ -2133,6 +1666,7 @@ function getPackageEsmEntryPath(pkg) {
 		resolveSubpathWithRequire: false
 	}) || resolvePackageEntryFromProjectRoot(pkg);
 }
+const packageNamedExportsCache = /* @__PURE__ */ new Map();
 const DEFAULT_SHARED_EXPORT_CONDITIONS = [
 	"browser",
 	"import",
@@ -2619,10 +2153,13 @@ function getPackageNamedExports(pkg, exportConditions = DEFAULT_SHARED_EXPORT_CO
 		resolveSubpathWithRequire: false
 	});
 	if (esmEntryPath) {
+		const cacheKey = !isWorkspaceFilePath(esmEntryPath) ? `${getPackageDetectionCwd()}\0${esmEntryPath}\0${exportConditions.join("\0")}` : void 0;
+		const cached = cacheKey ? packageNamedExportsCache.get(cacheKey) : void 0;
+		if (cached) return cached.value;
 		const inspection = inspectSharedExportsFromFile(esmEntryPath, exportConditions);
-		if (!inspection || inspection.commonJs || path$1.extname(esmEntryPath) === ".cjs") return getRequiredNamedExports(esmEntryPath);
-		if (inspection.namedExports !== void 0) return inspection.namedExports;
-		return;
+		const value = !inspection || inspection.commonJs || path$1.extname(esmEntryPath) === ".cjs" ? getRequiredNamedExports(esmEntryPath) : inspection.namedExports;
+		if (cacheKey) packageNamedExportsCache.set(cacheKey, { value });
+		return value;
 	}
 	return getRequiredNamedExports(pkg);
 }
@@ -2770,10 +2307,27 @@ function tryResolveImportFromPackageRoot(pkg, root) {
 		return;
 	}
 }
+/**
+* Resolution walks from the project root up to the filesystem root, probing
+* every level, and the shared-module resolver asks for the same few packages
+* tens of thousands of times on a cold dev start. The detection cwd is part of
+* the key because `setPackageDetectionCwd` can move it between config hooks.
+*/
+const concreteSharedImportSourceCache = /* @__PURE__ */ new Map();
+function resetConcreteSharedImportSourceCache() {
+	concreteSharedImportSourceCache.clear();
+}
 function getConcreteSharedImportSource(pkg, shareItem) {
 	const configuredImport = shareItem?.shareConfig.import;
 	if (typeof configuredImport === "string") return configuredImport;
 	const projectRoot = getPackageDetectionCwd();
+	const cacheKey = JSON.stringify([projectRoot, pkg]);
+	if (concreteSharedImportSourceCache.has(cacheKey)) return concreteSharedImportSourceCache.get(cacheKey);
+	const resolved = resolveConcreteSharedImportSource(pkg, projectRoot);
+	concreteSharedImportSourceCache.set(cacheKey, resolved);
+	return resolved;
+}
+function resolveConcreteSharedImportSource(pkg, projectRoot) {
 	if (tryResolveImportFromPackageRoot(pkg, projectRoot)) return;
 	let currentDir = path$1.dirname(projectRoot);
 	while (currentDir !== path$1.dirname(currentDir)) {
@@ -3348,6 +2902,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 //#region src/virtualModules/virtualRemoteEntry.ts
 let usedShares = /* @__PURE__ */ new Set();
 const usedSharesByOptions = /* @__PURE__ */ new WeakMap();
+const materializedSharesByOptions = /* @__PURE__ */ new WeakMap();
 function getScopedUsedShares(options) {
 	let scoped = usedSharesByOptions.get(options);
 	if (!scoped) {
@@ -3363,6 +2918,18 @@ function getUsedShares(options) {
 function addUsedShares(pkg, options) {
 	usedShares.add(pkg);
 	if (options) getScopedUsedShares(options).add(pkg);
+	if (options) {
+		let scoped = materializedSharesByOptions.get(options);
+		if (!scoped) {
+			scoped = /* @__PURE__ */ new Set();
+			materializedSharesByOptions.set(options, scoped);
+		}
+		scoped.add(pkg);
+	}
+}
+function addConfiguredShare(pkg, options) {
+	usedShares.add(pkg);
+	if (options) getScopedUsedShares(options).add(pkg);
 }
 const LOCAL_SHARED_IMPORT_MAP_ID = "virtual:mf-localSharedImportMap";
 const localOwnerIds = /* @__PURE__ */ new WeakMap();
@@ -3409,6 +2976,7 @@ function generateLocalSharedImportMap(options) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const useDirectReactImport = shouldUseDirectReactImport();
 	const orderedShares = getOrderedUsedShares(options);
+	const sharesToMaterialize = new Set(getMaterializedShares(options));
 	return `
     import {loadShare} from "@module-federation/runtime";
     ${orderedShares.map((pkg, index) => {
@@ -3429,7 +2997,7 @@ function generateLocalSharedImportMap(options) {
 	}).join(",")}
     }
       const usedShared = {
-      ${getOrderedUsedShares(options).map((key) => {
+      ${orderedShares.map((key) => {
 		const shareItem = getNormalizeShareItem(key, resolvedOptions);
 		if (!shareItem) return null;
 		const detectedNamedExports = getSharedNamedExports(key, shareItem);
@@ -3447,6 +3015,7 @@ function generateLocalSharedImportMap(options) {
             version: ${JSON.stringify(shareItem.version)},
             scope: [${JSON.stringify(shareItem.scope)}],
             loaded: false,
+            materialize: ${sharesToMaterialize.has(key)},
             eager: ${Boolean(shareItem.shareConfig.eager)},
             from: ${JSON.stringify(resolvedOptions.name)},
             canLiveRebind: ${canLiveRebind},
@@ -3517,7 +3086,7 @@ function generateLocalSharedImportMap(options) {
 function getOrderedUsedShares(options) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const shares = new Set(getUsedShares(options));
-	Object.keys(resolvedOptions.shared).forEach((pkg) => {
+	Object.keys(resolvedOptions.shared ?? {}).forEach((pkg) => {
 		if (!pkg.endsWith("/")) shares.add(pkg);
 	});
 	return orderSharedDependenciesFirst(Array.from(shares).sort((a, b) => {
@@ -3525,6 +3094,69 @@ function getOrderedUsedShares(options) {
 		return priority(a) - priority(b) || a.localeCompare(b);
 	}));
 }
+function getMaterializedShares(options) {
+	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
+	const scopedRegistrations = options ? usedSharesByOptions.get(options) : void 0;
+	const shares = new Set(options && scopedRegistrations?.size ? materializedSharesByOptions.get(options) ?? [] : usedShares);
+	for (const [pkg, share] of Object.entries(resolvedOptions.shared ?? {})) if (!pkg.endsWith("/") && share.shareConfig?.eager) shares.add(pkg);
+	const configured = /* @__PURE__ */ new Map();
+	for (const pkg of getOrderedUsedShares(options)) {
+		const packageName = getPackageName(pkg);
+		if (!configured.has(packageName) || pkg === packageName) configured.set(packageName, pkg);
+	}
+	const pending = [...shares];
+	while (pending.length) {
+		const pkg = pending.pop();
+		const packageName = getPackageName(pkg);
+		const packageJson = getInstalledPackageJson(pkg)?.packageJson ?? (pkg !== packageName ? getInstalledPackageJson(packageName)?.packageJson : void 0);
+		const dependencies = {
+			...packageJson?.dependencies || {},
+			...packageJson?.peerDependencies || {},
+			...packageJson?.optionalDependencies || {}
+		};
+		for (const dependency of Object.keys(dependencies)) {
+			const sharedDependency = configured.get(dependency);
+			if (sharedDependency && !shares.has(sharedDependency)) {
+				shares.add(sharedDependency);
+				pending.push(sharedDependency);
+			}
+		}
+	}
+	if (hasPackageDependency("vinext")) shares.delete("react");
+	return orderSharedDependenciesFirst([...shares].sort((a, b) => {
+		const priority = (pkg) => pkg === "react" ? 0 : pkg === "react-dom" ? 1 : pkg.startsWith("react/") ? 2 : 3;
+		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();
+	const roots = /* @__PURE__ */ new Map();
+	const subpaths = /* @__PURE__ */ new Map();
+	for (const pkg of ordered) {
+		const packageName = getPackageName(pkg);
+		if (pkg === packageName) roots.set(packageName, pkg);
+		else subpaths.set(packageName, [...subpaths.get(packageName) ?? [], pkg]);
+	}
+	for (const pkg of ordered) {
+		const packageName = getPackageName(pkg);
+		const packageJson = getInstalledPackageJson(pkg)?.packageJson ?? (pkg !== packageName ? getInstalledPackageJson(packageName)?.packageJson : void 0);
+		const dependencies = {
+			...packageJson?.dependencies || {},
+			...packageJson?.peerDependencies || {},
+			...packageJson?.optionalDependencies || {}
+		};
+		const prerequisites = Object.keys(dependencies).map((dependency) => roots.get(dependency)).filter((dependency) => Boolean(dependency));
+		if (pkg !== packageName && (packageName === "react" || packageName === "react-dom")) {
+			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));
+	}
+	const batches = [];
+	for (const pkg of ordered) (batches[levels.get(pkg) ?? 0] ??= []).push(pkg);
+	return batches.filter(Boolean);
+}
 function orderSharedDependenciesFirst(sharedPackages) {
 	const sharedKeyByPackageName = /* @__PURE__ */ new Map();
 	const subpathKeysByPackageName = /* @__PURE__ */ new Map();
@@ -3575,7 +3207,7 @@ function orderSharedDependenciesFirst(sharedPackages) {
 }
 function getShareItemForPreload(pkg, options = getNormalizeModuleFederationOptions()) {
 	const shared = options.shared;
-	const wildcardKey = `${pkg.startsWith("@") ? pkg.split("/").slice(0, 2).join("/") : pkg.split("/")[0]}/`;
+	const wildcardKey = `${getPackageName(pkg)}/`;
 	if (isExplicitSharedKey(pkg, options)) return shared[pkg];
 	if (isExplicitSharedKey(wildcardKey, options)) return shared[wildcardKey];
 }
@@ -3750,34 +3382,24 @@ const externalSharedProviderSelectionHelperCode = `const __mfSelectExternalShare
             ) return undefined;
             return { provider, scopeRootProvider };
           };`;
-function generateRuntimeSharedCacheSeedCode(shareStrategy) {
-	const seedOrder = getOrderedUsedShares();
+function generateRuntimeSharedCacheSeedCode(shareStrategy, options) {
+	const seedBatches = getShareBatches(options, false);
 	return `
-    const __mfSeedOrder = ${JSON.stringify(seedOrder)};
-    const __mfSeedKeys = __mfSeedOrder.filter((pkg) => usedShared[pkg] !== undefined);
-    const __mfSeedPackageName = (pkg) => pkg.startsWith('@')
-      ? pkg.split('/').slice(0, 2).join('/')
-      : pkg.split('/')[0];
-    for (const pkg of Object.keys(usedShared)) {
-      if (__mfSeedKeys.includes(pkg)) continue;
-      const packageName = __mfSeedPackageName(pkg);
-      const rootIndex = __mfSeedKeys.indexOf(packageName);
-      if (rootIndex === -1) {
-        __mfSeedKeys.push(pkg);
-        continue;
-      }
-      let insertIndex = rootIndex;
-      while (
-        insertIndex > 0 &&
-        __mfSeedPackageName(__mfSeedKeys[insertIndex - 1]) === packageName &&
-        __mfSeedKeys[insertIndex - 1] !== packageName
-      ) {
-        insertIndex--;
-      }
-      __mfSeedKeys.splice(insertIndex, 0, pkg);
-    }
+    const __mfSeedOrder = ${JSON.stringify(seedBatches.flat())};
+    const __mfSeedBatches = ${JSON.stringify(seedBatches)};
+    const __mfSeedKeys = __mfSeedOrder.filter((pkg) => usedShared[pkg] && usedShared[pkg].materialize !== false);
+    __mfModuleCache.providerInit ||= new Map();
+    const __mfInitializeProviderOnce = (key, initialize) => {
+      const existing = __mfModuleCache.providerInit.get(key);
+      if (existing) return existing;
+      const pending = Promise.resolve().then(initialize);
+      __mfModuleCache.providerInit.set(key, pending);
+      pending.catch(() => __mfModuleCache.providerInit.delete(key));
+      return pending;
+    };
     var __mfSeedLocalShared = async (seedKeys) => {
-      for (const pkg of seedKeys) {
+      const requested = new Set(seedKeys);
+      for (const batch of __mfSeedBatches) await Promise.all(batch.filter((pkg) => requested.has(pkg)).map(async (pkg) => {
         const share = usedShared[pkg];
         const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
         if (
@@ -3785,7 +3407,7 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy) {
           Boolean(share.treeShaking) ||
           __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined
         ) {
-          continue;
+          return;
         }
         const singletonCacheDescriptor = __mfGetSharedCacheDescriptor(pkg, true, share.version, share.scope);
         const singletonModule = __mfReadSharedCache(__mfModuleCache.share, singletonCacheDescriptor);
@@ -3796,11 +3418,20 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy) {
             singletonModule,
             __mfReadSharedCacheOwner(__mfModuleCache.share, singletonCacheDescriptor)
           );
-          continue;
+          return;
         }
-        const factory = await share.get();
-        const mod = typeof factory === "function" ? factory() : factory;
-        const resolved = await Promise.resolve(mod);
+        const pendingExternalProvider = typeof __mfGetPendingExternalSharedProvider === 'function'
+          ? __mfGetPendingExternalSharedProvider(pkg, share)
+          : undefined;
+        if (pendingExternalProvider && !pendingExternalProvider.lib && !pendingExternalProvider.loaded) {
+          return;
+        }
+        const providerKey = cacheDescriptor.canonical;
+        const resolved = await __mfInitializeProviderOnce(providerKey, async () => {
+          const factory = await share.get();
+          const mod = typeof factory === "function" ? factory() : factory;
+          return Promise.resolve(mod);
+        });
         ${normalizeRuntimeShareCode}
         const normalizedModule = __mfNormalizeRuntimeShare(resolved);
         const exportModule = normalizedModule === resolved ? {...resolved} : normalizedModule;
@@ -3809,7 +3440,7 @@ function generateRuntimeSharedCacheSeedCode(shareStrategy) {
           enumerable: false
         });
         __mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, exportModule, mfName);
-      }
+      }));
     };
     const __mfIsRuntimeOnlySharePending = (pkg) => {
       const share = usedShared[pkg];
@@ -3875,7 +3506,7 @@ function getBrowserImportPath(importPath) {
 }
 function getHostAutoInitSharedSeedItems(options) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
-	return getOrderedUsedShares(options).map((pkg) => ({
+	return getMaterializedShares(options).map((pkg) => ({
 		pkg,
 		shareItem: getShareItemForPreload(pkg, resolvedOptions)
 	})).filter(({ shareItem }) => shareItem?.shareConfig?.import === false).sort((a, b) => {
@@ -3895,12 +3526,10 @@ function generateHostAutoInitSharedCacheSeedCode(command = "build", options) {
 }
 const REMOTE_ENTRY_ID = "virtual:mf-REMOTE_ENTRY_ID";
 function getRemoteEntryId(options) {
-	const scopedKey = `${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_");
-	return `${REMOTE_ENTRY_ID}:${scopedKey}`;
+	return `${REMOTE_ENTRY_ID}:${getVirtualModuleScopeKey(options)}`;
 }
-const SSR_ONLY_PLUGIN_SPECIFIERS = /* @__PURE__ */ new Set(["@module-federation/vite/ssrEntryLoader"]);
-const isSsrOnlyPlugin = (importStatement) => [...SSR_ONLY_PLUGIN_SPECIFIERS].some((s) => importStatement.includes(s));
-const getSsrOnlyPluginSpecifier = (importStatement) => [...SSR_ONLY_PLUGIN_SPECIFIERS].find((s) => importStatement.includes(s));
+const isSsrOnlyPlugin = (importStatement) => [...SSR_ONLY_RUNTIME_PLUGINS].some((s) => importStatement.includes(s));
+const getSsrOnlyPluginSpecifier = (importStatement) => [...SSR_ONLY_RUNTIME_PLUGINS].find((s) => importStatement.includes(s));
 function generateTreeShakingSharedResolutionCode(enabled) {
 	if (!enabled) return "const __mfResolveTreeShakingShared = async () => {};";
 	return `
@@ -4064,6 +3693,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
 	const needsSharedProviderSelectionHelper = Object.keys(options.shared ?? {}).length > 0;
 	const hasTreeShakingShared = Object.values(options.shared ?? {}).some((share) => !!share?.shareConfig.treeShaking);
 	const hasMultipleShareScopes = Array.isArray(options.shareScope);
+	const materializedShareBatches = JSON.stringify(getShareBatches(options, false));
 	const runtimeImports = [
 		"init as runtimeInit",
 		"loadRemote",
@@ -4117,14 +3747,16 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   import {${runtimeImports}} from "@module-federation/runtime";
   ${runtimeHelperImports.length ? `import {${runtimeHelperImports.join(", ")}} from "@module-federation/runtime/helpers";` : ""}
   ${pluginImportNames.filter((item) => !isSsrOnlyPlugin(item[1])).map((item) => item[1]).join("\n")}
-  ${command === "build" ? getRuntimeInitResolveBootstrapCode(false, options ? getRuntimeInitStatusImportId(options) : void 0) : getRuntimeInitBootstrapCode(false, options ? getRuntimeInitStatusImportId(options) : void 0) + "\n  const { initResolve } = globalThis[globalKey];"}
+  ${command === "build" ? getRuntimeInitResolveBootstrapCode(false, getRuntimeInitStatusImportId(options)) : getRuntimeInitBootstrapCode(false, getRuntimeInitStatusImportId(options)) + "\n  const { initResolve } = globalThis[globalKey];"}
   ${getRuntimeModuleCacheBootstrapCode()}
   const initTokens = {}
   const shareScopeNames = Array.isArray(${JSON.stringify(options.shareScope)}) ? ${JSON.stringify(options.shareScope)} : [${JSON.stringify(options.shareScope)}]
   const shareScopeName = ${JSON.stringify(hasMultipleShareScopes ? options.shareScope[0] : options.shareScope)}
   const mfName = ${JSON.stringify(options.name)}
+  const __mfMaterializedShareBatches = ${materializedShareBatches}
   let localSharedImportMapPromise
   let exposesMapPromise
+  let __mfLateBridgeShared
   const shouldRetrySharedInitError = ${command !== "build"} && ((error) => {
     const message = String((error && error.message) || error || '');
     return message.includes('Importing a module script failed') ||
@@ -4195,6 +3827,40 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       instance?.options?.name !== mfName &&
       ${hasMultipleShareScopes ? "shareScopeNames.some((scopeName) => instance?.shareScopeMap?.[scopeName] === getShareScope(scopeName))" : `instance?.shareScopeMap?.['${options.shareScope}'] === shared`}
     );
+    const __mfRuntimeShareScopes = Object.create(null);
+    const __mfCloneShareScope = (hostScope) => {
+      const runtimeScope = Object.create(null);
+      for (const [pkg, versions] of Object.entries(hostScope || {})) {
+        runtimeScope[pkg] = Object.assign(Object.create(null), versions);
+      }
+      return runtimeScope;
+    };
+    const __mfGetRuntimeShareScope = (scopeName, hostScope) => {
+      const isWebpackScope = !scopeRoot && Object.values(hostScope || {}).some((versions) =>
+        Object.values(versions || {}).some(isWebpackProvider)
+      );
+      const runtimeScope = isWebpackScope ? __mfCloneShareScope(hostScope) : hostScope;
+      __mfRuntimeShareScopes[scopeName] = {
+        host: hostScope,
+        runtime: runtimeScope,
+        isWebpackScope
+      };
+      return runtimeScope;
+    };
+    const __mfRestoreForeignSharedProviders = () => {
+      const webpackScopes = Object.values(__mfRuntimeShareScopes).filter(
+        ({ isWebpackScope }) => isWebpackScope
+      );
+      if (webpackScopes.length === 0) return;
+      for (const { host, runtime } of webpackScopes) {
+        for (const [pkg, versions] of Object.entries(host || {})) {
+          const runtimeVersions = runtime[pkg] ||= Object.create(null);
+          for (const [version, provider] of Object.entries(versions || {})) {
+            runtimeVersions[version] = provider;
+          }
+        }
+      }
+    };
     const initialShared = Object.create(null);
     ${hasMultipleShareScopes ? `for (const scopeName of shareScopeNames) {
       for (const [pkg, versions] of Object.entries(getShareScope(scopeName))) {
@@ -4213,6 +3879,41 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       }
     }`}
     const {usedShared, usedRemotes} = await getLocalSharedImportMap()
+    function isWebpackProvider(provider) {
+      if (typeof provider?.get !== 'function') return false;
+      const source = Function.prototype.toString.call(provider.get);
+      return source.includes('__webpack_require__');
+    }
+    const __mfUsesWebpackShareScope = Object.values(initialShared).some((versions) =>
+      Object.values(versions || {}).some(isWebpackProvider)
+    );
+    const __mfGetSharePackageName = (pkg) => {
+      const parts = pkg.split('/');
+      return pkg.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0];
+    };
+    const __mfGetPendingExternalSharedProvider = (pkg, share, versionMap) => {
+      if (typeof __mfSelectExternalSharedProvider !== 'function') return undefined;
+      const packageName = __mfGetSharePackageName(pkg);
+      const candidates = packageName === pkg
+        ? [[pkg, share]]
+        : [[pkg, share], [packageName, usedShared[packageName]]];
+      for (const [candidatePkg, candidateShare] of candidates) {
+        if (!candidateShare) continue;
+        const candidateVersionMap = versionMap
+          ? (candidatePkg === pkg ? versionMap : initialShared[candidatePkg])
+          : ${hasMultipleShareScopes ? "getShareVersions(candidatePkg, candidateShare)" : "shared[candidatePkg]"};
+        const provider = __mfSelectExternalSharedProvider(
+          candidateVersionMap,
+          candidatePkg,
+          candidateShare,
+          '${options.shareStrategy}'
+        );
+        if (provider && isWebpackProvider(provider) && !provider.lib && !provider.loaded) {
+          return provider;
+        }
+      }
+      return undefined;
+    };
     // handling circular init calls before an external provider can re-enter this container
     ${hasMultipleShareScopes ? `const shareScopeNamesToInitialize = [];
     for (const shareScopeName of shareScopeNames) {
@@ -4249,8 +3950,14 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
     });
     ${hasMultipleShareScopes ? `for (const shareScopeName of shareScopeNamesToInitialize) {
       const scopeShare = getShareScope(shareScopeName);
-      initRes.initShareScopeMap(shareScopeName, scopeShare);
-    }` : `initRes.initShareScopeMap('${options.shareScope}', shared);`}
+      initRes.initShareScopeMap(
+        shareScopeName,
+        __mfGetRuntimeShareScope(shareScopeName, scopeShare)
+      );
+    }` : `initRes.initShareScopeMap(
+      '${options.shareScope}',
+      __mfGetRuntimeShareScope('${options.shareScope}', shared)
+    );`}
     function __mfSharePinLifecyclePlugin() {
       return {
         name: "vite-share-pin-lifecycle-plugin",
@@ -4522,6 +4229,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
           // this container's outer initScope. Materialized providers are already active,
           // so resolve them directly and keep remote initialization on the guarded path.
           let directFactory = provider.lib;
+          if (!directFactory && isWebpackProvider(provider)) return;
           if (!directFactory && provider.loading) directFactory = await provider.loading;
           if (!directFactory && provider.loaded && typeof provider.get === 'function') {
             directFactory = await provider.get();
@@ -4546,13 +4254,10 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
         const resolved = loadedShare?.resolved;
         if (resolved === undefined) return;
         if (__mfReadSharedCache(__mfModuleCache.share, usedCacheDescriptor) !== undefined) return;
-        ${options.shareStrategy === "loaded-first" ? `if (
-          actualSelection.registered &&
-          liveVersionMap?.[actualSelection.version] !== actualProvider
-        ) return;` : `if (
+        if (
           actualSelection.registered &&
           liveVersionMap?.[actualSelection.version] !== actualProvider
-        ) return;`}
+        ) return;
         __mfWriteSharedCache(
           __mfModuleCache.share,
           usedCacheDescriptor,
@@ -4572,6 +4277,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       expectedSelection
     ) => {
       try {
+        if (__mfGetPendingExternalSharedProvider(pkg, usedShare)) return;
         const usedCacheDescriptor = __mfGetSharedCacheDescriptor(pkg, usedShare.shareConfig?.singleton, usedShare.version, usedShare.scope);
         const cachedShare = __mfReadSharedCache(__mfModuleCache.share, usedCacheDescriptor);
         const cachedShareOwner = __mfReadSharedCacheOwner(__mfModuleCache.share, usedCacheDescriptor);
@@ -4619,6 +4325,12 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
           !scopeRootProvider &&
           !__mfMatchesSharedProvider(liveProvider, provider)
         ) return;
+        if (
+          !selectedLocalProvider &&
+          isWebpackProvider(provider) &&
+          !provider.lib &&
+          !provider.loaded
+        ) return;
         const loadedShare = await __mfLoadPinnedRuntimeShare(
           pkg,
           usedShare.shareConfig,
@@ -4666,10 +4378,11 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
         console.error('[Module Federation] Failed to bridge external shared module "' + pkg + '"', e)
       }
     };
-    for (const [pkg, usedShare] of Object.entries(usedShared)) {
-      if (usedShare.treeShaking) continue;
+    for (const batch of __mfMaterializedShareBatches) await Promise.all(batch.map(async (pkg) => {
+      const usedShare = usedShared[pkg];
+      if (!usedShare || usedShare.materialize === false || usedShare.treeShaking) return;
       await __mfBridgeMaterializedProvider(pkg, usedShare, initialShared[pkg]);
-    }
+    }));
     for (const [pkg, share] of Object.entries(usedShared)) {
       if (share.treeShaking) continue;
       const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
@@ -4685,19 +4398,27 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
         );
       }
     }
-    ${generateRuntimeSharedCacheSeedCode(options.shareStrategy)}
+    ${generateRuntimeSharedCacheSeedCode(options.shareStrategy, options)}
     ${initializeSharingCode}
+    __mfRestoreForeignSharedProviders();
     // Calling provider.get() marks a provider as loaded. Wait until the Runtime has
     // finalized normal same-version precedence before materializing an external share.
-    for (const [pkg, usedShare] of Object.entries(usedShared)) {
-      if (usedShare.treeShaking) continue;
-      await __mfBridgeExternalSharedProvider(
-        pkg,
-        usedShare,
-        ${hasMultipleShareScopes ? "getShareVersions(pkg, usedShare)" : "shared[pkg]"},
-        initialShared[pkg],
-        undefined
-      );
+    const __mfBridgeSharedProviders = async () => {
+      for (const batch of __mfMaterializedShareBatches) await Promise.all(batch.map(async (pkg) => {
+        const usedShare = usedShared[pkg];
+        if (!usedShare || usedShare.materialize === false || usedShare.treeShaking) return;
+        await __mfBridgeExternalSharedProvider(
+          pkg,
+          usedShare,
+          ${hasMultipleShareScopes ? "getShareVersions(pkg, usedShare)" : "shared[pkg]"},
+          initialShared[pkg],
+          undefined
+        );
+      }));
+    };
+    await __mfBridgeSharedProviders();
+    if (__mfUsesWebpackShareScope) {
+      __mfLateBridgeShared = __mfBridgeSharedProviders;
     }
     try {
       const allInstances = globalThis.__FEDERATION__?.__SHARE__;
@@ -4732,7 +4453,9 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
           }
         }
       }
-      for (const [pkg, versionMap] of Object.entries(globalVersionsByPackage)) {
+      for (const batch of __mfMaterializedShareBatches) await Promise.all(batch.map(async (pkg) => {
+        const versionMap = globalVersionsByPackage[pkg];
+        if (!versionMap) return;
         await __mfBridgeExternalSharedProvider(
           pkg,
           usedShared[pkg],
@@ -4740,7 +4463,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
           initialShared[pkg],
           bridgeSelections.get(pkg)
         );
-      }
+      }));
     } catch (e) {
       console.error('[Module Federation] Failed to bridge external shared modules', e)
     }
@@ -4751,6 +4474,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
         ? __mfReadTreeShakingSharedSelection(__mfModuleCache.share, cacheDescriptor, mfName)
         : __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor);
       if (share.shareConfig?.import !== false || cachedShare !== undefined) return;
+      if (__mfGetPendingExternalSharedProvider(pkg, share, initialShared[pkg])) return;
       ${normalizeRuntimeShareCode}
       const versionMap = ${hasMultipleShareScopes ? "getShareVersions(pkg, share)" : "shared?.[pkg]"};
       const provider = __mfSelectSharedProvider(
@@ -4813,18 +4537,30 @@ 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.
+    const __mfReadyDeferredSeedKeys = [];
     for (const pkg of __mfDeferredSeedKeys) {
       const share = usedShared[pkg];
       if (__mfIsRuntimeOnlySharePending(pkg)) {
-        if (share.treeShaking) {
-          await __mfResolveTreeShakingShared(pkg, share);
-        } else if (share.shareConfig?.import === false) {
-          await __mfResolveImportFalseShared(pkg, share);
+        try {
+          if (share.treeShaking) {
+            await __mfResolveTreeShakingShared(pkg, share);
+          } else if (share.shareConfig?.import === false) {
+            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.
+          console.error(
+            \`[Module Federation] Failed to resolve runtime-only shared module "\${pkg}"\`,
+            err
+          );
+          break;
         }
       }
       if (__mfIsRuntimeOnlySharePending(pkg)) break;
-      await __mfSeedLocalShared([pkg]);
+      __mfReadyDeferredSeedKeys.push(pkg);
     }
+    await __mfSeedLocalShared(__mfReadyDeferredSeedKeys);
     initResolve(initRes)
     return initRes
   }
@@ -4832,6 +4568,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   async function getExposes(moduleName) {
     const exposesMap = await getExposesMap()
     if (!(moduleName in exposesMap)) throw new Error(\`[Module Federation] Module \${moduleName} does not exist in container.\`)
+    if (__mfLateBridgeShared) await __mfLateBridgeShared()
     if (__mfModuleCache.pendingShareLoads) {
       await Promise.all(__mfModuleCache.pendingShareLoads)
     }
@@ -4886,11 +4623,10 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
           const {usedShared} = await import("${getLocalSharedImportMapPath(options)}");
           ${normalizeRuntimeShareCode}
           ${shouldPreloadShares ? `
-          const __mfHostInitShareOrder = ${hostInitShareOrder}
-            .concat(Object.keys(usedShared).filter((pkg) => !${hostInitShareOrder}.includes(pkg)));
+          const __mfHostInitShareOrder = ${hostInitShareOrder};
           for (const pkg of __mfHostInitShareOrder) {
             const share = usedShared[pkg];
-            if (!share) continue;
+            if (!share || share.materialize === false) continue;
             // remoteEntry.init resolves tree-enabled shares into the
             // coverage-aware cache. Never republish that selected partial under
             // a generic full-module key here.
@@ -4914,8 +4650,6 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
             });
           }
           ` : ""}
-          const __mfRemotePreloads = [];
-          await Promise.all(__mfRemotePreloads);
           return runtime;
         })();
       }
@@ -4937,9 +4671,6 @@ function refreshHostAutoInit(options) {
 		writeHostAutoInit(state.remoteEntryId, state.command, options);
 	} catch {}
 }
-function getHostAutoInitImportId(options) {
-	return getHostAutoInitState(options).module.getImportId();
-}
 function getHostAutoInitPath(options) {
 	return getHostAutoInitState(options).module.getImportId();
 }
@@ -5493,6 +5224,10 @@ const __mfCurrentScript = document.currentScript;
 	function normalizeModuleId(id) {
 		return normalizePathForImport(id.split("?")[0]);
 	}
+	function isReactRouterClientEntry(id) {
+		const normalized = normalizeModuleId(decodeViteId(id).replace(/^\0+/, ""));
+		return /(?:^|\/)entry\.client\.(?:[cm]?[jt]sx?)$/.test(normalized);
+	}
 	function resolveProjectId(id) {
 		if (id.startsWith("\0") || id.startsWith("virtual:")) return normalizeModuleId(id);
 		return normalizeModuleId(path$1.isAbsolute(id) ? id : path$1.resolve(viteConfig.root, id));
@@ -5753,10 +5488,11 @@ const __mfCurrentScript = document.currentScript;
 				const injection = `await import(${JSON.stringify(getEntryPath())}).then(({ initHost }) => initHost());\n      `;
 				return mapCodeToCodeWithSourcemap(code.replace("vueApp.mount(vueAppRootContainer);", `${injection}vueApp.mount(vueAppRootContainer);`));
 			}
-			const isHydrationEntryFallback = inject === "entry" && entryFiles.length === 0 && (!htmlFilePath || !fs$2.existsSync(htmlFilePath)) && !clientInjected && !isFederationInternalVirtualId(id) && !id.includes("node_modules") && (id.startsWith("\0") || /\.(js|ts|mjs|vue|jsx|tsx)(\?|$)/.test(id)) && (/hydrateRoot|createRoot|ReactDOM\.render/.test(code) || /\.mount\s*\(\s*['"#]/.test(code) || /\.mount\s*\(/.test(code) && /createSSRApp|createApp/.test(code));
+			const isReactRouterEntry = isReactRouterClientEntry(id);
+			const isHydrationEntryFallback = inject === "entry" && entryFiles.length === 0 && (!htmlFilePath || !fs$2.existsSync(htmlFilePath)) && !clientInjected && !isFederationInternalVirtualId(id) && !id.includes("node_modules") && (!code.includes("HydratedRouter") || isReactRouterEntry) && (id.startsWith("\0") || /\.(js|ts|mjs|vue|jsx|tsx)(\?|$)/.test(id)) && (/hydrateRoot|createRoot|ReactDOM\.render/.test(code) || /\.mount\s*\(\s*['"#]/.test(code) || /\.mount\s*\(/.test(code) && /createSSRApp|createApp/.test(code));
 			const isNuxtEntryAsyncModule = /(?:^|\/)nuxt\/dist\/app\/entry\.async\.js(?:\?|$)/.test(id) && code.includes("entry();");
 			const isNuxtClientEntryFallback = _command === "serve" && inject === "entry" && (!htmlFilePath || !fs$2.existsSync(htmlFilePath)) && !clientInjected && !hasEntryBootstrapParam(id) && !id.includes("node_modules/.vite") && isNuxtEntryAsyncModule && !entryFiles.some((file) => projectId === file);
-			if (!(_command === "serve" && isNuxtEntryAsyncModule) && (injectedTransformIds.has(projectId) || injectEntry() && entryFiles.some((file) => projectId === file) || _command === "serve" && inject === "html" && !isVinext && !clientInjected && !skipHtmlDevFallback && !id.startsWith("\0") && !id.includes("node_modules") && /\.(js|ts|mjs|vue|jsx|tsx)(\?|$)/.test(id) || isHydrationEntryFallback || isNuxtClientEntryFallback)) {
+			if (!(_command === "serve" && isNuxtEntryAsyncModule) && (injectedTransformIds.has(projectId) || injectEntry() && entryFiles.some((file) => projectId === file) || _command === "serve" && inject === "html" && !isVinext && !clientInjected && !skipHtmlDevFallback && !id.startsWith("\0") && !id.includes("node_modules") && /\.(js|ts|mjs|vue|jsx|tsx)(\?|$)/.test(id) || isHydrationEntryFallback || inject === "entry" && waitsForInit && isReactRouterEntry || isNuxtClientEntryFallback)) {
 				clientInjected = true;
 				injectedTransformIds.add(projectId);
 				if (!waitsForInit) return mapCodeToCodeWithSourcemap(`import ${JSON.stringify(getEntryPath())};\n` + code);
@@ -5892,10 +5628,12 @@ const reactAdapter = {
 * host components lives in the orphaned first runtime, but `reload(hmrId, ...)`
 * goes through the second runtime — the lookup misses and HMR stops working.
 *
-* This guard pins `__VUE_HMR_RUNTIME__` to the first writer (the host's Vue)
+* This guard pins `__VUE_HMR_RUNTIME__` to the first application Vue runtime
 * via a property trap on `globalThis`. Subsequent writes from remote-side Vue
-* copies are silently dropped. Must execute before any Vue module loads —
-* injected as a plain (non-module) script at `head-prepend`.
+* copies are silently dropped. vite-plugin-checker bundles its own Vue runtime
+* and evaluates it before the application, so writes from its virtual runtime
+* are ignored explicitly. Must execute before any Vue module loads — injected
+* as a plain (non-module) script at `head-prepend`.
 *
 * `singleton: true` in `shared` is not sufficient: in dev mode MF's share-scope
 * does not actually dedupe Vue across dev servers, so without this guard the
@@ -5906,7 +5644,11 @@ const VUE_HMR_RUNTIME_GUARD_SCRIPT = `
   var h = null;
   Object.defineProperty(globalThis, '__VUE_HMR_RUNTIME__', {
     get: function () { return h; },
-    set: function (v) { if (h === null) h = v; },
+    set: function (v) {
+      var stack = new Error().stack || '';
+      if (stack.indexOf('@vite-plugin-checker-runtime') !== -1) return;
+      if (h === null) h = v;
+    },
     configurable: true,
     enumerable: true,
   });
@@ -5973,7 +5715,7 @@ const REMOTE_HMR_ENDPOINT = "__mf_hmr";
 const REMOTE_HMR_EVENT = "mf:remote-update";
 const REMOTE_HMR_CONNECT_RETRY_DELAY_MS = 1e3;
 const REMOTE_HMR_CONNECT_MAX_RETRIES = 10;
-function getBasePath$1(base) {
+function getBasePath(base) {
 	if (!base) return "/";
 	if (base.startsWith("http://") || base.startsWith("https://")) try {
 		return new URL(base).pathname || "/";
@@ -5983,11 +5725,11 @@ function getBasePath$1(base) {
 	return base;
 }
 function getRemoteHmrPath(base) {
-	return `${getBasePath$1(base).replace(/\/?$/, "/")}${REMOTE_HMR_ENDPOINT}`.replace(/\/{2,}/g, "/");
+	return `${getBasePath(base).replace(/\/?$/, "/")}${REMOTE_HMR_ENDPOINT}`.replace(/\/{2,}/g, "/");
 }
 function getHmrWsPath(base, hmrPath) {
-	const normalizedBase = getBasePath$1(base);
-	const normalizedPath = getBasePath$1(hmrPath || "");
+	const normalizedBase = getBasePath(base);
+	const normalizedPath = getBasePath(hmrPath || "");
 	if (!normalizedPath || normalizedPath === "/") return normalizedBase;
 	return `${normalizedBase.endsWith("/") ? normalizedBase.slice(0, -1) : normalizedBase}/${normalizedPath.startsWith("/") ? normalizedPath.slice(1) : normalizedPath}`;
 }
@@ -6872,7 +6614,7 @@ const buildFileToShareKeyMap = async (shareKeys, resolveFn, options) => {
 * and shared packages are imported as bare specifiers (externals in the SSR build).
 */
 function getVirtualExposesSSRId(options) {
-	return `virtual:mf-exposes-ssr:${`${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+	return `virtual:mf-exposes-ssr:${getVirtualModuleScopeKey(options)}`;
 }
 /**
 * Generates the SSR exposes map module.
@@ -6908,8 +6650,7 @@ function generateExposesSSR(options, reactIslandExposes = /* @__PURE__ */ new Se
 //#region src/virtualModules/virtualRemoteEntrySSR.ts
 const REMOTE_ENTRY_SSR_ID = "virtual:mf-REMOTE_ENTRY_SSR_ID";
 function getRemoteEntrySSRId(options) {
-	const scopedKey = `${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_");
-	return `${REMOTE_ENTRY_SSR_ID}:${scopedKey}`;
+	return `${REMOTE_ENTRY_SSR_ID}:${getVirtualModuleScopeKey(options)}`;
 }
 function getSsrRemoteEntryFileName(browserFilename) {
 	const ext = browserFilename.match(/\.[^.]+$/)?.[0] || ".js";
@@ -6927,11 +6668,24 @@ function getSsrRemoteEntryFileName(browserFilename) {
 */
 function generateRemoteEntrySSR(options) {
 	const virtualExposesSSRId = getVirtualExposesSSRId(options);
+	const sharedSingletons = Object.fromEntries(Object.entries(options.shared).filter(([, share]) => share.shareConfig.singleton));
 	return `
   import { init as runtimeInit } from "@module-federation/runtime";
+  const sharedSingletons = ${JSON.stringify(sharedSingletons)};
   let exposesMapPromise;
+  function createShareInitError(errors) {
+    const details = errors.map(({ scopeName, pkg, error }) => {
+      const target = pkg
+        ? \`scope "\${scopeName}" package "\${pkg}"\`
+        : \`scope "\${scopeName}"\`;
+      return \`\${target}: \${error instanceof Error ? error.message : String(error)}\`;
+    });
+    const message = \`[Module Federation SSR] Shared initialization failed: \${details.join('; ')}\`;
+    return new AggregateError(errors.map(({ error }) => error), message);
+  }
   async function getExposesMap() {
     exposesMapPromise ??= import(${JSON.stringify(virtualExposesSSRId)}).then((mod) => mod.default ?? mod);
     return exposesMapPromise;
@@ -6954,24 +6708,54 @@ function generateRemoteEntrySSR(options) {
     const shareScopeNames = Array.isArray(${JSON.stringify(options.shareScope)})
       ? ${JSON.stringify(options.shareScope)}
       : [${JSON.stringify(options.shareScope)}];
-    try {
-      for (const scopeName of shareScopeNames) {
+    const shareInitErrors = [];
+    const cacheEntries = [];
+    for (const scopeName of shareScopeNames) {
+      let scopeShare;
+      try {
+        scopeShare = Array.isArray(${JSON.stringify(options.shareScope)})
+          ? shared?.[scopeName] || {}
+          : shared || {};
+        initRes.initShareScopeMap(scopeName, scopeShare);
+        await Promise.all(
+          await initRes.initializeSharing(scopeName, {
+            strategy: ${JSON.stringify(options.shareStrategy ?? "version-first")},
+            from: 'build',
+            initScope,
+          })
+        );
+      } catch (e) {
+        shareInitErrors.push({ scopeName, pkg: undefined, error: e });
+        continue;
+      }
+      for (const [pkg, shareInfo] of Object.entries(sharedSingletons)) {
         try {
-          const scopeShare = Array.isArray(${JSON.stringify(options.shareScope)}) ? (shared?.[scopeName] || {}) : shared;
-          initRes.initShareScopeMap(scopeName, scopeShare);
-          await Promise.all(
-            await initRes.initializeSharing(scopeName, {
-              strategy: ${JSON.stringify(options.shareStrategy ?? "version-first")},
-              from: 'build',
-              initScope,
-            })
-          );
+          if (shareInfo.scope !== scopeName) continue;
+          if (!scopeShare[pkg]) continue;
+          const factory = await initRes.loadShare(pkg, {
+            customShareInfo: { ...shareInfo, scope: [scopeName] },
+          });
+          if (typeof factory !== 'function') {
+            throw new Error('No compatible host provider was selected');
+          }
+          const module = await factory();
+          cacheEntries.push({ scopeName, pkg, module });
         } catch (e) {
-          console.error('[Module Federation SSR]', e);
+          shareInitErrors.push({ scopeName, pkg, error: e });
         }
       }
-    } catch (e) {
-      console.error('[Module Federation SSR]', e);
+    }
+    if (shareInitErrors.length > 0) {
+      throw createShareInitError(shareInitErrors);
+    }
+    if (cacheEntries.length > 0) {
+      const moduleCache = (globalThis.__mf_module_cache__ ||= { share: {}, remote: {} });
+      const cache = (moduleCache.share ||= {});
+      for (const { scopeName, pkg, module } of cacheEntries) {
+        cache[scopeName + ':' + pkg] ??= module;
+        if (scopeName === 'default') cache[pkg] ??= module;
+      }
     }
     return initRes;
   }
@@ -6987,318 +6771,6 @@ function generateRemoteEntrySSR(options) {
   `;
 }
 //#endregion
-//#region src/plugins/pluginDts.ts
-var pluginDts_exports = /* @__PURE__ */ __exportAll({
-	DEFAULT_PUBLIC_TYPES_FOLDER: () => DEFAULT_PUBLIC_TYPES_FOLDER,
-	createDevDtsAssetMiddleware: () => createDevDtsAssetMiddleware,
-	default: () => pluginDts,
-	getDevDtsAssetPaths: () => getDevDtsAssetPaths,
-	resolveDtsPluginOptions: () => resolveDtsPluginOptions
-});
-const DEFAULT_DEV_OPTIONS = {
-	disableLiveReload: true,
-	disableHotTypesReload: false,
-	disableDynamicRemoteTypeHints: false
-};
-const DYNAMIC_HINTS_PLUGIN = "@module-federation/dts-plugin/dynamic-remote-type-hints-plugin";
-const getIPv4 = () => process.env["FEDERATION_IPV4"] || "127.0.0.1";
-const DEV_TYPES_FOLDER = ".dev-server";
-const DEFAULT_PUBLIC_TYPES_FOLDER = "@mf-types";
-const forkDevWorkerPath = (() => {
-	return resolveImportPath("@module-federation/dts-plugin/dist/fork-dev-worker.js");
-})();
-var DevWorker = class {
-	worker = rpc.createRpcWorker(forkDevWorkerPath, {}, void 0, false);
-	constructor(options) {
-		this.worker.connect(options);
-	}
-	update() {
-		this.worker.process?.send?.({
-			type: rpc.RpcGMCallTypes.CALL,
-			id: this.worker.id,
-			args: [void 0, "update"]
-		});
-	}
-	exit() {
-		this.worker.terminate();
-	}
-};
-const normalizeDevOptions = (dev) => {
-	if (dev === false) return false;
-	if (dev === true || typeof dev === "undefined") return { ...DEFAULT_DEV_OPTIONS };
-	return {
-		...DEFAULT_DEV_OPTIONS,
-		...dev
-	};
-};
-const buildDtsModuleFederationConfig = (options) => {
-	const exposes = {};
-	Object.entries(options.exposes).forEach(([key, value]) => {
-		if (value.import) exposes[key] = value.import;
-	});
-	const remotes = {};
-	Object.entries(options.remotes).forEach(([key, remote]) => {
-		if (!remote.entry) return;
-		const entryGlobalName = remote.entryGlobalName?.startsWith("http") || remote.entryGlobalName?.includes(".json") ? remote.name || key : remote.entryGlobalName || remote.name || key;
-		remotes[key] = `${entryGlobalName}@${remote.entry}`;
-	});
-	return {
-		...options,
-		exposes,
-		remotes
-	};
-};
-const resolveOutputDir = (config) => {
-	const { outDir } = config.build;
-	if (path$1.isAbsolute(outDir)) return normalizePathForImport(path$1.relative(config.root, outDir));
-	return outDir;
-};
-const ensureRuntimePlugin = (options, pluginId) => {
-	if (!options.runtimePlugins.some((plugin) => {
-		if (typeof plugin === "string") return plugin === pluginId;
-		return plugin[0] === pluginId;
-	})) options.runtimePlugins.push(pluginId);
-};
-const getExposeImportPaths = (options) => {
-	return Object.values(options.exposes).map((value) => {
-		return value.import;
-	}).filter((value) => Boolean(value));
-};
-const usesVueSfcExposes = (options) => {
-	return getExposeImportPaths(options).some((value) => value.endsWith(".vue"));
-};
-const resolveDtsPluginOptions = (dts, options, context) => {
-	if (dts === false) return false;
-	const inferredGenerateTypesDefaults = { generateAPITypes: true };
-	if (usesVueSfcExposes(options) && hasPackageDependency("vue-tsc", context)) inferredGenerateTypesDefaults.compilerInstance = "vue-tsc";
-	if (dts === true || typeof dts === "undefined") return { generateTypes: inferredGenerateTypesDefaults };
-	const generateTypes = dts.generateTypes;
-	return {
-		...dts,
-		generateTypes: generateTypes === false ? false : {
-			...inferredGenerateTypesDefaults,
-			...generateTypes === true || typeof generateTypes === "undefined" ? {} : generateTypes
-		}
-	};
-};
-const getBasePath = (base) => {
-	if (base.startsWith("http://") || base.startsWith("https://")) return new URL(base).pathname.replace(/\/$/, "") || "/";
-	return base.replace(/\/$/, "") || "/";
-};
-const joinBaseAndAsset = (base, assetFileName) => {
-	const basePath = getBasePath(base);
-	return `${basePath === "/" ? "" : basePath}/${assetFileName}`.replace(/\/{2,}/g, "/");
-};
-const getDevDtsAssetPaths = (options) => {
-	const { outputDir, publicTypesFolder, root, base } = options;
-	return {
-		apiFilePath: path$1.resolve(root, outputDir, `${DEV_TYPES_FOLDER}.d.ts`),
-		apiRequestPath: joinBaseAndAsset(base, `${publicTypesFolder}.d.ts`),
-		zipFilePath: path$1.resolve(root, outputDir, `${DEV_TYPES_FOLDER}.zip`),
-		zipRequestPath: joinBaseAndAsset(base, `${publicTypesFolder}.zip`)
-	};
-};
-const createDevDtsAssetMiddleware = (assetPaths) => {
-	return (req, res, next) => {
-		const requestPath = req.url?.split("?")[0];
-		const isZipRequest = requestPath === assetPaths.zipRequestPath;
-		const isApiRequest = requestPath === assetPaths.apiRequestPath;
-		if (!isZipRequest && !isApiRequest) {
-			next();
-			return;
-		}
-		const filePath = isZipRequest ? assetPaths.zipFilePath : assetPaths.apiFilePath;
-		if (!fs.existsSync(filePath)) {
-			res.statusCode = 404;
-			res.end();
-			return;
-		}
-		res.statusCode = 200;
-		res.setHeader("Content-Type", isZipRequest ? "application/x-gzip" : "application/typescript");
-		if (req.method === "HEAD") {
-			res.end();
-			return;
-		}
-		const stream = fs.createReadStream(filePath);
-		stream.on("error", () => {
-			if (!res.headersSent) res.statusCode = 500;
-			res.end();
-		});
-		res.on("close", () => {
-			stream.destroy();
-		});
-		stream.pipe(res);
-	};
-};
-const normalizeDevDtsOptions = (dts, context) => {
-	return normalizeOptions(isTSProject(dts, context), {
-		generateTypes: { compileInChildProcess: true },
-		consumeTypes: { consumeAPITypes: true },
-		extraOptions: {},
-		displayErrorInTerminal: typeof dts === "object" && dts ? dts.displayErrorInTerminal : void 0
-	}, "mfOptions.dts")(dts);
-};
-const logDtsError = (error, dtsOptions) => {
-	if (dtsOptions === false) return;
-	if (typeof dtsOptions === "object" && dtsOptions && dtsOptions.displayErrorInTerminal === false) return;
-	mfError(error);
-};
-function pluginDts(options) {
-	if (options.dts === false) return [];
-	const baseDtsModuleFederationConfig = buildDtsModuleFederationConfig(options);
-	const getDtsModuleFederationConfig = (context) => ({
-		...baseDtsModuleFederationConfig,
-		dts: resolveDtsPluginOptions(options.dts, options, context)
-	});
-	let resolvedConfig;
-	let devWorker;
-	let normalizedDevOptions;
-	let hasGeneratedBundle = false;
-	return [{
-		name: "module-federation-dts-dev",
-		apply: "serve",
-		config(config) {
-			normalizedDevOptions = normalizeDevOptions(options.dev);
-			if (!normalizedDevOptions) return;
-			if (normalizedDevOptions.disableDynamicRemoteTypeHints) return;
-			ensureRuntimePlugin(options, DYNAMIC_HINTS_PLUGIN);
-			const define = config.define ? { ...config.define } : {};
-			if (!("FEDERATION_IPV4" in define)) define.FEDERATION_IPV4 = JSON.stringify(getIPv4());
-			config.define = define;
-		},
-		configResolved(config) {
-			resolvedConfig = config;
-		},
-		configureServer(server) {
-			if (!normalizedDevOptions || !resolvedConfig) return;
-			const devOptions = normalizedDevOptions;
-			if (devOptions.disableDynamicRemoteTypeHints && devOptions.disableHotTypesReload && devOptions.disableLiveReload) return;
-			if (!options.name) throw createModuleFederationError("name is required if you want to enable dev server!");
-			const outputDir = resolveOutputDir(resolvedConfig);
-			const dtsModuleFederationConfig = getDtsModuleFederationConfig(resolvedConfig.root);
-			const normalizedDtsOptions = normalizeDevDtsOptions(dtsModuleFederationConfig.dts, resolvedConfig.root);
-			if (typeof normalizedDtsOptions !== "object") return;
-			const normalizedGenerateTypes = normalizeOptions(Boolean(normalizedDtsOptions), { compileInChildProcess: true }, "mfOptions.dts.generateTypes")(normalizedDtsOptions.generateTypes);
-			const remote = normalizedGenerateTypes === false ? void 0 : {
-				implementation: normalizedDtsOptions.implementation,
-				context: resolvedConfig.root,
-				outputDir,
-				moduleFederationConfig: { ...dtsModuleFederationConfig },
-				hostRemoteTypesFolder: normalizedGenerateTypes.typesFolder || "@mf-types",
-				...normalizedGenerateTypes,
-				typesFolder: DEV_TYPES_FOLDER
-			};
-			if (remote) server.middlewares.use(createDevDtsAssetMiddleware(getDevDtsAssetPaths({
-				outputDir,
-				publicTypesFolder: remote.hostRemoteTypesFolder || "@mf-types",
-				root: resolvedConfig.root,
-				base: resolvedConfig.base
-			})));
-			if (remote && !remote.tsConfigPath && normalizedDtsOptions.tsConfigPath) remote.tsConfigPath = normalizedDtsOptions.tsConfigPath;
-			const normalizedConsumeTypes = normalizeOptions(Boolean(normalizedDtsOptions), { consumeAPITypes: true }, "mfOptions.dts.consumeTypes")(normalizedDtsOptions.consumeTypes);
-			const host = normalizedConsumeTypes === false ? void 0 : {
-				implementation: normalizedDtsOptions.implementation,
-				context: resolvedConfig.root,
-				moduleFederationConfig: dtsModuleFederationConfig,
-				typesFolder: normalizedConsumeTypes.typesFolder || "@mf-types",
-				abortOnError: false,
-				...normalizedConsumeTypes
-			};
-			const extraOptions = normalizedDtsOptions.extraOptions || {};
-			if (!remote && !host && devOptions.disableLiveReload) return;
-			const startDevWorker = async () => {
-				let remoteTypeUrls;
-				if (host) remoteTypeUrls = await new Promise((resolve) => {
-					consumeTypesAPI({
-						host,
-						extraOptions,
-						displayErrorInTerminal: normalizedDtsOptions.displayErrorInTerminal
-					}, resolve);
-				});
-				devWorker = new DevWorker({
-					name: options.name,
-					remote,
-					host: host ? {
-						...host,
-						remoteTypeUrls
-					} : void 0,
-					extraOptions,
-					disableLiveReload: devOptions.disableLiveReload,
-					disableHotTypesReload: devOptions.disableHotTypesReload
-				});
-				const update = () => devWorker?.update();
-				server.watcher.on("change", update);
-				server.watcher.on("add", update);
-				server.watcher.on("unlink", update);
-				server.httpServer?.once("close", () => {
-					devWorker?.exit();
-					server.watcher.off("change", update);
-					server.watcher.off("add", update);
-					server.watcher.off("unlink", update);
-				});
-			};
-			startDevWorker().catch((error) => {
-				logDtsError(error, normalizedDtsOptions);
-			});
-		}
-	}, {
-		name: "module-federation-dts-build",
-		apply: "build",
-		configResolved(config) {
-			resolvedConfig = config;
-		},
-		async generateBundle() {
-			if (hasGeneratedBundle) return;
-			hasGeneratedBundle = true;
-			if (!resolvedConfig) return;
-			let normalizedDtsOptions;
-			try {
-				normalizedDtsOptions = normalizeDtsOptions(getDtsModuleFederationConfig(resolvedConfig.root), resolvedConfig.root);
-			} catch (error) {
-				logDtsError(error, options.dts);
-				return;
-			}
-			if (typeof normalizedDtsOptions !== "object") return;
-			const context = resolvedConfig.root;
-			const outputDir = resolveOutputDir(resolvedConfig);
-			let consumeOptions;
-			try {
-				consumeOptions = normalizeConsumeTypesOptions({
-					context,
-					dtsOptions: normalizedDtsOptions,
-					pluginOptions: getDtsModuleFederationConfig(resolvedConfig.root)
-				});
-			} catch (error) {
-				logDtsError(error, normalizedDtsOptions);
-				return;
-			}
-			if (consumeOptions?.host?.typesOnBuild) try {
-				await consumeTypesAPI(consumeOptions);
-			} catch (error) {
-				logDtsError(error, normalizedDtsOptions);
-			}
-			let generateOptions;
-			try {
-				generateOptions = normalizeGenerateTypesOptions({
-					context,
-					outputDir,
-					dtsOptions: normalizedDtsOptions,
-					pluginOptions: getDtsModuleFederationConfig(resolvedConfig.root)
-				});
-			} catch (error) {
-				logDtsError(error, normalizedDtsOptions);
-				return;
-			}
-			if (!generateOptions) return;
-			try {
-				await generateTypesAPI({ dtsManagerOptions: generateOptions });
-			} catch (error) {
-				logDtsError(error, normalizedDtsOptions);
-			}
-		}
-	}];
-}
-//#endregion
 //#region src/plugins/pluginMFManifest.ts
 /**
 * Resolves the build version for the module federation manifest.
@@ -8225,12 +7697,15 @@ function getSharedKeyMatcher(shared) {
 	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
 		});
-		for (const subpath of getCommonSharedSubpaths(keyBase)) if (!commonSubpathKeys.has(subpath)) commonSubpathKeys.set(subpath, key);
+		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) {
@@ -8386,15 +7861,16 @@ function proxySharedModule(options) {
 			configResolved(config) {
 				_config = config;
 				const isRolldown = getIsRolldown(this);
+				const registerConfiguredShare = _command === "serve" ? addConfiguredShare : addUsedShares;
 				Object.keys(shared).forEach((key) => {
 					if (key.endsWith("/")) return;
 					if (useDirectReactImport && key === "react") {
-						addUsedShares(key, federationOptions);
+						registerConfiguredShare(key, federationOptions);
 						return;
 					}
 					writeLoadShareModule(key, shared[key], _command, isRolldown, federationOptions);
 					if (shared[key].shareConfig.import !== false) writePreBuildLibPath(key, shared[key], federationOptions);
-					addUsedShares(key, federationOptions);
+					registerConfiguredShare(key, federationOptions);
 				});
 				writeLocalSharedImportMap(federationOptions);
 				refreshHostAutoInit(federationOptions);
@@ -8841,7 +8317,7 @@ function getRealPathIfExists(filePath) {
 		return;
 	}
 }
-function isPathWithinDirectory(filePath, directory) {
+function isCanonicalPathWithinDirectory(filePath, directory) {
 	const realFilePath = getRealPathIfExists(filePath) ?? path$1.resolve(filePath);
 	const realDirectory = getRealPathIfExists(directory) ?? path$1.resolve(directory);
 	const relative = path$1.relative(realDirectory, realFilePath);
@@ -8851,7 +8327,7 @@ function getRunnerAllowedDirectories(config) {
 	return [config.root, ...config.server?.fs?.allow ?? []].map((directory) => path$1.resolve(directory));
 }
 function isPathWithinAllowedDirectories(filePath, allowedDirectories) {
-	return allowedDirectories.some((directory) => isPathWithinDirectory(filePath, directory));
+	return allowedDirectories.some((directory) => isCanonicalPathWithinDirectory(filePath, directory));
 }
 function isSafeRunnerFetchModuleId(id, config) {
 	if (typeof id !== "string" || !id) return false;
@@ -9006,7 +8482,7 @@ function pluginSSRRemoteEntry(options) {
 		},
 		configureServer(server) {
 			const base = "/__mf_ssr__";
-			const basePath = getBasePath$2(viteConfig?.base);
+			const basePath = getBasePath$1(viteConfig?.base);
 			const ssrEntryFileName = getSsrRemoteEntryFileName(options.filename);
 			if (isNuxtProject || isNuxtClientBase(basePath)) server.middlewares.use((req, _res, next) => {
 				if (req.url?.replace(/\?.*/, "") === `${basePath}/${ssrEntryFileName}`) req.url = `${basePath}/__mf_ssr__/${ssrEntryFileName}`;
@@ -9061,7 +8537,7 @@ function pluginSSRRemoteEntry(options) {
 			const ssrPath = `${base}/${ssrEntryFileName}`;
 			server.middlewares.use(ssrPath, (_req, res) => {
 				const exposesUrl = `${base}/${options.filename.replace(/\.[^.]+$/, "")}.exposes.js`;
-				const code = generateRemoteEntrySSR(options).replace(JSON.stringify(virtualExposesSSRId), JSON.stringify(exposesUrl));
+				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);
@@ -9080,7 +8556,7 @@ function pluginSSRRemoteEntry(options) {
 			if (id === `/__mf_ssr__/${options.filename.replace(/\.[^.]+$/, "")}.exposes.js`) return virtualExposesSSRId;
 		},
 		load(id) {
-			if (id === remoteEntrySSRId || id.startsWith(remoteEntrySSRId)) return generateRemoteEntrySSR(options);
+			if (id === remoteEntrySSRId || id.startsWith(remoteEntrySSRId)) return getSsrRemoteEntrySource();
 			if (id === virtualExposesSSRId || id.startsWith(virtualExposesSSRId)) return generateExposesSSR(options, reactIslandExposes);
 		},
 		buildStart() {
@@ -9112,9 +8588,6 @@ function pluginSSRRemoteEntry(options) {
 					});
 				}
 				if (this.environment?.name === "ssr") ssrOutputFiles = collectEntryOutputFiles(bundle, ssrOutputFilename);
-				if (!isRolldown) return;
-				const chunk = bundle[ssrOutputFilename];
-				if (!chunk || chunk.type !== "chunk") return;
 			}
 		},
 		writeBundle(outputOptions) {
@@ -9134,7 +8607,7 @@ function pluginSSRRemoteEntry(options) {
 		for (const fileName of ssrOutputFiles) {
 			const source = path$1.resolve(ssrDir, fileName);
 			const destination = path$1.resolve(clientDir, fileName);
-			if (!isWithinDirectory(source, ssrDir) || !isWithinDirectory(destination, clientDir)) continue;
+			if (!isResolvedPathWithinDirectory(source, ssrDir) || !isResolvedPathWithinDirectory(destination, clientDir)) continue;
 			if (!fs$1.existsSync(source) || fs$1.existsSync(destination)) continue;
 			fs$1.mkdirSync(path$1.dirname(destination), { recursive: true });
 			fs$1.copyFileSync(source, destination);
@@ -9165,7 +8638,7 @@ function collectEntryOutputFiles(bundle, entryFileName) {
 	visit(entryFileName);
 	return files;
 }
-function isWithinDirectory(filePath, directory) {
+function isResolvedPathWithinDirectory(filePath, directory) {
 	const relative = path$1.relative(directory, filePath);
 	return relative !== "" && !relative.startsWith(`..${path$1.sep}`) && relative !== "..";
 }
@@ -9625,6 +9098,74 @@ function includeLinkedSharedEntries(optimizeDeps, shared, projectRoot, exposes,
 	for (const entry of additions) entries.add(entry);
 	optimizeDeps.entries = [...entries];
 }
+function stabilizeOptimizeDeps(optimizeDeps) {
+	optimizeDeps.include = [...new Set(optimizeDeps.include ?? [])].sort();
+	optimizeDeps.exclude = [...new Set(optimizeDeps.exclude ?? [])].sort();
+}
+function isFile(candidate) {
+	try {
+		return statSync(candidate).isFile();
+	} catch {
+		return false;
+	}
+}
+function registerEntryImports(options, projectRoot) {
+	const staticImport = /\b(?:import|export)\s+(?:type\s+)?(?:[^'";]*?\s+from\s*)?(['"])([^'"]+)\1/g;
+	const dynamicImport = /\b(?:import|require)\s*\(\s*(['"])([^'"]+)\1/g;
+	const sourceExtensions = [
+		".mjs",
+		".js",
+		".mts",
+		".ts",
+		".jsx",
+		".tsx",
+		".vue",
+		".svelte"
+	];
+	const root = path$1.resolve(projectRoot);
+	const pending = [];
+	const visited = /* @__PURE__ */ new Map();
+	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;
+		const base = cleanRequest.startsWith("/") ? path$1.resolve(root, `.${cleanRequest}`) : path$1.resolve(path$1.dirname(importer), cleanRequest);
+		const relative = path$1.relative(root, base);
+		if (relative.startsWith(`..${path$1.sep}`) || path$1.isAbsolute(relative)) return;
+		const file = [
+			base,
+			...sourceExtensions.map((extension) => `${base}${extension}`),
+			...sourceExtensions.map((extension) => path$1.join(base, `index${extension}`))
+		].find(isFile);
+		if (file && (!visited.has(file) || preloadRemotes && !visited.get(file))) pending.push({
+			file,
+			preloadRemotes
+		});
+	};
+	const htmlEntry = path$1.join(root, "index.html");
+	if (existsSync(htmlEntry)) {
+		const html = readFileSync(htmlEntry, "utf8");
+		for (const match of html.matchAll(/<script\b[^>]*\bsrc=(['"])([^'"]+)\1[^>]*>/gi)) enqueue(match[2], htmlEntry, true);
+	}
+	for (const expose of Object.values(options.exposes ?? {})) enqueue(expose.import);
+	while (pending.length) {
+		const { file, preloadRemotes } = pending.pop();
+		if (visited.get(file) || visited.has(file) && !preloadRemotes) continue;
+		visited.set(file, preloadRemotes);
+		const code = readFileSync(file, "utf8");
+		for (const pattern of [staticImport, dynamicImport]) {
+			const isStatic = pattern === staticImport;
+			pattern.lastIndex = 0;
+			for (const match of code.matchAll(pattern)) {
+				const request = match[2];
+				const remoteKey = preloadRemotes && isStatic && request ? Object.keys(options.remotes).find((name) => request === name || request.startsWith(`${name}/`)) : void 0;
+				const sharedKey = request && findSharedKey(request, options.shared);
+				if (remoteKey) addUsedRemote(remoteKey, request, options);
+				else if (sharedKey) addUsedShares(request, options);
+				else if (request) enqueue(request, file, preloadRemotes && isStatic);
+			}
+		}
+	}
+}
 /**
 * Plugin that runs FIRST to register generated virtual modules in the config hook.
 * This prevents 504 "Outdated Optimize Dep" errors by ensuring ids are known
@@ -9639,6 +9180,7 @@ function createEarlyVirtualModulesPlugin(options) {
 		config(config, { command: _command }) {
 			if (_command === "serve") ignoreFederationGeneratedFiles(config, options);
 			const root = config.root || process.cwd();
+			resetConcreteSharedImportSourceCache();
 			setPackageDetectionCwd(root);
 			const isVinext = hasPackageDependency("vinext");
 			initVirtualModules(_command, getRemoteEntryId(options), false, options);
@@ -9652,8 +9194,10 @@ function createEarlyVirtualModulesPlugin(options) {
 					config.optimizeDeps.exclude.push(...Object.keys(remotes || {}));
 				}
 			}
+			if (_command === "serve" && (Object.keys(shared ?? {}).length > 0 || Object.keys(remotes ?? {}).length > 0)) registerEntryImports(options, root);
 			if (shared && Object.keys(shared).length > 0) {
 				if (_command === "serve") {
+					excludeSharedSubDependencies(shared);
 					config.optimizeDeps = config.optimizeDeps || {};
 					config.optimizeDeps.include = config.optimizeDeps.include || [];
 					const optimizeDeps = config.optimizeDeps;
@@ -9685,16 +9229,15 @@ function createEarlyVirtualModulesPlugin(options) {
 								const isReactDomRequire = resolveOptions?.kind?.startsWith("require") && isReactDomSelfReference(source, importer);
 								if (resolveOptions?.kind?.startsWith("require") && !isReactRequire && !isReactDomRequire) return;
 								if (isCommonJsImporter(importer) && !isReactSingleton && !isReactDomRequire) return;
+								if (resolveOptions?.kind !== "entry-point") addUsedShares(source, options);
 								if (isReactRequire || isReactDomRequire) {
 									writeLoadShareModule(source, shareItem, _command, isRolldown, options);
 									if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(source, shareItem, options);
-									addUsedShares(source, options);
 									return { id: `module-federation:optimized-require-${source}` };
 								}
 								const loadSharePath = getLoadShareModulePath(source, isRolldown, options);
 								writeLoadShareModule(source, shareItem, _command, isRolldown, options);
 								if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(source, shareItem, options);
-								addUsedShares(source, options);
 								return {
 									id: loadSharePath,
 									external: true
@@ -9717,6 +9260,7 @@ function createEarlyVirtualModulesPlugin(options) {
 									if (isSharedResolverInternalImporter(args.importer)) return;
 									if (!findSharedKey(args.path, shared) || isAssetLikeImport(args.path)) return;
 									if (getPackageNameFromNodeModulePath(args.importer) === getPackageName(args.path) && !isReactDomSelfReference(args.path, args.importer)) return;
+									addUsedShares(args.path, options);
 									return {
 										path: args.path,
 										namespace: "mf-shared"
@@ -9732,7 +9276,6 @@ function createEarlyVirtualModulesPlugin(options) {
 									const loadSharePath = getLoadShareModulePath(args.path, isRolldown, options);
 									writeLoadShareModule(args.path, shareItem, _command, isRolldown, options);
 									if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(args.path, shareItem, options);
-									addUsedShares(args.path, options);
 									return {
 										loader: "js",
 										resolveDir: root,
@@ -9761,13 +9304,13 @@ export default __mfShared.default ?? __mfShared;`
 						continue;
 					}
 					if (isVinext && key === "react") {
-						addUsedShares(key, options);
+						addConfiguredShare(key, options);
 						continue;
 					}
 					getLoadShareModulePath(key, isRolldown, options);
 					writeLoadShareModule(key, shareItem, _command, isRolldown, options);
 					if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(key, shareItem, options);
-					addUsedShares(key, options);
+					addConfiguredShare(key, options);
 					if (_command === "serve" && shareItem.shareConfig?.import !== false) {
 						const optimizeDeps = config.optimizeDeps ??= {};
 						optimizeDeps.include ??= [];
@@ -9785,7 +9328,7 @@ export default __mfShared.default ?? __mfShared;`
 							getLoadShareModulePath(subpath, isRolldown, options);
 							writeLoadShareModule(subpath, shareItem, _command, isRolldown, options);
 							writePreBuildLibPath(subpath, shareItem, options);
-							addUsedShares(subpath, options);
+							addConfiguredShare(subpath, options);
 							if (canResolveSubpath) {
 								optimizeDeps.include.push(subpath);
 								if (key === "react-dom") optimizeDeps.include.push(`${key} > ${subpath}`);
@@ -9798,6 +9341,7 @@ export default __mfShared.default ?? __mfShared;`
 			if (_command === "serve") {
 				config.optimizeDeps ??= {};
 				includeLinkedSharedEntries(config.optimizeDeps, shared, root, options.exposes, config.build?.outDir ?? "dist");
+				stabilizeOptimizeDeps(config.optimizeDeps);
 			}
 		},
 		configResolved(config) {
@@ -9827,7 +9371,7 @@ export default __mfShared.default ?? __mfShared;`
 					resolvedShared[pkg] = resolveImportPath(pkg);
 				} catch {}
 			}
-			const ssrEntryLoaderSpecifier = "@module-federation/vite/ssrEntryLoader";
+			const ssrEntryLoaderSpecifier = SSR_ENTRY_LOADER_SPECIFIER;
 			try {
 				resolveImportPath(ssrEntryLoaderSpecifier);
 				options.runtimePlugins.push([ssrEntryLoaderSpecifier, { resolvedShared }]);
@@ -9835,7 +9379,6 @@ export default __mfShared.default ?? __mfShared;`
 		}
 	};
 }
-const SSR_ONLY_PLUGINS = /* @__PURE__ */ new Set(["@module-federation/vite/ssrEntryLoader"]);
 function applyBuildTimeRuntimeDefines(define, options, { target, isAstro, defaultDisableSnapshot }) {
 	const envTargetDefineValue = !options.target && isAstro ? "undefined" : JSON.stringify(target);
 	if (!("ENV_TARGET" in define)) define.ENV_TARGET = envTargetDefineValue;
@@ -9847,7 +9390,7 @@ function applyBuildTimeRuntimeDefines(define, options, { target, isAstro, defaul
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [Promise.resolve().then(() => pluginDts_exports).then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-BNCg4Gri.js").then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {
@@ -9888,7 +9431,7 @@ function federation(mfUserOptions) {
 	const virtualExposesId = getVirtualExposesId(options);
 	const moduleParseController = createModuleParseController();
 	const moduleParsePlugins = pluginModuleParseEnd_default((id) => {
-		return id.includes(getHostAutoInitImportId(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(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,
@@ -10288,7 +9831,7 @@ function federation(mfUserOptions) {
 				if (needsRuntimeHelpers) config.optimizeDeps.include.push("@module-federation/runtime/helpers");
 				options.runtimePlugins.forEach((p) => {
 					const pluginPath = typeof p === "string" ? p : p[0];
-					if (SSR_ONLY_PLUGINS.has(pluginPath)) return;
+					if (SSR_ONLY_RUNTIME_PLUGINS.has(pluginPath)) return;
 					if (pluginPath && !pluginPath.startsWith(".") && !pluginPath.startsWith("/") && !pluginPath.startsWith("\0") && !pluginPath.startsWith("virtual:")) {
 						let optimizeDep = pluginPath;
 						if (pluginPath === "@module-federation/dts-plugin/dynamic-remote-type-hints-plugin") try {