@module-federation/vite 1.21.1 → 1.21.3

package/README.md

@@ -167,7 +167,7 @@ export default defineConfig({
       name: "host",
       remotes: {
         remote: {
-          type: "module", // type "var" (default) for vite remote is supported with remote's `varFilename` option
+          type: "module", // omitted object type defaults to "var" with a warning
           name: "remote",
           entry: "https://[...]/remoteEntry.js",
           entryGlobalName: "remote",
@@ -237,6 +237,7 @@ export default defineConfig({
 ```
 
 The host app configuration specifies its name, the filename of its exposed remote entry remoteEntry.js, and importantly, the configuration of the remote application to load.
+Object remotes that omit `type` retain the legacy `"var"` default and emit a warning. Use `type: "module"` for Vite ESM remotes. Use `type: "var"` explicitly only for global-format remotes, such as Webpack/Rspack remotes or a Vite remote's `varFilename` output.
 You can specify the place the host initialization file is injected with the **hostInitInjectLocation** option, which is described in the example code above.
 The **moduleParseTimeout** option allows you to configure the maximum time to wait for module parsing during the build process.
 The **moduleParseIdleTimeout** option is an alternative that resets the timer on every parsed module. It only fires when there has been no module activity for the configured duration, making it suitable for large codebases where the total build time exceeds the fixed timeout.
@@ -303,6 +304,18 @@ federation({
 
 `runtime-infer` is useful for local development and falls back to the full dependency when the required exports are not available. `server-calc` is recommended for deployments because it can use aggregated export metadata from all consumers.
 
+Use `eager: true` when a shared dependency must provide exports during module evaluation. For example, icon libraries may call `jsx()` at module scope before deferred singleton initialization completes. Configure the remote's React share as follows; discovered React subpaths such as `react/jsx-runtime` inherit this setting:
+
+```ts
+federation({
+  shared: {
+    react: { singleton: true, eager: true },
+  },
+});
+```
+
+This bundles the local fallback into the initial entry, so enable it only when synchronous evaluation requires it.
+
 Do not combine `eager: true` with `treeShaking`; eager shared dependencies are bundled into the initial entry and cannot use the on-demand tree-shaking path. Choose eager loading for small dependencies, or tree shaking for larger dependencies such as component libraries.
 
 With `server-calc`, the Vite build records the exports used by each application in its generated Module Federation metadata. A deployment service must then collect that metadata for all applications that share the same dependency and version, merge their `usedExports` lists, and use the resulting union to create one optimized secondary shared artifact. For example, if one application uses `Button` and another uses `Input`, the secondary artifact must contain both exports.

package/lib/{dtsConstants-DyJrx8ah.js → dtsConstants-CScOzmdO.js}

@@ -388,17 +388,22 @@ function resolveInstalledPackageJson(pkg, cwd, packageName, opts) {
 		}
 		let currentDir = path$1.dirname(resolvedPath);
 		const rootDir = path$1.parse(currentDir).root;
+		let matchingPackage;
 		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
-					};
+					if (packageJson.name === packageName) {
+						const packageInfo = {
+							path: packageJsonPath,
+							dir: currentDir,
+							packageJson
+						};
+						if (currentDir.endsWith(path$1.join("node_modules", packageName))) return packageInfo;
+						matchingPackage ??= packageInfo;
+					}
 				} catch (error) {
 					if (!(error instanceof SyntaxError)) throw error;
 				}
@@ -406,6 +411,7 @@ function resolveInstalledPackageJson(pkg, cwd, packageName, opts) {
 			if (currentDir === rootDir) break;
 			currentDir = path$1.dirname(currentDir);
 		}
+		return matchingPackage;
 	} catch {
 		let currentDir = cwd;
 		const rootDir = path$1.parse(currentDir).root;

package/lib/index.js

@@ -1,6 +1,6 @@
 import { n as normalizePathForImport, r as rebaseImport } from "./buildPaths-BkaQHrd2.js";
-import { a as getPackageDetectionCwd, c as getSharedCacheDescriptor, d as packageNameDecode, f as packageNameEncode, g as createModuleFederationError, h as sharedCacheHelperCode, i as getIsRolldown, l as hasPackageDependency, m as setPackageDetectionCwd, n as getInstalledPackageEntry, o as getPackageName, p as resolveImportPath, r as getInstalledPackageJson, s as getPackageNameFromNodeModulePath, u as isNuxtProjectRoot, v as mfWarn } from "./dtsConstants-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 { a as getPackageDetectionCwd, c as getSharedCacheDescriptor, d as packageNameDecode, f as packageNameEncode, g as createModuleFederationError, h as sharedCacheHelperCode, i as getIsRolldown, l as hasPackageDependency, m as setPackageDetectionCwd, n as getInstalledPackageEntry, o as getPackageName, p as resolveImportPath, r as getInstalledPackageJson, s as getPackageNameFromNodeModulePath, u as isNuxtProjectRoot, v as mfWarn } from "./dtsConstants-CScOzmdO.js";
+import { a as getCommonSharedSubpaths, c as isNodeModulePath, d as normalizeNodeModulePath, f as resolvePublicPath, i as getCommonSharedSubpathFromNodeModulePath, l as isNuxtClientBase, n as filterId, o as getMatchingNodeModuleSubpath, r as getBasePath$1, s as isAssetLikeImport, t as ensureTrailingSlash, u as isViteOptimizableEntry } from "./pathNormalization-CHct3UwV.js";
 import { createRequire } from "node:module";
 import * as fs$2 from "fs";
 import { existsSync, readFileSync, realpathSync, statSync, writeFileSync } from "fs";
@@ -502,64 +502,119 @@ function createCodePositionMap(code) {
 }
 //#endregion
 //#region src/utils/htmlEntryUtils.ts
-function isTypeOnlyClause(clause) {
-	const normalized = clause.trim();
-	if (/^type\b/.test(normalized)) return true;
-	const namedSpecifiers = normalized.match(/^\{([\s\S]*)\}$/)?.[1];
-	if (!namedSpecifiers) return false;
+const IDENTIFIER = String.raw`[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}]*`;
+const NAMED_SPECIFIERS = String.raw`\{[^{}]*\}`;
+const NAMESPACE_SPECIFIER = String.raw`\*\s*as\s+${IDENTIFIER}`;
+const IMPORT_CLAUSE = String.raw`(?:(?<importType>type)\s+)?(?<importClause>${NAMESPACE_SPECIFIER}|${NAMED_SPECIFIERS}|${IDENTIFIER}(?:\s*,\s*(?:${NAMESPACE_SPECIFIER}|${NAMED_SPECIFIERS}))?)`;
+const EXPORT_CLAUSE = String.raw`(?:(?<exportType>type)\s+)?(?<exportClause>\*(?:\s*as\s+(?:${IDENTIFIER}|"[^"]*"|'[^']*'))?|${NAMED_SPECIFIERS})`;
+const SPECIFIER = String.raw`(?<quote>["'])(?<source>[^"'\r\n]*)\k<quote>`;
+const KEYWORD_BOUNDARY = String.raw`(?<![.$\w])`;
+const KEYWORD_GAP = String.raw`(?:\s+|(?=[{*]))`;
+const STATIC_PATTERN = new RegExp(String.raw`${KEYWORD_BOUNDARY}(?:import${KEYWORD_GAP}${IMPORT_CLAUSE}|export${KEYWORD_GAP}${EXPORT_CLAUSE})\s*from\s*${SPECIFIER}`, "gud");
+const DYNAMIC_PATTERN = new RegExp(String.raw`${KEYWORD_BOUNDARY}import\s*\(\s*${SPECIFIER}`, "gud");
+const REQUIRE_PATTERN = new RegExp(String.raw`${KEYWORD_BOUNDARY}require\s*\(\s*${SPECIFIER}\s*\)`, "gud");
+const SIDE_EFFECT_PATTERN = new RegExp(String.raw`${KEYWORD_BOUNDARY}import\s*${SPECIFIER}`, "gud");
+/**
+* Returns `code` with every non-code region blanked out to spaces so that
+* regexes can run against real syntax only. String literals keep their
+* delimiters (with a blank interior) so import specifiers stay locatable;
+* comments, template literals, and regular expressions vanish entirely.
+* The result has the same length as `code`, so match indices map back 1:1.
+*/
+function blankNonCode(code) {
+	const codePositions = createCodePositionMap(code);
+	const chars = code.split("");
+	let index = 0;
+	while (index < code.length) {
+		if (codePositions[index]) {
+			index++;
+			continue;
+		}
+		const start = index;
+		while (index < code.length && !codePositions[index]) index++;
+		const quote = code[start];
+		const isString = (quote === "\"" || quote === "'") && index - start >= 2 && code[index - 1] === quote;
+		for (let position = start; position < index; position++) chars[position] = isString && (position === start || position === index - 1) ? quote : code[position] === "\n" ? "\n" : " ";
+	}
+	return chars.join("");
+}
+function isTypeOnlyNamedClause(clause) {
+	const namedSpecifiers = clause.trim().match(/^\{([\s\S]*)\}$/)?.[1];
+	if (namedSpecifiers === void 0) return false;
 	const specifiers = namedSpecifiers.split(",").map((specifier) => specifier.trim()).filter(Boolean);
-	return specifiers.length > 0 && specifiers.every((specifier) => /^type\s+\S/.test(specifier));
+	return specifiers.length > 0 && specifiers.every((specifier) => /^type\s+(?!as(?:\s|$))\S/.test(specifier));
+}
+function readSource(code, match) {
+	const range = match.indices?.groups?.source;
+	if (!range) return void 0;
+	const source = code.slice(range[0], range[1]);
+	return source.length > 0 ? source : void 0;
 }
 /**
 * Finds module imports while ignoring comments, strings, and regular expressions.
 * The descriptor keeps enough information for callers to distinguish runtime
 * static imports from type-only imports without introducing a parser dependency.
+*
+* Matching runs against a blanked copy of the code (see `blankNonCode`), so an
+* `import` inside a comment or string can never match, comments inside a
+* statement never change its classification, and a clause can never span
+* multiple statements.
 */
 function findModuleImportDescriptors(code) {
-	const codePositions = createCodePositionMap(code);
+	const blanked = blankNonCode(code);
 	const descriptors = [];
-	const staticFromPattern = /\b(?:import|export)\s+([\s\S]*?)\s+from\s*(["'])([^"']+)\2/g;
-	const dynamicPattern = /\bimport\s*\(\s*(?:\/\*[\s\S]*?\*\/\s*)?(["'])([^"']+)\1\s*\)/g;
-	const requirePattern = /\brequire\s*\(\s*(["'])([^"']+)\1\s*\)/g;
-	const sideEffectPattern = /\bimport\s*(["'])([^"']+)\1/g;
-	for (const match of code.matchAll(staticFromPattern)) {
-		if (!codePositions[match.index]) continue;
+	for (const match of blanked.matchAll(STATIC_PATTERN)) {
+		const source = readSource(code, match);
+		if (!source) continue;
+		const groups = match.groups;
+		const typeOnly = groups.importType !== void 0 || groups.exportType !== void 0 || isTypeOnlyNamedClause(groups.importClause ?? groups.exportClause ?? "");
 		descriptors.push({
 			kind: "static",
 			syntax: "import",
-			source: match[3],
-			typeOnly: isTypeOnlyClause(match[1])
+			source,
+			typeOnly
 		});
 	}
-	for (const match of code.matchAll(dynamicPattern)) {
-		if (!codePositions[match.index]) continue;
-		descriptors.push({
+	for (const match of blanked.matchAll(DYNAMIC_PATTERN)) {
+		const source = readSource(code, match);
+		if (source) descriptors.push({
 			kind: "dynamic",
 			syntax: "import",
-			source: match[2],
+			source,
 			typeOnly: false
 		});
 	}
-	for (const match of code.matchAll(requirePattern)) {
-		if (!codePositions[match.index]) continue;
-		descriptors.push({
+	for (const match of blanked.matchAll(REQUIRE_PATTERN)) {
+		const source = readSource(code, match);
+		if (source) descriptors.push({
 			kind: "dynamic",
 			syntax: "require",
-			source: match[2],
+			source,
 			typeOnly: false
 		});
 	}
-	for (const match of code.matchAll(sideEffectPattern)) {
-		if (!codePositions[match.index]) continue;
-		descriptors.push({
+	for (const match of blanked.matchAll(SIDE_EFFECT_PATTERN)) {
+		const source = readSource(code, match);
+		if (source) descriptors.push({
 			kind: "static",
 			syntax: "import",
-			source: match[2],
+			source,
 			typeOnly: false
 		});
 	}
 	return descriptors;
 }
+/**
+* Returns the JavaScript/TypeScript portion of a module for import scanning.
+* Vue and Svelte single-file components only contribute their `<script>`
+* blocks so template markup and styles are never misread as code.
+*/
+function getScannableModuleSource(id, code) {
+	if (!/\.(?:vue|svelte)(?:\?|$)/.test(id)) return code;
+	const blocks = [];
+	for (const match of code.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script(?:\s[^>]*)?>/gi)) blocks.push(match[1]);
+	return blocks.join("\n");
+}
 function findModuleImportSources(code) {
 	return Array.from(new Set(findModuleImportDescriptors(code).filter(({ syntax, typeOnly }) => syntax === "import" && !typeOnly).map(({ source }) => source)));
 }
@@ -573,6 +628,7 @@ function sanitizeDevEntryPath(devEntryPath) {
 */
 function rewriteEntryScripts(html, createProxySrc) {
 	return html.replace(/<script\b(?=[^>]*\btype=["']module["'])(?=[^>]*\bsrc=["'][^"']+["'])([^>]*)>/gi, (match, attrs) => {
+		if (/\svite-ignore(?:\s|=|\/|$)/i.test(attrs)) return match;
 		const srcMatch = attrs.match(/\bsrc=["']([^"']+)["']/i);
 		if (!srcMatch) return match;
 		const originalSrc = srcMatch[1];
@@ -617,6 +673,9 @@ function normalizeRemotes(remotes) {
 	});
 	return result;
 }
+function warnOmittedObjectRemoteType(remoteKey) {
+	mfWarn(`Remote "${remoteKey}" omits type and defaults to 'var'. Set type: 'module' for Vite ESM remotes, or type: 'var' explicitly to silence this warning.`);
+}
 function normalizeRemoteItem(key, remote) {
 	warnOnReservedInternalNamePrefix(key, "remoteAlias");
 	if (typeof remote === "string") {
@@ -639,6 +698,8 @@ function normalizeRemoteItem(key, remote) {
 			shareScope: "default"
 		};
 	}
+	const typeOmitted = remote.type === void 0 || remote.type === null || remote.type === "";
+	if (typeOmitted) warnOmittedObjectRemoteType(key);
 	return Object.assign({
 		type: "var",
 		name: key,
@@ -647,6 +708,7 @@ function normalizeRemoteItem(key, remote) {
 		entryGlobalName: key
 	}, {
 		...remote,
+		type: typeOmitted ? "var" : remote.type,
 		internalName: toInternalModuleFederationName(remote.name || key)
 	});
 }
@@ -662,7 +724,35 @@ function searchPackageVersion(sharedName) {
 }
 function inferVersionFromRequiredVersion(requiredVersion) {
 	if (typeof requiredVersion !== "string") return void 0;
-	return requiredVersion.match(/\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/)?.[0];
+	const isDigit = (char) => char !== void 0 && char >= "0" && char <= "9";
+	const isSuffixChar = (char) => char !== void 0 && (char >= "0" && char <= "9" || char >= "A" && char <= "Z" || char >= "a" && char <= "z" || char === "." || char === "-");
+	let index = 0;
+	while (index < requiredVersion.length) {
+		if (!isDigit(requiredVersion[index])) {
+			index += 1;
+			continue;
+		}
+		const start = index;
+		while (isDigit(requiredVersion[index])) index += 1;
+		if (requiredVersion[index] !== ".") continue;
+		index += 1;
+		if (!isDigit(requiredVersion[index])) continue;
+		while (isDigit(requiredVersion[index])) index += 1;
+		if (requiredVersion[index] !== ".") continue;
+		index += 1;
+		if (!isDigit(requiredVersion[index])) continue;
+		while (isDigit(requiredVersion[index])) index += 1;
+		if ((requiredVersion[index] === "-" || requiredVersion[index] === "+") && isSuffixChar(requiredVersion[index + 1])) {
+			index += 1;
+			while (isSuffixChar(requiredVersion[index])) index += 1;
+		}
+		return requiredVersion.slice(start, index);
+	}
+}
+/** URI-style package specifiers are not semver ranges for runtime satisfy(). */
+const PACKAGE_SPECIFIER_PROTOCOL_RE = /^[a-z][a-z\d+.-]*:/i;
+function isProtocolRequiredVersion(requiredVersion) {
+	return PACKAGE_SPECIFIER_PROTOCOL_RE.test(requiredVersion.trim());
 }
 function getLitExportSubpathShares(sharedName) {
 	if (sharedName !== "lit") return [];
@@ -691,6 +781,8 @@ function normalizeShareItem(key, shareItem) {
 			requiredVersion: version ? `^${version}` : "*"
 		}
 	};
+	const userRequiredVersion = shareItem.requiredVersion;
+	const keepUserRequiredVersion = userRequiredVersion === false || typeof userRequiredVersion === "string" && userRequiredVersion.trim() !== "" && !isProtocolRequiredVersion(userRequiredVersion);
 	return {
 		name: key,
 		from: "",
@@ -700,7 +792,7 @@ function normalizeShareItem(key, shareItem) {
 			import: shareItem.import,
 			singleton: shareItem.singleton || false,
 			eager: shareItem.eager || false,
-			requiredVersion: shareItem.requiredVersion !== void 0 ? shareItem.requiredVersion : isImportFalse || shareItem.version ? "*" : version ? `^${version}` : "*",
+			requiredVersion: keepUserRequiredVersion ? userRequiredVersion : isImportFalse || shareItem.version ? "*" : version ? `^${version}` : "*",
 			strictVersion: !!shareItem.strictVersion,
 			...shareItem.suppressMissingImportWarning ? { suppressMissingImportWarning: true } : {},
 			...treeShaking ? { treeShaking: { ...treeShaking } } : {}
@@ -719,9 +811,9 @@ function normalizeShareItem(key, shareItem) {
 * a prefix; concrete subpaths materialize on import via the generic matcher.
 *
 * `react-dom/` must keep collapsing. A browser-wide `react-dom/` prefix would
-* also capture `react-dom/server*`, which is unsafe without environment-aware
-* filtering. Browser-safe entries such as `react-dom/client` stay explicit via
-* COMMON_SHARED_SUBPATHS (local provider) or an exact shared key.
+* also capture `react-dom/server*`. Browser-safe entries (`react-dom/client`,
+* `react-dom/profiling`) stay via COMMON_SHARED_SUBPATHS (local provider) or
+* an exact shared key; SSR server* entries need an explicit shared key.
 */
 function normalizeSharedKey(key) {
 	if (!key.endsWith("/")) return key;
@@ -1265,6 +1357,49 @@ function loadReactIslandConsumerModule(id) {
 function getVirtualModuleScopeKey(options) {
 	return `${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
+function compareConfigValues(a, b) {
+	const serializedA = JSON.stringify(a);
+	const serializedB = JSON.stringify(b);
+	return serializedA < serializedB ? -1 : serializedA > serializedB ? 1 : 0;
+}
+function stableConfigValue(value, ancestors = /* @__PURE__ */ new WeakSet()) {
+	if (typeof value === "function") return value.toString();
+	if (!value || typeof value !== "object") return value;
+	if (value instanceof Date) return {
+		type: "Date",
+		value: value.toISOString()
+	};
+	if (value instanceof RegExp) return {
+		type: "RegExp",
+		source: value.source,
+		flags: value.flags
+	};
+	if (ancestors.has(value)) return "__circular__";
+	ancestors.add(value);
+	let result;
+	if (value instanceof Map) {
+		const entries = [...value.entries()].map(([key, item]) => [stableConfigValue(key, ancestors), stableConfigValue(item, ancestors)]);
+		entries.sort(compareConfigValues);
+		result = {
+			type: "Map",
+			entries
+		};
+	} else if (value instanceof Set) {
+		const values = [...value].map((item) => stableConfigValue(item, ancestors));
+		values.sort(compareConfigValues);
+		result = {
+			type: "Set",
+			values
+		};
+	} else result = Array.isArray(value) ? value.map((item) => stableConfigValue(item, ancestors)) : Object.fromEntries(Object.entries(value).filter(([key]) => key !== "implementation").sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => [key, stableConfigValue(item, ancestors)]));
+	ancestors.delete(value);
+	return result;
+}
+function getFederationScopeKey(options) {
+	const identity = JSON.stringify(stableConfigValue(options));
+	const ownerId = BigInt(`0x${createHash("sha256").update(identity).digest("hex").slice(0, 12)}`);
+	return `${options.internalName}${MF_OWNER_INFIX}${ownerId}`;
+}
 //#endregion
 //#region src/virtualModules/virtualExposes.ts
 const EXPOSES_CSS_MAP_PLACEHOLDER = "__MF_EXPOSES_CSS_MAP__";
@@ -1414,28 +1549,17 @@ function isReactServerConditions(conditions) {
 //#region src/virtualModules/virtualRuntimeInitStatus.ts
 const virtualRuntimeInitStatus = new VirtualModule("runtimeInit");
 const runtimeInitModules = /* @__PURE__ */ new WeakMap();
-const runtimeInitOwnerIds = /* @__PURE__ */ new WeakMap();
-let nextRuntimeInitOwnerId = 1;
 const MODULE_CACHE_GLOBAL_KEY = "__mf_module_cache__";
 const REACT_SERVER_MODULE_CACHE_GLOBAL_KEY = "__mf_module_cache_react_server__";
 const MODULE_CACHE_SHARE_SCOPE_KEY = "module-federation.vite-module-cache";
 function getModuleCacheGlobalKey(exportConditions) {
 	return isReactServerConditions(exportConditions) ? REACT_SERVER_MODULE_CACHE_GLOBAL_KEY : MODULE_CACHE_GLOBAL_KEY;
 }
-function getRuntimeInitOwnerId(options) {
-	let ownerId = runtimeInitOwnerIds.get(options);
-	if (!ownerId) {
-		ownerId = nextRuntimeInitOwnerId++;
-		runtimeInitOwnerIds.set(options, ownerId);
-	}
-	return ownerId;
-}
 function getRuntimeInitModule(options) {
 	if (!options) return virtualRuntimeInitStatus;
 	let runtimeInitModule = runtimeInitModules.get(options);
 	if (!runtimeInitModule) {
-		const ownerId = getRuntimeInitOwnerId(options);
-		runtimeInitModule = new VirtualModule("runtimeInit", "__mf_v__", "", `${options.internalName}${MF_OWNER_INFIX}${ownerId}`);
+		runtimeInitModule = new VirtualModule("runtimeInit", "__mf_v__", "", getFederationScopeKey(options));
 		runtimeInitModules.set(options, runtimeInitModule);
 	}
 	return runtimeInitModule;
@@ -1448,7 +1572,7 @@ function getRuntimeRemoteCachePrefix(options) {
 }
 function getRuntimeRemoteAlias(alias, options) {
 	if (!options) return alias;
-	return `${options.internalName}${MF_OWNER_INFIX}${getRuntimeInitOwnerId(options)}__${alias}`;
+	return `${getFederationScopeKey(options)}__${alias}`;
 }
 function getRuntimeInitGlobalKey(ownerImportId) {
 	return `__mf_init__${ownerImportId ?? virtualRuntimeInitStatus.getImportId()}__`;
@@ -1538,6 +1662,16 @@ globalThis[__mfCacheGlobalKey] ||= { share: {}, remote: {} };
 globalThis[__mfCacheGlobalKey].share ||= {};
 globalThis[__mfCacheGlobalKey].remote ||= {};
 const __mfModuleCache = globalThis[__mfCacheGlobalKey];
+const __mfTrackPendingShareLoad = (promise) => {
+  const pendingShareLoads = (__mfModuleCache.pendingShareLoads ||= []);
+  pendingShareLoads.push(promise);
+  const cleanup = () => {
+    const index = pendingShareLoads.indexOf(promise);
+    if (index !== -1) pendingShareLoads.splice(index, 1);
+  };
+  void promise.then(cleanup, cleanup);
+  return promise;
+};
 for (const __mfShareKey of Object.keys(__mfModuleCache.share)) {
   if (__mfShareKey.startsWith("default:")) {
     const __mfLegacyShareKey = __mfShareKey.slice("default:".length);
@@ -2218,6 +2352,14 @@ function getAdditionalTopLevelDeclaratorNames(source, start, codePositions) {
 			canStartRegex = false;
 			continue;
 		}
+		if (char === "<" && source[index + 1] === "/") {
+			const jsxClosingTag = source.slice(index).match(/^<\/\s*(?:[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}.:-]*\s*)?>/u);
+			if (jsxClosingTag) {
+				index += jsxClosingTag[0].length - 1;
+				canStartRegex = false;
+				continue;
+			}
+		}
 		if (char === "/" && source[index + 1] === "/") {
 			index = source.indexOf("\n", index + 2);
 			if (index === -1) return names;
@@ -2454,6 +2596,9 @@ function getNamedExportsViaRegex(source, filePath, visited, scanState = { comple
 		let previousCodeIndex = match.index - 1;
 		while (previousCodeIndex >= 0 && (/\s/.test(source[previousCodeIndex]) || !codePositions[previousCodeIndex])) previousCodeIndex--;
 		if (source[previousCodeIndex] === ".") continue;
+		let nextCodeIndex = match.index + match[0].length;
+		while (/\s/.test(source[nextCodeIndex] || "")) nextCodeIndex++;
+		if (source[nextCodeIndex] === "(") continue;
 		scanState.complete = false;
 		break;
 	}
@@ -2692,7 +2837,6 @@ const legacySharedVirtualModuleState = {
 	warnedMissingImportFalse: /* @__PURE__ */ new Set()
 };
 const sharedVirtualModuleStates = /* @__PURE__ */ new WeakMap();
-let nextSharedVirtualModuleOwnerId = 1;
 function getSharedVirtualModuleState(options) {
 	if (!options) try {
 		const currentOptions = getNormalizeModuleFederationOptions();
@@ -2709,7 +2853,7 @@ function getSharedVirtualModuleState(options) {
 			materializedTreeShakingProviders: /* @__PURE__ */ new Set(),
 			loadShareCacheMap: {},
 			warnedMissingImportFalse: /* @__PURE__ */ new Set(),
-			ownerKey: `${options.internalName}${MF_OWNER_INFIX}${nextSharedVirtualModuleOwnerId++}`
+			ownerKey: getFederationScopeKey(options)
 		};
 		sharedVirtualModuleStates.set(options, state);
 	}
@@ -3008,7 +3152,7 @@ function generateLazyWorkspaceSingletonExports(namedExports, importSource, cache
       if (import.meta.env.SSR${serveLocalFallback ? " || (import.meta.env.DEV && typeof __mfLocalShare !== 'undefined')" : ""}) {
         ${applyLocalFallback}
       } else {
-        (__mfModuleCache.pendingShareLoads ||= []).push(initPromise.then(() => {
+        __mfTrackPendingShareLoad(initPromise.then(() => {
           exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
           if (exportModule !== undefined) {
             __mfApplyLazyShareExports(exportModule);
@@ -3053,7 +3197,7 @@ function generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor,
     };
     let exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
     if (exportModule === undefined) {
-      (__mfModuleCache.pendingShareLoads ||= []).push(initPromise.then(() => {
+      __mfTrackPendingShareLoad(initPromise.then(() => {
         exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
         if (exportModule === undefined) {
           throw new Error("[Module Federation] Shared module ${pkg} was imported before federation bootstrap finished.");
@@ -3140,10 +3284,10 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	const hasCompleteExportCoverage = detectedNamedExports !== void 0;
 	const isWorkspaceSingleton = isWorkspacePackage && shareItem.shareConfig.singleton === true;
 	const isDefaultShareScope = shareItem.scope === void 0 || shareItem.scope === "default" || Array.isArray(shareItem.scope) && shareItem.scope[0] === "default";
-	const usesDeferredSingletonFallback = hasCompleteExportCoverage && (isWorkspacePackage || command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true || command === "build" && isRemoteOnlyContainer(resolvedOptions) && (shareItem.shareConfig.singleton === true ? !isDefaultShareScope : isDefaultShareScope));
+	const usesDeferredSingletonFallback = hasCompleteExportCoverage && shareItem.shareConfig.eager !== true && (isWorkspacePackage || command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true || command === "build" && isRemoteOnlyContainer(resolvedOptions) && (shareItem.shareConfig.singleton === true || isDefaultShareScope));
 	const servesRemoteSingletonFallback = command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true;
 	const isConsumedByPeerSingleton = isSharedSingletonConsumedByPeer(pkg, resolvedOptions);
-	const usesEntryInjectedRemoteFallback = hasCompleteExportCoverage && command !== "build" && !isWorkspaceSingleton && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true && resolvedOptions.hostInitInjectLocation === "entry" && isConsumedByPeerSingleton;
+	const usesEntryInjectedRemoteFallback = hasCompleteExportCoverage && !isWorkspaceSingleton && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true && resolvedOptions.hostInitInjectLocation === "entry" && (command === "build" || isConsumedByPeerSingleton);
 	const usesEagerWorkspaceFallback = hasCompleteExportCoverage && isWorkspaceSingleton && !servesRemoteSingletonFallback && (isConsumedByPeerSingleton || shareItem.shareConfig.eager === true);
 	const usesDeferredTreeShakingFallback = hasCompleteExportCoverage && Boolean(treeShakingConsumer);
 	const reactMixedModeGuard = pkg === "react" ? createReactMixedModeRuntimeGuard() : "";
@@ -3432,12 +3576,24 @@ function generateLocalSharedImportMap(options) {
       }
       `;
 }
+/** Expand `pkg/` → package root + matching usedShares; never returns the prefix string. */
+function expandSharedPrefixKey(prefixKey, used) {
+	const base = prefixKey.slice(0, -1);
+	const expanded = /* @__PURE__ */ new Set([base]);
+	for (const pkg of used) {
+		if (pkg.endsWith("/")) continue;
+		if (pkg === base || pkg.startsWith(`${base}/`)) expanded.add(pkg);
+	}
+	return [...expanded];
+}
 function getOrderedUsedShares(options) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
-	const shares = new Set(getUsedShares(options));
+	const used = getUsedShares(options);
+	const shares = new Set(used);
 	Object.keys(resolvedOptions.shared ?? {}).forEach((pkg) => {
 		if (!pkg.endsWith("/")) shares.add(pkg);
 	});
+	for (const [pkg, share] of Object.entries(resolvedOptions.shared ?? {})) if (pkg.endsWith("/") && share.shareConfig?.eager) for (const concrete of expandSharedPrefixKey(pkg, used)) shares.add(concrete);
 	return orderSharedDependenciesFirst(Array.from(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);
@@ -3447,7 +3603,12 @@ 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 usedForEager = options ? usedSharesByOptions.get(options) ?? [] : usedShares;
+	for (const [pkg, share] of Object.entries(resolvedOptions.shared ?? {})) {
+		if (!share.shareConfig?.eager) continue;
+		if (pkg.endsWith("/")) for (const concrete of expandSharedPrefixKey(pkg, usedForEager)) shares.add(concrete);
+		else shares.add(pkg);
+	}
 	const configured = /* @__PURE__ */ new Map();
 	for (const pkg of getOrderedUsedShares(options)) {
 		const packageName = getPackageName(pkg);
@@ -3620,8 +3781,16 @@ const sharedProviderSelectionHelperCode = `const __mfOriginalProviderKey = Symbo
             strategy
           ) => {
             if (!versions || !share) return undefined;
+            // import:false stubs provide nothing, so they are never a selectable
+            // provider and must not be satisfy-checked. Skip the runtime entirely
+            // when nothing remains: it treats an empty map as version "0" and
+            // warns that it fails even a "*" requirement.
+            const candidates = Object.fromEntries(
+              Object.entries(versions).filter(([, provider]) => provider?.shareConfig?.import !== false)
+            );
+            if (Object.keys(candidates).length === 0) return undefined;
             const scopes = Array.isArray(share.scope) ? share.scope : [share.scope || "default"];
-            const selectionVersions = __mfCreateProviderSelectionVersions(versions, strategy);
+            const selectionVersions = __mfCreateProviderSelectionVersions(candidates, strategy);
             const shareScopeMap = {};
             for (const scope of scopes) {
               shareScopeMap[scope || "default"] = { [pkg]: selectionVersions };
@@ -4190,7 +4359,21 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       }
       return runtimeScope;
     };
+    // runtimeInit() lets runtime plugins register providers (public
+    // registerShared) before initShareScopeMap() replaces the runtime's own
+    // scope map. Carry those registrations over; the runtime's own copies of
+    // usedShared keep registering lazily through loadShare().
+    const __mfKeepRegisteredShares = (scopeName, scope) => {
+      for (const [pkg, versions] of Object.entries(initRes.shareScopeMap?.[scopeName] || {})) {
+        for (const [version, provider] of Object.entries(versions || {})) {
+          if (!provider || provider.get === usedShared[pkg]?.get) continue;
+          const target = scope[pkg] ||= {};
+          if (target[version] === undefined) target[version] = provider;
+        }
+      }
+    };
     const __mfGetRuntimeShareScope = (scopeName, hostScope) => {
+      __mfKeepRegisteredShares(scopeName, hostScope);
       const isWebpackScope = !scopeRoot && Object.values(hostScope || {}).some((versions) =>
         Object.values(versions || {}).some(isWebpackProvider)
       );
@@ -4586,6 +4769,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
         );
         const providerEntry = __mfFindSharedProviderEntry(versionMap, provider);
         if (!providerEntry) return;
+        if (usedShare.shareConfig?.import === false && __mfMatchesSharedProvider(provider, usedShare)) return;
         const { version } = providerEntry;
         if (!singleton && version !== usedShare.version) return;
         if (
@@ -4699,6 +4883,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
           scopeRootProvider: undefined
         };
         if (usedShare.canLiveRebind === false) return;
+        if (usedShare.shareConfig?.import === false && __mfMatchesSharedProvider(provider, usedShare)) return;
         // Preserve a singleton already selected by another container. The bridge may
         // only replace the provisional local fallback seeded by this container.
         if (cachedShare !== undefined && cachedShareOwner !== mfName) return;
@@ -4865,6 +5050,11 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
       ) || share;
       const providerEntry = __mfFindSharedProviderEntry(versionMap, provider);
       if (!providerEntry) return;
+      // A provider registered on this instance through the public registerShared
+      // API carries this container's own name, so tell the own stub apart by its
+      // import:false config rather than by provenance.
+      const __mfIsOwnStub = (candidate) => candidate === share || candidate?.shareConfig?.import === false;
+      if (__mfIsOwnStub(provider)) return;
       const { version } = providerEntry;
       const currentProvider = versionMap?.[version];
       const loadedShare = await __mfLoadPinnedRuntimeShare(
@@ -4874,13 +5064,13 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
         version,
         currentProvider,
         provider,
-        providerEntry.registered && !__mfMatchesSharedProvider(provider, share)
+        providerEntry.registered
       );
       const providerSelection = loadedShare?.selection;
       const actualProvider = loadedShare?.provider;
       const resolved = loadedShare?.resolved;
       if (!providerSelection) return;
-      if (__mfMatchesSharedProvider(actualProvider, share)) return;
+      if (__mfIsOwnStub(actualProvider)) return;
       if (resolved === undefined) return;
       const latestCachedShare = share.treeShaking
         ? __mfReadTreeShakingSharedSelection(__mfModuleCache.share, cacheDescriptor, mfName)
@@ -5021,6 +5211,16 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build", options
                 __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== undefined &&
                 __mfReadSharedCacheOwner(__mfModuleCache.share, cacheDescriptor) ${_command === "serve" ? "!== undefined" : `=== ${cacheOwner}`}
               ) return;
+              // An import:false share has nothing to load until a foreign provider
+              // registers: its own stub getter throws by construction.
+              if (
+                share.shareConfig?.import === false &&
+                !(Array.isArray(share.scope) ? share.scope : [share.scope || 'default']).some((scopeName) =>
+                  Object.values(runtime.shareScopeMap?.[scopeName]?.[pkg] || {}).some(
+                    (provider) => provider?.shareConfig?.import !== false
+                  )
+                )
+              ) return;
               await runtime.loadShare(pkg, {
                 customShareInfo: { shareConfig: share.shareConfig }
               }).then(async (factory) => {
@@ -5122,6 +5322,7 @@ const usedRemotesMap = {};
 const usedRemotesByOptions = /* @__PURE__ */ new WeakMap();
 const dynamicRemotesByOptions = /* @__PURE__ */ new WeakMap();
 const staticRemotesByOptions = /* @__PURE__ */ new WeakMap();
+const preloadRemotesByOptions = /* @__PURE__ */ new WeakMap();
 const EMPTY_STATIC_REMOTES = /* @__PURE__ */ new Set();
 function getScopedUsedRemotesMap(options) {
 	let scoped = usedRemotesByOptions.get(options);
@@ -5159,8 +5360,16 @@ function markStaticRemote(remote, options) {
 	}
 	remotes.add(remote);
 }
-function getStaticRemotes(options) {
-	return staticRemotesByOptions.get(options) ?? EMPTY_STATIC_REMOTES;
+function markPreloadRemote(remote, options) {
+	let remotes = preloadRemotesByOptions.get(options);
+	if (!remotes) {
+		remotes = /* @__PURE__ */ new Set();
+		preloadRemotesByOptions.set(options, remotes);
+	}
+	remotes.add(remote);
+}
+function getPreloadRemotes(options) {
+	return preloadRemotesByOptions.get(options) ?? EMPTY_STATIC_REMOTES;
 }
 function isDynamicOnlyRemote(remote, options) {
 	return (dynamicRemotesByOptions.get(options)?.has(remote) ?? false) && !(staticRemotesByOptions.get(options)?.has(remote) ?? false);
@@ -5660,7 +5869,7 @@ const __mfCurrentScript = document.currentScript;
 		const normalizedOptions = federationOptions ?? getNormalizeModuleFederationOptions();
 		const isLoadedFirstClientBuild = (_command === "build" || viteConfig?.command === "build") && waitsForInit && !viteConfig?.build?.ssr && normalizedOptions.shareStrategy === "loaded-first";
 		if (normalizedOptions.shareStrategy === "loaded-first" && !isLoadedFirstClientBuild) return [];
-		const remoteSources = isLoadedFirstClientBuild ? Array.from(getStaticRemotes(normalizedOptions)) : Object.entries(getUsedRemotesMap(federationOptions)).flatMap(([, remotes]) => Array.from(remotes)).filter((remote) => !federationOptions || !isDynamicOnlyRemote(remote, federationOptions));
+		const remoteSources = isLoadedFirstClientBuild ? Array.from(getPreloadRemotes(normalizedOptions)) : Object.entries(getUsedRemotesMap(federationOptions)).flatMap(([, remotes]) => Array.from(remotes)).filter((remote) => !federationOptions || !isDynamicOnlyRemote(remote, federationOptions));
 		return Array.from(new Set(remoteSources.flatMap((remote) => {
 			const registration = getRemoteRegistration(remote, normalizedOptions.remotes, federationOptions);
 			return registration && (registration.type === "module" || registration.type === "esm") && /^(?:https?:)?\/\//.test(registration.entry) ? [registration.entry] : [];
@@ -5680,7 +5889,7 @@ const __mfCurrentScript = document.currentScript;
 		const normalizedOptions = federationOptions ?? getNormalizeModuleFederationOptions();
 		const isLoadedFirstClientBuild = (_command === "build" || viteConfig?.command === "build") && waitsForInit && !viteConfig?.build?.ssr && normalizedOptions.shareStrategy === "loaded-first";
 		const shouldPreloadRemotes = !options?.skipRemotePreload && (normalizedOptions.shareStrategy !== "loaded-first" || isLoadedFirstClientBuild);
-		const remoteSources = isLoadedFirstClientBuild ? Array.from(getStaticRemotes(normalizedOptions)) : Object.entries(getUsedRemotesMap(federationOptions)).flatMap(([, remotes]) => Array.from(remotes)).filter((remote) => !federationOptions || !isDynamicOnlyRemote(remote, federationOptions));
+		const remoteSources = isLoadedFirstClientBuild ? Array.from(getPreloadRemotes(normalizedOptions)) : Object.entries(getUsedRemotesMap(federationOptions)).flatMap(([, remotes]) => Array.from(remotes)).filter((remote) => !federationOptions || !isDynamicOnlyRemote(remote, federationOptions));
 		const remotePreloads = shouldPreloadRemotes ? remoteSources.sort().map((remote) => {
 			const registration = isLoadedFirstClientBuild ? getRemoteRegistration(remote, normalizedOptions.remotes, federationOptions) : void 0;
 			return `__mfPreloadRemote(${JSON.stringify(getRuntimeRemoteId(remote, normalizedOptions.remotes, federationOptions))}, ${JSON.stringify(remote)}${registration ? `, ${JSON.stringify(registration)}` : ""})`;
@@ -5922,6 +6131,10 @@ for (const __mfRemoteEntryPrefetchUrl of __mfRemoteEntryPrefetchUrls) {
 			else if (Array.isArray(inputOptions)) entryFiles = inputOptions.filter((input) => !isReactRouterClientRouteInput(String(input))).map(resolveProjectId);
 			else if (typeof inputOptions === "object") entryFiles = Object.values(inputOptions).filter((input) => !isReactRouterClientRouteInput(String(input))).map((input) => resolveProjectId(String(input)));
 			if (entryFiles.length > 0) htmlFilePath = getFirstHtmlEntryFile(entryFiles);
+			if (config.command === "serve" && !htmlFilePath) {
+				const rootIndexHtml = path$1.resolve(config.root, "index.html");
+				if (fs$2.existsSync(rootIndexHtml)) htmlFilePath = rootIndexHtml;
+			}
 			if (htmlFilePath) addHtmlScriptEntries(htmlFilePath);
 		},
 		buildStart() {
@@ -7028,8 +7241,30 @@ function getRemoteEntrySSRId(options) {
 	return `${REMOTE_ENTRY_SSR_ID}:${getVirtualModuleScopeKey(options)}`;
 }
 function getSsrRemoteEntryFileName(browserFilename) {
-	const ext = browserFilename.match(/\.[^.]+$/)?.[0] || ".js";
-	return `${browserFilename.slice(0, browserFilename.length - ext.length)}.ssr${ext}`;
+	let filename = browserFilename;
+	if (filename.includes("[hash")) {
+		filename = filename.replace(/(?:[._-]?\[hash(?::\d+)?\])/g, "");
+		if (!/\.[^.]+$/.test(filename)) filename = `${filename}.js`;
+	}
+	const ext = filename.match(/\.[^.]+$/)?.[0] || ".js";
+	return `${filename.slice(0, filename.length - ext.length)}.ssr${ext}`;
+}
+/** Singleton map for SSR loadShare: expand `pkg/` via usedShares; never serialize the prefix. */
+function getSsrSharedSingletons(options) {
+	const used = getUsedShares(options);
+	const result = {};
+	for (const [pkg, share] of Object.entries(options.shared)) {
+		if (!share.shareConfig.singleton) continue;
+		if (pkg.endsWith("/")) {
+			for (const concrete of expandSharedPrefixKey(pkg, used)) result[concrete] = {
+				...share,
+				name: concrete
+			};
+			continue;
+		}
+		result[pkg] = share;
+	}
+	return result;
 }
 /**
 * Generates the SSR remote entry module.
@@ -7043,7 +7278,7 @@ function getSsrRemoteEntryFileName(browserFilename) {
 */
 function generateRemoteEntrySSR(options) {
 	const virtualExposesSSRId = getVirtualExposesSSRId(options);
-	const sharedSingletons = Object.fromEntries(Object.entries(options.shared).filter(([, share]) => share.shareConfig.singleton));
+	const sharedSingletons = getSsrSharedSingletons(options);
 	return `
   import { init as runtimeInit } from "@module-federation/runtime";
 
@@ -7398,7 +7633,7 @@ const Manifest = (providedOptions) => {
 			if (this.environment?.name === "ssr") return;
 			let filesMap = {};
 			const foundRemoteEntryFile = findRemoteEntryFile(mfOptions.filename, bundle);
-			const expectedSsrRemoteEntryFile = getSsrRemoteEntryFileName(foundRemoteEntryFile || mfOptions.filename);
+			const expectedSsrRemoteEntryFile = getSsrRemoteEntryFileName(mfOptions.filename);
 			const foundSsrRemoteEntryFile = Object.values(bundle).find((file) => file.fileName === expectedSsrRemoteEntryFile)?.fileName;
 			if (foundRemoteEntryFile) remoteEntryFile = foundRemoteEntryFile;
 			ssrRemoteEntryFile = foundSsrRemoteEntryFile || (_command === "serve" ? getSsrRemoteEntryFileName(resolveDevRemoteEntryFileName(mfOptions.filename)) : expectedSsrRemoteEntryFile);
@@ -7788,12 +8023,10 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 	}
 	function collectImportSources(code) {
 		const sources = /* @__PURE__ */ new Map();
-		for (const match of code.matchAll(/(?:^|[;\n\r])\s*import\s+(?:[\s\S]*?\s+from\s+)?["']([^"']+)["']|import\(\s*["']([^"']+)["']\s*\)/g)) {
-			const source = match[1] || match[2];
-			if (source) {
-				const dynamic = !match[1];
-				sources.set(source, (sources.get(source) ?? true) && dynamic);
-			}
+		for (const { source, kind, syntax, typeOnly } of findModuleImportDescriptors(code)) {
+			if (syntax !== "import" || typeOnly) continue;
+			const dynamic = kind === "dynamic";
+			sources.set(source, (sources.get(source) ?? true) && dynamic);
 		}
 		return Array.from(sources, ([source, dynamic]) => ({
 			source,
@@ -7810,7 +8043,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		seen.add(id);
 		let code;
 		try {
-			code = readFileSync$1(id, "utf8");
+			code = getScannableModuleSource(id, readFileSync$1(id, "utf8"));
 		} catch {
 			return [];
 		}
@@ -8205,6 +8438,35 @@ function excludeSharedSubDependencies(shared) {
 		}
 	}
 }
+const sharedDependencyCache = /* @__PURE__ */ new Map();
+/** Whether `dependency` is reachable through the shared package's manifest dependencies. */
+function isSharedPackageDependency(sharedKey, dependency) {
+	const sharedPackage = getPackageName(sharedKey);
+	let reachable = sharedDependencyCache.get(sharedPackage);
+	if (!reachable) {
+		reachable = /* @__PURE__ */ new Set();
+		const visited = /* @__PURE__ */ new Set();
+		const queue = [getInstalledPackageJson(sharedPackage, { packageName: sharedPackage })];
+		for (let installed = queue.shift(); installed; installed = queue.shift()) {
+			if (visited.has(installed.dir)) continue;
+			visited.add(installed.dir);
+			const manifest = installed.packageJson;
+			for (const dep of Object.keys({
+				...manifest.dependencies,
+				...manifest.peerDependencies,
+				...manifest.optionalDependencies
+			})) {
+				reachable.add(dep);
+				queue.push(getInstalledPackageJson(dep, {
+					cwd: installed.dir,
+					packageName: dep
+				}));
+			}
+		}
+		sharedDependencyCache.set(sharedPackage, reachable);
+	}
+	return reachable.has(dependency);
+}
 function proxySharedModule(options) {
 	const { shared = {}, federationOptions, getParsePromise = () => Promise.resolve() } = options;
 	let _config;
@@ -8286,6 +8548,7 @@ function proxySharedModule(options) {
 				setTreeShakingBuildMode(command === "build", federationOptions);
 				resetTreeShakingExports(federationOptions);
 				emittedTreeShakingProviders.clear();
+				sharedDependencyCache.clear();
 				const isVinext = hasPackageDependency("vinext");
 				const isAstro = hasPackageDependency("astro");
 				const isRolldown = getIsRolldown(this);
@@ -8374,6 +8637,9 @@ function proxySharedModule(options) {
 				}
 				const key = findSharedKeyForSource(source, shared);
 				if (!key) return;
+				const importerPackage = importer ? getPackageNameFromNodeModulePath(importer) : void 0;
+				if (importerPackage === getPackageName(key)) return;
+				if (importerPackage && isSharedPackageDependency(key, importerPackage)) return;
 				if (useDirectReactImport && key === "react") return;
 				if (isAssetLikeImport(source)) return;
 				if (isBuildConfigImporter(importer)) return;
@@ -9562,7 +9828,7 @@ function registerEntryImports(options, projectRoot, recordShared = true, entryFi
 		const { file, preloadRemotes } = pending.pop();
 		if (visited.get(file) || visited.has(file) && !preloadRemotes) continue;
 		visited.set(file, preloadRemotes);
-		const code = readFileSync(file, "utf8");
+		const code = getScannableModuleSource(file, readFileSync(file, "utf8"));
 		for (const { source: request, kind, typeOnly } of findModuleImportDescriptors(code)) {
 			const isStatic = kind === "static" && !typeOnly;
 			const remoteKey = preloadRemotes && isStatic && request ? Object.keys(options.remotes).find((name) => request === name || request.startsWith(`${name}/`)) : void 0;
@@ -9570,6 +9836,7 @@ function registerEntryImports(options, projectRoot, recordShared = true, entryFi
 			if (remoteKey) {
 				addUsedRemote(remoteKey, request, options);
 				markStaticRemote(request, options);
+				markPreloadRemote(request, options);
 			} else if (sharedKey && recordShared) addUsedShares(request, options);
 			else if (request && !typeOnly) enqueue(request, file, preloadRemotes && isStatic);
 		}
@@ -9743,7 +10010,11 @@ export default __mfShared.default ?? __mfShared;`
 						else optimizeDeps.include.push(key);
 						for (const subpath of getCommonSharedSubpaths(key)) {
 							const canResolveSubpath = canResolveSharedSubpath(subpath, root);
-							if (["react/compiler-runtime", "react-dom/client"].includes(subpath) && !canResolveSubpath) {
+							if ([
+								"react/compiler-runtime",
+								"react-dom/client",
+								"react-dom/profiling"
+							].includes(subpath) && !canResolveSubpath) {
 								optimizeDeps.exclude.push(subpath);
 								continue;
 							}
@@ -9812,7 +10083,7 @@ function applyBuildTimeRuntimeDefines(define, options, { target, isAstro, defaul
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-sJeW2nss.js").then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-C2bUY8h9.js").then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {

package/lib/{pathNormalization-DvgU8LIp.js → pathNormalization-CHct3UwV.js}

@@ -5,11 +5,7 @@ const COMMON_SHARED_SUBPATHS = {
 		"react/jsx-dev-runtime",
 		"react/compiler-runtime"
 	],
-	"react-dom": [
-		"react-dom/client",
-		"react-dom/server",
-		"react-dom/server.browser"
-	],
+	"react-dom": ["react-dom/client", "react-dom/profiling"],
 	"solid-js": [
 		"solid-js/web",
 		"solid-js/store",

package/lib/{pluginDts-sJeW2nss.js → pluginDts-C2bUY8h9.js}

@@ -1,5 +1,5 @@
 import { n as normalizePathForImport } from "./buildPaths-BkaQHrd2.js";
-import { _ as mfError, g as createModuleFederationError, l as hasPackageDependency, p as resolveImportPath } from "./dtsConstants-DyJrx8ah.js";
+import { _ as mfError, g as createModuleFederationError, l as hasPackageDependency, p as resolveImportPath } from "./dtsConstants-CScOzmdO.js";
 import fs from "fs";
 import * as path$1 from "node:path";
 import os from "os";

package/lib/{ssrEntryLoader-0NnTjWR1.js → ssrEntryLoader-BMtjS_Vl.js}

@@ -606,7 +606,7 @@ async function importTempModule(filePath, versionKey) {
 }
 let warnedVmUnavailable = false;
 async function tryVmStrategy(ssrEntry, options) {
-	const { loadViaVmStrategy, isVmStrategyAvailable } = await import("./ssrVmStrategy-B0fCaHs5.js");
+	const { loadViaVmStrategy, isVmStrategyAvailable } = await import("./ssrVmStrategy-tpI6we9Q.js");
 	if (!await isVmStrategyAvailable()) {
 		if (!warnedVmUnavailable) {
 			warnedVmUnavailable = true;

package/lib/{ssrVmStrategy-B0fCaHs5.js → ssrVmStrategy-tpI6we9Q.js}

@@ -1,5 +1,5 @@
-import { a as getCommonSharedSubpaths } from "./pathNormalization-DvgU8LIp.js";
-import { c as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, s as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-0NnTjWR1.js";
+import { a as getCommonSharedSubpaths } from "./pathNormalization-CHct3UwV.js";
+import { c as readResponseTextBounded, n as neutralizeBrowserPreloadHelpers, s as fetchWithTimeout, t as SsrEntryHttpError } from "./ssrEntryLoader-BMtjS_Vl.js";
 //#region src/utils/ssrVmStrategy.ts
 /**
 * vm.SourceTextModule strategy for loading remote SSR entries.

package/lib/utils/ssrEntryLoader.js

@@ -1,2 +1,2 @@
-import { i as ssrEntryLoaderPlugin, n as neutralizeBrowserPreloadHelpers, r as revalidate, t as SsrEntryHttpError } from "../ssrEntryLoader-0NnTjWR1.js";
+import { i as ssrEntryLoaderPlugin, n as neutralizeBrowserPreloadHelpers, r as revalidate, t as SsrEntryHttpError } from "../ssrEntryLoader-BMtjS_Vl.js";
 export { SsrEntryHttpError, ssrEntryLoaderPlugin as default, neutralizeBrowserPreloadHelpers, revalidate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/vite",
-  "version": "1.21.1",
+  "version": "1.21.3",
   "description": "Vite plugin for Module Federation",
   "type": "module",
   "main": "./lib/index.js",
@@ -28,7 +28,7 @@
     "lib/**/*"
   ],
   "scripts": {
-    "prepare": "husky install",
+    "prepare": "husky",
     "fmt": "oxfmt src",
     "fmt.check": "oxfmt --check src",
     "dev": "tsdown --watch",
@@ -93,4 +93,4 @@
     "vite": "8.2.0",
     "vitest": "4.1.10"
   }
-}
+}