@module-federation/vite 1.21.2 → 1.21.3

package/README.md

@@ -304,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,5 +1,5 @@
 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 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";
@@ -502,68 +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;
-	let match;
-	while (match = staticFromPattern.exec(code)) {
-		if (!codePositions[match.index]) {
-			staticFromPattern.lastIndex = match.index + 1;
-			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)));
 }
@@ -673,7 +724,30 @@ 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;
@@ -1283,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__";
@@ -1432,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;
@@ -1466,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()}__`;
@@ -1556,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);
@@ -2236,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;
@@ -2472,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;
 	}
@@ -2710,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();
@@ -2727,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);
 	}
@@ -3026,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);
@@ -3071,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.");
@@ -3158,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() : "";
@@ -3655,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 };
@@ -4225,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)
       );
@@ -4621,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 (
@@ -4734,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;
@@ -4900,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(
@@ -4909,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)
@@ -5056,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) => {
@@ -5966,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() {
@@ -7854,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,
@@ -7876,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 [];
 		}
@@ -8271,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;
@@ -8352,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);
@@ -8440,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;
@@ -9628,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;
@@ -9883,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/{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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/vite",
-  "version": "1.21.2",
+  "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",