@module-federation/vite 1.20.0 → 1.20.2

package/lib/index.js

@@ -1,7 +1,6 @@
-import { _ as createModuleFederationError, a as getIsRolldown, b as rebaseImport, c as getPackageNameFromNodeModulePath, d as isNuxtProjectRoot, f as packageNameDecode, g as sharedCacheHelperCode, h as setPackageDetectionCwd, i as getInstalledPackageJson, l as getSharedCacheDescriptor, m as resolveImportPath, o as getPackageDetectionCwd, p as packageNameEncode, r as getInstalledPackageEntry, s as getPackageName, u as hasPackageDependency, v as mfWarn, y as normalizePathForImport } from "./pluginDts-Dbbi4cnh.js";
 import { createRequire } from "node:module";
 import * as fs$2 from "fs";
-import { existsSync, readFileSync, realpathSync, statSync, writeFileSync } from "fs";
+import fs, { existsSync, readFileSync, readdirSync, 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";
@@ -11,9 +10,71 @@ 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/buildPaths.ts
+/**
+* Rebase an import path for a bootstrap file that moved from root into `dir`.
+*
+* When entryFileNames places entries in a subdirectory (e.g. `static/js/`),
+* the bootstrap file moves there too. Paths that resolved from the HTML root
+* must resolve from the new directory instead.
+*
+* Cases: `/static/js/hostInit.js` → `./hostInit.js` (strip dir prefix)
+*        `./src/main.tsx`          → `../../src/main.tsx` (climb back up for each dir level)
+*        `https://cdn.example.com` → unchanged         (absolute URL)
+*/
+function rebaseImport(importSrc, dir) {
+	if (!dir) return importSrc;
+	if (isAbsoluteUrl(importSrc)) return importSrc;
+	const normalizedDir = dir.replace(/^\/+|\/+$/g, "");
+	if (!normalizedDir) return importSrc;
+	const stripDirPrefix = (src, prefix) => {
+		if (src === prefix) return "";
+		if (src.startsWith(prefix + "/")) return src.slice(prefix.length);
+	};
+	const absoluteRemainder = stripDirPrefix(importSrc, "/" + normalizedDir);
+	if (absoluteRemainder !== void 0) {
+		const remainder = absoluteRemainder.replace(/^\/+/, "");
+		return remainder ? "./" + remainder : "./";
+	}
+	const relativeRemainder = stripDirPrefix(importSrc, normalizedDir);
+	if (relativeRemainder !== void 0) {
+		const remainder = relativeRemainder.replace(/^\/+/, "");
+		return remainder ? "./" + remainder : "./";
+	}
+	const upLevels = normalizedDir.split("/").filter(Boolean).length;
+	const prefix = upLevels > 0 ? "../".repeat(upLevels) : "./";
+	if (importSrc.startsWith("./")) return prefix + importSrc.slice(2);
+	if (importSrc.startsWith("/")) return prefix + importSrc.slice(1);
+	return prefix + importSrc;
+}
+function normalizePathForImport(path) {
+	return path.replace(/\\/g, "/");
+}
+const EXTERNAL_URL_RE = /^(?:[a-z]+:|\/\/)/i;
+function isAbsoluteUrl(src) {
+	if (/^[a-z]:[\\/]/i.test(src)) return false;
+	return EXTERNAL_URL_RE.test(src);
+}
+//#endregion
 //#region src/utils/codeRewriter.ts
 const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var CodeRewriter = class {
+	original;
 	replacements = [];
 	constructor(original) {
 		this.original = original;
@@ -149,7 +210,7 @@ async function mapCodeToCodeWithSourcemap(code) {
 }
 //#endregion
 //#region src/utils/codePositionMap.ts
-const REGEX_PREFIX_KEYWORDS = new Set([
+const REGEX_PREFIX_KEYWORDS = /* @__PURE__ */ new Set([
 	"await",
 	"case",
 	"delete",
@@ -321,6 +382,475 @@ 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/pathNormalization.ts
 const COMMON_SHARED_SUBPATHS = {
 	react: [
@@ -396,14 +926,15 @@ function removeTrailingSlash(value) {
 function ensureTrailingSlash(value) {
 	return `${removeTrailingSlash(value)}/`;
 }
-function getBasePath$1(base) {
+function getBasePath$2(base) {
 	return removeTrailingSlash(base || "/");
 }
 function isNuxtClientBase(base) {
-	return getBasePath$1(base).endsWith("/_nuxt");
+	return getBasePath$2(base).endsWith("/_nuxt");
 }
 function normalizeNodeModulePath(source) {
-	return source.replace(/\\/g, "/").replace(/\?.*$/, "");
+	const queryIndex = source.indexOf("?");
+	return (queryIndex === -1 ? source : source.slice(0, queryIndex)).replace(/\\/g, "/");
 }
 function isNodeModulePath(source) {
 	return source.includes("/node_modules/") || source.includes("\\node_modules\\");
@@ -1016,6 +1547,104 @@ function generateReactIslandSSRDefinition(enabled) {
             }
           }`;
 }
+const REACT_ISLAND_CLIENT_ID_PREFIX = "virtual:mf-react-island-client:";
+const REACT_ISLAND_SERVER_ID_PREFIX = "virtual:mf-react-island-server:";
+const RESOLVED_REACT_ISLAND_CLIENT_ID_PREFIX = `\0${REACT_ISLAND_CLIENT_ID_PREFIX}`;
+const RESOLVED_REACT_ISLAND_SERVER_ID_PREFIX = `\0${REACT_ISLAND_SERVER_ID_PREFIX}`;
+function encodeIslandRemoteId(remoteId) {
+	return encodeURIComponent(remoteId);
+}
+function decodeIslandRemoteId(encodedRemoteId) {
+	return decodeURIComponent(encodedRemoteId);
+}
+function getReactIslandImportRemoteId(source) {
+	const queryIndex = source.indexOf("?");
+	if (queryIndex === -1) return;
+	if (!new URLSearchParams(source.slice(queryIndex + 1)).has("mf-island")) return;
+	return source.slice(0, queryIndex);
+}
+function getReactIslandServerImportId(remoteId) {
+	return `${REACT_ISLAND_SERVER_ID_PREFIX}${encodeIslandRemoteId(remoteId)}`;
+}
+function getReactIslandClientImportId(remoteId) {
+	return `${REACT_ISLAND_CLIENT_ID_PREFIX}${encodeIslandRemoteId(remoteId)}`;
+}
+function resolveReactIslandConsumerId(id) {
+	if (id.startsWith("virtual:mf-react-island-server:")) return `\0${id}`;
+	if (id.startsWith("virtual:mf-react-island-client:")) return `\0${id}`;
+}
+function remoteIdFromResolvedIslandId(id, prefix) {
+	if (!id.startsWith(prefix)) return;
+	return decodeIslandRemoteId(id.slice(prefix.length));
+}
+/** Generates the server half of the opt-in `?mf-island` consumer component. */
+function generateReactIslandConsumerServer(remoteId) {
+	const source = JSON.stringify(remoteId);
+	return `import * as React from "react";
+import IslandClient from ${JSON.stringify(getReactIslandClientImportId(remoteId))};
+
+const islandModulePromise = import(${source});
+
+async function loadIslandModule() {
+  const namespace = await islandModulePromise;
+  const pending = namespace && namespace.__mf_remote_pending;
+  if (pending && typeof pending.then === "function") return pending;
+  return namespace && namespace.__moduleExports || namespace;
+}
+
+export default async function ModuleFederationIsland(props) {
+  const remoteModule = await loadIslandModule();
+  const shell = remoteModule && remoteModule.__mf_island;
+  if (!shell || typeof shell.renderToHtml !== "function") {
+    throw new Error(${JSON.stringify(`[Module Federation] ${remoteId} does not expose an SSR island capability`)});
+  }
+  const html = await shell.renderToHtml(props);
+  return React.createElement(IslandClient, { html, islandProps: props });
+}`;
+}
+/** Generates the client boundary which hydrates with the remote-owned React. */
+function generateReactIslandConsumerClient(remoteId) {
+	return `"use client";
+
+import * as React from "react";
+
+const islandModulePromise = import(${JSON.stringify(remoteId)});
+
+async function loadIslandModule() {
+  const namespace = await islandModulePromise;
+  const pending = namespace && namespace.__mf_remote_pending;
+  if (pending && typeof pending.then === "function") return pending;
+  return namespace && namespace.__moduleExports || namespace;
+}
+
+export default function ModuleFederationIslandClient({ html, islandProps }) {
+  const ref = React.useRef(null);
+
+  React.useEffect(() => {
+    const element = ref.current;
+    if (!element) return;
+    void loadIslandModule().then((remoteModule) => {
+      const shell = remoteModule && remoteModule.__mf_island;
+      if (!shell || typeof shell.hydrate !== "function") {
+        throw new Error(${JSON.stringify(`[Module Federation] ${remoteId} does not expose a client island capability`)});
+      }
+      return shell.hydrate(element, islandProps);
+    });
+  }, []);
+
+  return React.createElement("div", {
+    ref,
+    suppressHydrationWarning: true,
+    dangerouslySetInnerHTML: { __html: html },
+  });
+}`;
+}
+function loadReactIslandConsumerModule(id) {
+	const serverRemoteId = remoteIdFromResolvedIslandId(id, RESOLVED_REACT_ISLAND_SERVER_ID_PREFIX);
+	if (serverRemoteId !== void 0) return generateReactIslandConsumerServer(serverRemoteId);
+	const clientRemoteId = remoteIdFromResolvedIslandId(id, RESOLVED_REACT_ISLAND_CLIENT_ID_PREFIX);
+	if (clientRemoteId !== void 0) return generateReactIslandConsumerClient(clientRemoteId);
+}
 //#endregion
 //#region src/virtualModules/virtualExposes.ts
 const EXPOSES_CSS_MAP_PLACEHOLDER = "__MF_EXPOSES_CSS_MAP__";
@@ -1286,6 +1915,9 @@ ${exportStatement}
 }
 //#endregion
 //#region src/utils/treeShaking.ts
+function shouldAnalyzeSharedExports(shareItem) {
+	return !!(shareItem && (shareItem.shareConfig.treeShaking || shareItem.shareConfig.import === false));
+}
 const legacyTreeShakingState = {
 	inferredUsage: /* @__PURE__ */ new Map(),
 	buildMode: false
@@ -1359,12 +1991,12 @@ function getExportRecords(sharedKey, request, options) {
 * fallback lookup across keys keeps aliases/backwards-compatible callers
 * working, while still keeping each concrete request's exports isolated.
 */
-function getTreeShakingExportUsage(request, shareItem, sharedKey, options) {
+function getSharedExportUsage(request, shareItem, sharedKey, options) {
 	const treeShaking = shareItem?.shareConfig.treeShaking;
-	if (!treeShaking || !getTreeShakingState(options).buildMode) return void 0;
+	if (!shouldAnalyzeSharedExports(shareItem) || !getTreeShakingState(options).buildMode) return;
 	const records = getExportRecords(sharedKey, request, options);
 	if (records.some((record) => record.requiresFullBundle)) return { kind: "full" };
-	const configured = treeShaking.usedExports ?? [];
+	const configured = treeShaking?.usedExports ?? [];
 	const result = new Set(configured);
 	records.forEach((record) => record.usedExports.forEach((name) => result.add(name)));
 	if (result.size > 0) return {
@@ -1376,6 +2008,10 @@ function getTreeShakingExportUsage(request, shareItem, sharedKey, options) {
 		usedExports: []
 	} : { kind: "unknown" };
 }
+function getTreeShakingExportUsage(request, shareItem, sharedKey, options) {
+	if (!shareItem?.shareConfig.treeShaking) return void 0;
+	return getSharedExportUsage(request, shareItem, sharedKey, options);
+}
 function getModuleSource(node) {
 	if (!node || typeof node !== "object") return void 0;
 	const source = node;
@@ -1490,8 +2126,8 @@ function collectReExport(node, source, record, markUnsafe) {
 *
 * Parsing the module avoids treating import-looking text in comments, strings,
 * templates, or regular expressions as real dependencies. If parsing fails,
-* every configured tree-shaken share is conservatively marked as requiring its
-* full bundle instead of guessing from source text.
+* every configured share whose exports are analyzed is conservatively marked
+* as requiring its full export surface instead of guessing from source text.
 *
 * Generated federation wrappers are excluded because their imports describe
 * the wrapper implementation, not the consumer's requirements.
@@ -1504,13 +2140,13 @@ function collectTreeShakingImports(code, id, shared, findSharedKey, record, mark
 		ast = parseAst(code);
 	} catch {
 		Object.entries(shared).forEach(([sharedKey, shareItem]) => {
-			if (shareItem.shareConfig.treeShaking) markUnsafe(sharedKey, "*");
+			if (shouldAnalyzeSharedExports(shareItem)) markUnsafe(sharedKey, "*");
 		});
 		return;
 	}
 	const matchShared = (source) => {
 		const sharedKey = findSharedKey(source, shared);
-		return sharedKey && shared[sharedKey]?.shareConfig.treeShaking ? sharedKey : void 0;
+		return sharedKey && shouldAnalyzeSharedExports(shared[sharedKey]) ? sharedKey : void 0;
 	};
 	const recordSource = (names, source) => {
 		const sharedKey = matchShared(source);
@@ -1684,7 +2320,18 @@ function hasCodeMatch(source, regex, codePositions) {
 	return false;
 }
 function hasCommonJsExports(source) {
-	return hasCodeMatch(source, /\bmodule\s*(?:\.exports|\[\s*['"]exports['"]\s*\])|\bexports\s*(?:\.|\[|[,)]|=(?!=|>))/g, createCodePositionMap(source));
+	const codePositions = createCodePositionMap(source);
+	if (hasCodeMatch(source, /\bmodule\s*(?:\.exports|\[\s*['"]exports['"]\s*\])/g, codePositions)) return true;
+	const exportsRegex = /\bexports\s*(?:\.|\[|[,)]|=(?!=|>))/g;
+	let match;
+	while ((match = exportsRegex.exec(source)) !== null) {
+		if (!codePositions[match.index]) continue;
+		let previousCodeIndex = match.index - 1;
+		while (previousCodeIndex >= 0 && (/\s/.test(source[previousCodeIndex]) || !codePositions[previousCodeIndex])) previousCodeIndex--;
+		if (source[previousCodeIndex] === ".") continue;
+		return true;
+	}
+	return false;
 }
 function inspectSharedExportsFromFile(entryPath, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
 	try {
@@ -1701,6 +2348,64 @@ function inspectSharedExportsFromFile(entryPath, exportConditions = DEFAULT_SHAR
 		return;
 	}
 }
+function getMutableExportsFromFile(entryPath, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS, visited = /* @__PURE__ */ new Set()) {
+	if (!entryPath || visited.has(entryPath)) return [];
+	visited.add(entryPath);
+	try {
+		const source = readFileSync(entryPath, "utf-8");
+		const codePositions = createCodePositionMap(source);
+		const mutableBindings = /* @__PURE__ */ new Set();
+		const mutableExports = /* @__PURE__ */ new Set();
+		let match;
+		const declarationRegex = new RegExp(`\\b(?:export\\s+)?(?:let|var)\\s+(${JS_IDENTIFIER_PATTERN})`, "gu");
+		let declarationScanIndex = 0;
+		let braceDepth = 0;
+		while ((match = declarationRegex.exec(source)) !== null) {
+			if (!codePositions[match.index]) continue;
+			for (let index = declarationScanIndex; index < match.index; index++) {
+				if (!codePositions[index]) continue;
+				if (source[index] === "{") braceDepth++;
+				else if (source[index] === "}") braceDepth--;
+			}
+			declarationScanIndex = match.index;
+			if (braceDepth !== 0) continue;
+			mutableBindings.add(match[1]);
+			if (match[0].trimStart().startsWith("export")) mutableExports.add(match[1]);
+		}
+		const listRegex = /export\s*\{([^}]+)\}(?:\s*from\s*['"]([^'"]+)['"])?/g;
+		while ((match = listRegex.exec(source)) !== null) {
+			if (!codePositions[match.index]) continue;
+			const reExportPath = match[2] ? resolveReExportModule(entryPath, match[2], exportConditions) : void 0;
+			const reExportedMutable = new Set(reExportPath ? getMutableExportsFromFile(reExportPath, exportConditions, visited) : []);
+			for (const rawSpecifier of match[1].split(",")) {
+				const specifier = rawSpecifier.trim();
+				if (!specifier || specifier.startsWith("type ")) continue;
+				const parts = specifier.split(/\s+as\s+/);
+				const local = parts[0].trim();
+				const exported = (parts[1] || local).trim();
+				if (isValidEsmExportName(exported) && (mutableBindings.has(local) || reExportedMutable.has(local))) mutableExports.add(exported);
+			}
+		}
+		const starExportRegex = /export\s+\*\s+from\s+['"]([^'"]+)['"]/g;
+		while ((match = starExportRegex.exec(source)) !== null) {
+			if (!codePositions[match.index]) continue;
+			const resolved = resolveReExportModule(entryPath, match[1], exportConditions);
+			for (const name of getMutableExportsFromFile(resolved, exportConditions, visited)) mutableExports.add(name);
+		}
+		visited.delete(entryPath);
+		return Array.from(mutableExports);
+	} catch {
+		visited.delete(entryPath);
+		return [];
+	}
+}
+function getSharedMutableExports(pkg, shareItem, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
+	const configuredImport = shareItem?.shareConfig.import;
+	return getMutableExportsFromFile(typeof configuredImport === "string" ? resolveConfiguredImportPath(configuredImport, exportConditions) : getInstalledPackageEntry(pkg, {
+		conditions: exportConditions,
+		resolveSubpathWithRequire: false
+	}), exportConditions);
+}
 function resolveConfiguredImportPath(importSource, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
 	if (path$1.isAbsolute(importSource)) return resolveFileLikeModule(importSource);
 	const projectRoot = getPackageDetectionCwd();
@@ -1948,6 +2653,7 @@ function getNamedExportsViaRegex(source, filePath, visited, scanState = { comple
 		const specifiers = match[1].split(",");
 		for (const specifier of specifiers) {
 			const trimmed = specifier.trim();
+			if (!trimmed) continue;
 			if (typeOnlySpecifierRegex.test(trimmed)) continue;
 			const asMatch = trimmed.match(exportSpecifierRegex);
 			if (!asMatch) {
@@ -2011,7 +2717,22 @@ function getNamedExportsViaRegex(source, filePath, visited, scanState = { comple
 	}
 	return Array.from(names);
 }
+/**
+* Reading a module's export names runs its top-level code inside the build
+* process, and getPackageNamedExports deliberately resolves the browser entry.
+* A browser entry may open a handle Node never closes — react-dom/server.browser
+* holds a module-scope MessageChannel — and one ref'd handle keeps the event loop
+* alive forever, so `vite build` writes a correct bundle and then never exits.
+*
+* Unref'ing whatever the require created is safe here because the module is
+* loaded purely to read Object.keys off it and is never used afterwards. The
+* handle list is undocumented, so its absence degrades to the previous behaviour
+* rather than failing the build. Side effects that are not handles (an exit
+* listener, a global mutation) are still not contained.
+*/
 function getRequiredNamedExports(specifier) {
+	const getActiveHandles = process._getActiveHandles;
+	const handlesBeforeRequire = typeof getActiveHandles === "function" ? new Set(getActiveHandles.call(process)) : void 0;
 	try {
 		const mod = createRequire$1(pathToFileURL(path$1.join(getPackageDetectionCwd(), "package.json")))(specifier);
 		const runtimeNamedKeys = Object.keys(mod).filter((key) => key !== "default" && key !== "__esModule");
@@ -2019,6 +2740,12 @@ function getRequiredNamedExports(specifier) {
 		return runtimeNamedKeys;
 	} catch {
 		return;
+	} finally {
+		if (handlesBeforeRequire && typeof getActiveHandles === "function") for (const handle of getActiveHandles.call(process)) {
+			if (handlesBeforeRequire.has(handle)) continue;
+			const unref = handle?.unref;
+			if (typeof unref === "function") unref.call(handle);
+		}
 	}
 }
 function getPackageNamedExports(pkg, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
@@ -2163,11 +2890,14 @@ function isSharedSingletonConsumedByPeer(pkg, options = getNormalizeModuleFedera
 		}
 		return false;
 	};
-	return Array.from(sharedKeyByPackageName.values()).some((sharedPkg) => sharedPkg !== pkg && reachesPkg(sharedPkg, new Set([sharedPkg])));
+	return Array.from(sharedKeyByPackageName.values()).some((sharedPkg) => sharedPkg !== pkg && reachesPkg(sharedPkg, /* @__PURE__ */ new Set([sharedPkg])));
 }
 function isRemoteOnlyContainer(options = getNormalizeModuleFederationOptions()) {
 	return Object.keys(options.exposes || {}).length > 0 && Object.keys(options.remotes || {}).length === 0;
 }
+function isLocalOnlyContainer(options = getNormalizeModuleFederationOptions()) {
+	return Object.keys(options.exposes || {}).length === 0 && Object.keys(options.remotes || {}).length === 0;
+}
 function tryResolveImportFromPackageRoot(pkg, root) {
 	try {
 		return resolveWorkspaceEsmEntry(pkg, createRequire$1(pathToFileURL(path$1.join(root, "package.json"))).resolve(pkg), root);
@@ -2317,6 +3047,7 @@ export default { get, init };
 	materializedTreeShakingProviders.add(pkg);
 }
 function writePreBuildLibPath(pkg, shareItem, options, exportConditions) {
+	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const { preBuildCacheMap, preBuildShareItemMap } = getSharedVirtualModuleState(options);
 	if (!preBuildCacheMap[pkg]) preBuildCacheMap[pkg] = createScopedSharedVirtualModule(pkg, PREBUILD_TAG, options);
 	preBuildShareItemMap[pkg] = shareItem;
@@ -2368,14 +3099,19 @@ function writePreBuildLibPath(pkg, shareItem, options, exportConditions) {
 	}
 	const namedExports = getSharedNamedExports(pkg, shareItem, exportConditions) ?? [];
 	if (namedExports.length > 0) {
-		const namedExportVars = namedExports.map((_name, i) => `__mf_${i}`);
-		const declarations = namedExports.map((name, i) => `const ${namedExportVars[i]} = __mfPrebuildExports[${escapeGeneratedStringLiteral(name)}];`).join("\n    ");
-		const namedExportLine = `export { ${namedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };`;
+		const mutableExports = new Set(isLocalOnlyContainer(resolvedOptions) ? getSharedMutableExports(pkg, shareItem, exportConditions) : []);
+		const copiedExports = namedExports.filter((name) => !mutableExports.has(name));
+		const liveExports = namedExports.filter((name) => mutableExports.has(name));
+		const namedExportVars = copiedExports.map((_name, i) => `__mf_${i}`);
+		const declarations = copiedExports.map((name, i) => `const ${namedExportVars[i]} = __mfPrebuildExports[${escapeGeneratedStringLiteral(name)}];`).join("\n    ");
+		const namedExportLine = copiedExports.length ? `export { ${copiedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : "";
+		const liveExportLine = liveExports.length ? `export { ${liveExports.join(", ")} } from ${escapeGeneratedStringLiteral(importSource)};` : "";
 		preBuildCacheMap[pkg].writeSync(`
     import * as __mfPrebuildNamespace from ${escapeGeneratedStringLiteral(importSource)};
     const __mfPrebuildExports = __mfPrebuildNamespace;
     ${declarations}
     ${namedExportLine}
+    ${liveExportLine}
     export default Reflect.get(__mfPrebuildNamespace, "default") ?? __mfPrebuildNamespace;
   `, true);
 		return;
@@ -2463,11 +3199,13 @@ function findCurrentLoadShareForStaleOwnerId(id, shared, findSharedKey, options)
 function getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer) {
 	return treeShakingConsumer ? `__mfReadTreeShakingSharedSelection(__mfModuleCache.share, ${cacheDescriptor}, ${JSON.stringify(treeShakingConsumer)})` : `__mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor})`;
 }
-function generateEagerWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer) {
-	const namedExportVars = namedExports.map((_name, i) => `__mf_${i}`);
+function generateEagerWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer, mutableExports = []) {
+	const copiedExports = namedExports.filter((name) => !mutableExports.includes(name));
+	const namedExportVars = copiedExports.map((_name, i) => `__mf_${i}`);
 	const declarations = namedExports.length > 0 ? ["let __mf_default;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ") : "let __mf_default;";
-	const assignments = [...namedExports.map((name, i) => `${namedExportVars[i]} = mod[${escapeGeneratedStringLiteral(name)}];`), "__mf_default = mod.default ?? mod;"].join("\n      ");
-	const namedExportLine = namedExports.length > 0 ? `\n    export { ${namedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : "";
+	const assignments = [...copiedExports.map((name, i) => `${namedExportVars[i]} = mod[${escapeGeneratedStringLiteral(name)}];`), "__mf_default = mod.default ?? mod;"].join("\n      ");
+	const namedExportLine = copiedExports.length > 0 ? `\n    export { ${copiedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : "";
+	const mutableExportLine = mutableExports.length ? `\n    export { ${mutableExports.join(", ")} } from ${escapeGeneratedStringLiteral(importSource)};` : "";
 	return `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(importSource)};
     let exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
     if (exportModule === undefined) {
@@ -2484,13 +3222,15 @@ function generateEagerWorkspaceSingletonExports(namedExports, importSource, cach
     };
     __mfSubscribeSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfApplyEagerShareExports);
     __mfApplyEagerShareExports(exportModule);
-    export { __mf_default as default };${namedExportLine}`;
+    export { __mf_default as default };${namedExportLine}${mutableExportLine}`;
 }
-function generateLazyWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer, serveLocalFallback = false) {
-	const namedExportVars = namedExports.map((_name, i) => `__mf_${i}`);
+function generateLazyWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer, serveLocalFallback = false, mutableExports = []) {
+	const copiedExports = namedExports.filter((name) => !mutableExports.includes(name));
+	const namedExportVars = copiedExports.map((_name, i) => `__mf_${i}`);
 	const declarations = namedExports.length > 0 ? ["let __mf_default;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ") : "let __mf_default;";
-	const assignments = namedExports.length > 0 ? [...namedExports.map((name, i) => `${namedExportVars[i]} = mod[${escapeGeneratedStringLiteral(name)}];`), "__mf_default = mod.default ?? mod;"].join("\n      ") : "__mf_default = mod.default ?? mod;";
-	const namedExportLine = namedExports.length > 0 ? `\n    export { ${namedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : "";
+	const assignments = copiedExports.length > 0 ? [...copiedExports.map((name, i) => `${namedExportVars[i]} = mod[${escapeGeneratedStringLiteral(name)}];`), "__mf_default = mod.default ?? mod;"].join("\n      ") : "__mf_default = mod.default ?? mod;";
+	const namedExportLine = copiedExports.length > 0 ? `\n    export { ${copiedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : "";
+	const mutableExportLine = mutableExports.length ? `\n    export { ${mutableExports.join(", ")} } from ${escapeGeneratedStringLiteral(importSource)};` : "";
 	const applyLocalFallback = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
       __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});
       __mfApplyLazyShareExports(exportModule);`;
@@ -2519,7 +3259,7 @@ function generateLazyWorkspaceSingletonExports(namedExports, importSource, cache
     } else {
       __mfApplyLazyShareExports(exportModule);
     }
-    export { __mf_default as default };${namedExportLine}`;
+    export { __mf_default as default };${namedExportLine}${mutableExportLine}`;
 }
 const WORKSPACE_SINGLETON_SSR_LOCAL_SHARE = "__mfNormalizeShareModule(__mfLocalShare)";
 function prependWorkspaceSingletonSsrImport(code) {
@@ -2561,6 +3301,12 @@ function generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor,
     }
     export { __mf_default as default };${namedExportLine}`;
 }
+function selectImportFalseNamedExports(detectedNamedExports, usage) {
+	if (!detectedNamedExports || usage?.kind !== "exports") return detectedNamedExports ?? [];
+	const usedNamedExports = new Set(usage.usedExports.filter((name) => name !== "default"));
+	if ([...usedNamedExports].some((name) => !detectedNamedExports.includes(name))) return detectedNamedExports;
+	return detectedNamedExports.filter((name) => usedNamedExports.has(name));
+}
 function generateShareModuleUnwrapCode({ source, preserveNamedExports, stopWithReturn }) {
 	return `let current = ${source};
       for (let i = 0; i < 5; i++) {
@@ -2583,7 +3329,7 @@ const normalizeLocalShareModuleCode = `const __mfNormalizeShareModule = (mod) =>
         ? Object.assign({}, normalized)
         : normalized;
     };`;
-function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exportConditions) {
+function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exportConditions, importFalseExportUsage) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const { loadShareCacheMap } = getSharedVirtualModuleState(options);
 	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = createScopedSharedVirtualModule(pkg, LOAD_SHARE_TAG, options);
@@ -2594,7 +3340,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	const treeShakingConsumer = command === "build" && shareItem.shareConfig.treeShaking ? resolvedOptions.name : void 0;
 	if (shareItem.shareConfig.import === false) {
 		const detectedNamedExports = getPackageNamedExports(pkg, exportConditions);
-		const namedExports = detectedNamedExports ?? [];
+		const namedExports = selectImportFalseNamedExports(detectedNamedExports, importFalseExportUsage);
 		let exportLine;
 		if (namedExports.length > 0) exportLine = generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor, treeShakingConsumer);
 		else {
@@ -2619,6 +3365,10 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	const skipServePrebuildWarmup = command !== "build" && (pkg === "lit" || pkg.startsWith("lit/"));
 	const detectedNamedExports = getSharedNamedExports(pkg, shareItem, exportConditions);
 	const namedExports = detectedNamedExports ?? [];
+	const mutableExports = new Set(isLocalOnlyContainer(resolvedOptions) ? getSharedMutableExports(pkg, shareItem, exportConditions) : []);
+	const copiedNamedExports = namedExports.filter((name) => !mutableExports.has(name));
+	const liveNamedExports = namedExports.filter((name) => mutableExports.has(name));
+	const liveNamedExportLine = liveNamedExports.length ? `export { ${liveNamedExports.join(", ")} } from ${escapeGeneratedStringLiteral(sharedImportSource)};` : "";
 	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";
@@ -2632,11 +3382,11 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	let initBlock = "";
 	if (usesDeferredTreeShakingFallback) {
 		importLine = `${getRuntimeInitPromiseBootstrapCode(false, runtimeInitOwnerImportId)}\n    ${importLine}`;
-		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && (isWorkspaceSingleton || isWorkspacePackage || servesRemoteSingletonFallback));
-	} else if (usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback) exportLine = generateEagerWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer);
+		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && (isWorkspaceSingleton || isWorkspacePackage || servesRemoteSingletonFallback), liveNamedExports);
+	} else if (usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback) exportLine = generateEagerWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, liveNamedExports);
 	else if (usesDeferredSingletonFallback) {
 		importLine = `${getRuntimeInitPromiseBootstrapCode(false, runtimeInitOwnerImportId)}\n    ${importLine}`;
-		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && (isWorkspaceSingleton || isWorkspacePackage || servesRemoteSingletonFallback));
+		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && (isWorkspaceSingleton || isWorkspacePackage || servesRemoteSingletonFallback), liveNamedExports);
 	} else if (detectedNamedExports === void 0) {
 		exportLine = `const __mfDefaultExport = (() => {
       ${generateShareModuleUnwrapCode({
@@ -2650,10 +3400,10 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
       __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
 	} else if (namedExports.length > 0 && shareItem.shareConfig.singleton === true) {
-		const namedExportVars = namedExports.map((_name, i) => `__mf_${i}`);
+		const namedExportVars = copiedNamedExports.map((_name, i) => `__mf_${i}`);
 		exportLine = `${["let __mfDefaultExport;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ")}
     const __mfApplySharedExports = (mod) => {
-      ${[...namedExports.map((name, i) => `${namedExportVars[i]} = mod[${escapeGeneratedStringLiteral(name)}];`), `__mfDefaultExport = (() => {
+      ${[...copiedNamedExports.map((name, i) => `${namedExportVars[i]} = mod[${escapeGeneratedStringLiteral(name)}];`), `__mfDefaultExport = (() => {
         ${generateShareModuleUnwrapCode({
 			source: "mod",
 			preserveNamedExports: false,
@@ -2664,12 +3414,13 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
     __mfSubscribeSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfApplySharedExports);
     __mfApplySharedExports(exportModule);
     export { __mfDefaultExport as default };
-    ${`export { ${namedExports.map((name, i) => `__mf_${i} as ${name}`).join(", ")} };`}`;
+    ${copiedNamedExports.length ? `export { ${copiedNamedExports.map((name, i) => `__mf_${i} as ${name}`).join(", ")} };` : ""}
+    ${liveNamedExportLine}`;
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
       __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
 	} else if (namedExports.length > 0) {
-		const destructure = `const { ${namedExports.map((name, i) => `${name}: __mf_${i}`).join(", ")} } = exportModule;`;
-		const namedExportLine = `export { ${namedExports.map((name, i) => `__mf_${i} as ${name}`).join(", ")} };`;
+		const destructure = copiedNamedExports.length ? `const { ${copiedNamedExports.map((name, i) => `${name}: __mf_${i}`).join(", ")} } = exportModule;` : "";
+		const namedExportLine = copiedNamedExports.length ? `export { ${copiedNamedExports.map((name, i) => `__mf_${i} as ${name}`).join(", ")} };` : "";
 		exportLine = `const __mfDefaultExport = (() => {
       ${generateShareModuleUnwrapCode({
 			source: "exportModule",
@@ -2679,7 +3430,8 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
     })();
     export default __mfDefaultExport;
     ${destructure}
-    ${namedExportLine}`;
+    ${namedExportLine}
+    ${liveNamedExportLine}`;
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
       __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
 	} else if (shareItem.shareConfig.singleton === true) {
@@ -2754,7 +3506,8 @@ function getLocalOwnerKey(options) {
 }
 function getLocalSharedImportMapPath(options) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
-	return `${LOCAL_SHARED_IMPORT_MAP_ID}:${packageNameEncode(options ? getLocalOwnerKey(resolvedOptions) : resolvedOptions.internalName || resolvedOptions.name)}`;
+	const ownerName = options ? getLocalOwnerKey(resolvedOptions) : resolvedOptions.internalName || resolvedOptions.name;
+	return `${LOCAL_SHARED_IMPORT_MAP_ID}:${packageNameEncode(ownerName)}`;
 }
 function getResolvedLocalSharedImportMapId(options) {
 	return `\0${getLocalSharedImportMapPath(options)}`;
@@ -2874,7 +3627,7 @@ function generateLocalSharedImportMap(options) {
 		if (!remote) return null;
 		return `
                 {
-                  alias: ${JSON.stringify(getRuntimeRemoteAlias(key, options))},
+                  alias: ${JSON.stringify(key)},
                   entryGlobalName: ${JSON.stringify(remote.entryGlobalName)},
                   name: ${JSON.stringify(options ? getRuntimeRemoteAlias(key, options) : remote.name)},
                   type: ${JSON.stringify(remote.type)},
@@ -3272,9 +4025,10 @@ function generateHostAutoInitSharedCacheSeedCode(command = "build", options) {
 }
 const REMOTE_ENTRY_ID = "virtual:mf-REMOTE_ENTRY_ID";
 function getRemoteEntryId(options) {
-	return `${REMOTE_ENTRY_ID}:${`${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+	const scopedKey = `${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_");
+	return `${REMOTE_ENTRY_ID}:${scopedKey}`;
 }
-const SSR_ONLY_PLUGIN_SPECIFIERS = new Set(["@module-federation/vite/ssrEntryLoader"]);
+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));
 function generateTreeShakingSharedResolutionCode(enabled) {
@@ -4240,8 +4994,9 @@ function getHostAutoInitState(options) {
 	if (!options) return legacyHostAutoInitState;
 	let state = hostAutoInitStates.get(options);
 	if (!state) {
+		const ownerKey = getLocalOwnerKey(options);
 		state = {
-			module: new VirtualModule("hostAutoInit", HOST_AUTO_INIT_TAG, "", getLocalOwnerKey(options)),
+			module: new VirtualModule("hostAutoInit", HOST_AUTO_INIT_TAG, "", ownerKey),
 			remoteEntryId: REMOTE_ENTRY_ID,
 			command: "build"
 		};
@@ -4354,6 +5109,8 @@ function getRemoteVirtualModule(remote, command, enableSsrInit = false, consumer
 }
 const usedRemotesMap = {};
 const usedRemotesByOptions = /* @__PURE__ */ new WeakMap();
+const dynamicRemotesByOptions = /* @__PURE__ */ new WeakMap();
+const staticRemotesByOptions = /* @__PURE__ */ new WeakMap();
 function getScopedUsedRemotesMap(options) {
 	let scoped = usedRemotesByOptions.get(options);
 	if (!scoped) {
@@ -4374,6 +5131,25 @@ function getUsedRemotesMap(options) {
 	if (options) return getScopedUsedRemotesMap(options);
 	return usedRemotesMap;
 }
+function markDynamicRemote(remote, options) {
+	let remotes = dynamicRemotesByOptions.get(options);
+	if (!remotes) {
+		remotes = /* @__PURE__ */ new Set();
+		dynamicRemotesByOptions.set(options, remotes);
+	}
+	remotes.add(remote);
+}
+function markStaticRemote(remote, options) {
+	let remotes = staticRemotesByOptions.get(options);
+	if (!remotes) {
+		remotes = /* @__PURE__ */ new Set();
+		staticRemotesByOptions.set(options, remotes);
+	}
+	remotes.add(remote);
+}
+function isDynamicOnlyRemote(remote, options) {
+	return (dynamicRemotesByOptions.get(options)?.has(remote) ?? false) && !(staticRemotesByOptions.get(options)?.has(remote) ?? false);
+}
 function getRemoteAliasFromId(id, remotes) {
 	return Object.keys(remotes).filter((name) => id === name || id.startsWith(name + "/")).sort((a, b) => b.length - a.length)[0];
 }
@@ -4558,7 +5334,7 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
 	const registerRemoteCode = isLoadedFirst && remote ? `runtime.registerRemotes([${JSON.stringify({
 		entryGlobalName: remote.entryGlobalName,
 		name: options ? runtimeRemoteAlias : remote.name,
-		alias: runtimeRemoteAlias,
+		alias: remoteAlias,
 		type: remote.type,
 		entry: remote.entry,
 		shareScope: remote.shareScope ?? "default"
@@ -4796,7 +5572,7 @@ const __mfCurrentScript = document.currentScript;
 		const entryImportDeclaration = isEncodedVirtualEntry ? `const __mfEntryUrl = ${JSON.stringify(entrySrc)};
 ` : "";
 		const entryImportExpression = isEncodedVirtualEntry ? "import(/* @vite-ignore */ __mfEntryUrl)" : importExpression(entrySrc);
-		const remotePreloads = !options?.skipRemotePreload && (federationOptions ?? getNormalizeModuleFederationOptions())?.shareStrategy !== "loaded-first" ? Object.entries(getUsedRemotesMap(federationOptions)).flatMap(([, remotes]) => Array.from(remotes)).sort().map((remote) => `__mfPreloadRemote(${JSON.stringify(getRuntimeRemoteId(remote, (federationOptions ?? getNormalizeModuleFederationOptions()).remotes, federationOptions))}, ${JSON.stringify(remote)})`).join(",") : "";
+		const remotePreloads = !options?.skipRemotePreload && (federationOptions ?? getNormalizeModuleFederationOptions())?.shareStrategy !== "loaded-first" ? Object.entries(getUsedRemotesMap(federationOptions)).flatMap(([, remotes]) => Array.from(remotes)).filter((remote) => !federationOptions || !isDynamicOnlyRemote(remote, federationOptions)).sort().map((remote) => `__mfPreloadRemote(${JSON.stringify(getRuntimeRemoteId(remote, (federationOptions ?? getNormalizeModuleFederationOptions()).remotes, federationOptions))}, ${JSON.stringify(remote)})`).join(",") : "";
 		const remoteCachePrefix = getRuntimeRemoteCachePrefix(federationOptions);
 		const preloadBlock = remotePreloads ? `
   const runtime = await initHost();
@@ -4943,10 +5719,11 @@ const __mfCurrentScript = document.currentScript;
 					const entrySrc = stripBase(originalSrc);
 					addEntryRemoteImports(entrySrc);
 					const resolvedEntrySrc = entrySrc.startsWith("virtual:") ? toViteEncodedId(entrySrc) : entrySrc;
-					return toViteEncodedId(`${DEV_HTML_PROXY_PREFIX}${new URLSearchParams({
+					const query = new URLSearchParams({
 						init: sanitizeDevEntryPath(stripBase(devEntryPath)),
 						entry: sanitizeDevEntryPath(resolvedEntrySrc)
-					}).toString()}`);
+					}).toString();
+					return toViteEncodedId(`${DEV_HTML_PROXY_PREFIX}${query}`);
 				});
 				return html === c ? injectEntryScript(c, stripBase(devEntryPath)) : html;
 			}
@@ -5332,7 +6109,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(base) {
+function getBasePath$1(base) {
 	if (!base) return "/";
 	if (base.startsWith("http://") || base.startsWith("https://")) try {
 		return new URL(base).pathname || "/";
@@ -5342,11 +6119,11 @@ function getBasePath(base) {
 	return base;
 }
 function getRemoteHmrPath(base) {
-	return `${getBasePath(base).replace(/\/?$/, "/")}${REMOTE_HMR_ENDPOINT}`.replace(/\/{2,}/g, "/");
+	return `${getBasePath$1(base).replace(/\/?$/, "/")}${REMOTE_HMR_ENDPOINT}`.replace(/\/{2,}/g, "/");
 }
 function getHmrWsPath(base, hmrPath) {
-	const normalizedBase = getBasePath(base);
-	const normalizedPath = getBasePath(hmrPath || "");
+	const normalizedBase = getBasePath$1(base);
+	const normalizedPath = getBasePath$1(hmrPath || "");
 	if (!normalizedPath || normalizedPath === "/") return normalizedBase;
 	return `${normalizedBase.endsWith("/") ? normalizedBase.slice(0, -1) : normalizedBase}/${normalizedPath.startsWith("/") ? normalizedPath.slice(1) : normalizedPath}`;
 }
@@ -6267,7 +7044,8 @@ 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) {
-	return `${REMOTE_ENTRY_SSR_ID}:${`${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+	const scopedKey = `${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_");
+	return `${REMOTE_ENTRY_SSR_ID}:${scopedKey}`;
 }
 function getSsrRemoteEntryFileName(browserFilename) {
 	const ext = browserFilename.match(/\.[^.]+$/)?.[0] || ".js";
@@ -6345,6 +7123,318 @@ 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.
@@ -6447,9 +7537,20 @@ const Manifest = (providedOptions) => {
 	return [{
 		name: "module-federation-manifest",
 		apply: "serve",
+		/**
+		* Stores resolved Vite config for later use
+		*/
+		/**
+		* Finalizes configuration after all plugins are resolved
+		* @param config - Fully resolved Vite config
+		*/
 		configResolved(config) {
 			viteConfig = config;
 		},
+		/**
+		* Configures dev server middleware to handle manifest requests
+		* @param server - Vite dev server instance
+		*/
 		configureServer(server) {
 			server.middlewares.use((req, res, next) => {
 				const devRemoteEntryFile = resolveDevRemoteEntryFileName(filename);
@@ -6507,6 +7608,11 @@ const Manifest = (providedOptions) => {
 	}, {
 		name: "module-federation-manifest",
 		enforce: "post",
+		/**
+		* Initial plugin configuration
+		* @param config - Vite config object
+		* @param command - Current Vite command (serve/build)
+		*/
 		config(config, { command }) {
 			_command = command;
 			if (!config.build) config.build = {};
@@ -6521,6 +7627,11 @@ const Manifest = (providedOptions) => {
 			if (_command === "serve") base = (config.server.origin || "") + config.base;
 			publicPath = mfOptions.publicPath === "auto" ? "auto" : resolvePublicPath(mfOptions, base, _originalConfigBase);
 		},
+		/**
+		* Generates the module federation manifest file
+		* @param options - Rollup output options
+		* @param bundle - Generated bundle assets
+		*/
 		async generateBundle(_options, bundle) {
 			if (!mfManifestName) return;
 			if (this.environment?.name === "ssr") return;
@@ -6716,116 +7827,174 @@ function getStatsFileName(manifestFileName) {
 }
 //#endregion
 //#region src/plugins/pluginModuleParseEnd.ts
-let _resolve = null;
-let _parseTimeout = null;
-let _settleTimeout = null;
-let parsePromise = Promise.resolve(1);
-let parseStartSet = /* @__PURE__ */ new Set();
-let parseEndSet = /* @__PURE__ */ new Set();
-let lastLoadedModule = "";
-let lastParsedModule = "";
-function clearParseTimeout() {
-	if (_parseTimeout) {
-		clearTimeout(_parseTimeout);
-		_parseTimeout = null;
-	}
-}
-function clearSettleTimeout() {
-	if (_settleTimeout) {
-		clearTimeout(_settleTimeout);
-		_settleTimeout = null;
-	}
-}
-function resetParseState() {
-	clearParseTimeout();
-	clearSettleTimeout();
-	parseStartSet = /* @__PURE__ */ new Set();
-	parseEndSet = /* @__PURE__ */ new Set();
-	lastLoadedModule = "";
-	lastParsedModule = "";
-	parsePromise = new Promise((resolve) => {
-		_resolve = (v) => {
-			clearParseTimeout();
-			clearSettleTimeout();
-			resolve(v);
+function createModuleParseController() {
+	return {
+		resolve: null,
+		parseTimeout: null,
+		settleTimeout: null,
+		parsePromise: Promise.resolve({
+			complete: false,
+			reason: "initial"
+		}),
+		parseStartSet: /* @__PURE__ */ new Set(),
+		parseEndSet: /* @__PURE__ */ new Set(),
+		discardWarned: false,
+		externalSet: /* @__PURE__ */ new Set(),
+		resolutionProbed: /* @__PURE__ */ new Set(),
+		lastLoadedModule: "",
+		lastParsedModule: ""
+	};
+}
+function clearParseTimeout(controller) {
+	if (controller.parseTimeout) {
+		clearTimeout(controller.parseTimeout);
+		controller.parseTimeout = null;
+	}
+}
+function clearSettleTimeout(controller) {
+	if (controller.settleTimeout) {
+		clearTimeout(controller.settleTimeout);
+		controller.settleTimeout = null;
+	}
+}
+function resetParseState(controller) {
+	clearParseTimeout(controller);
+	clearSettleTimeout(controller);
+	controller.parseStartSet = /* @__PURE__ */ new Set();
+	controller.parseEndSet = /* @__PURE__ */ new Set();
+	controller.externalSet = /* @__PURE__ */ new Set();
+	controller.resolutionProbed = /* @__PURE__ */ new Set();
+	controller.discardWarned = false;
+	controller.lastLoadedModule = "";
+	controller.lastParsedModule = "";
+	controller.parsePromise = new Promise((resolve) => {
+		controller.resolve = (result) => {
+			clearParseTimeout(controller);
+			clearSettleTimeout(controller);
+			resolve(result);
 		};
 	});
 }
-function setParseTimeout(timeout) {
-	if (!_parseTimeout) _parseTimeout = setTimeout(() => {
+function setParseTimeout(controller, timeout) {
+	if (!controller.parseTimeout) controller.parseTimeout = setTimeout(() => {
 		mfWarn(`Parse timeout (${timeout}s) - forcing resolve`);
-		_resolve?.(1);
+		controller.resolve?.({
+			complete: false,
+			reason: "timeout"
+		});
 	}, timeout * 1e3);
 }
-function resetIdleTimeout(timeout) {
-	clearParseTimeout();
-	_parseTimeout = setTimeout(() => {
-		const pendingModules = Array.from(parseStartSet).filter((moduleId) => !parseEndSet.has(moduleId));
-		mfWarn(`moduleParseIdleTimeout: no module activity for ${timeout}s, forcing resolve. Some shared/remote dependencies may be missing. Consider increasing moduleParseIdleTimeout. Tracked modules: ${parseEndSet.size}/${parseStartSet.size}.` + (lastLoadedModule ? ` Last loaded: ${lastLoadedModule}.` : "") + (lastParsedModule ? ` Last parsed: ${lastParsedModule}.` : "") + (pendingModules.length ? ` Pending modules: ${pendingModules.slice(0, 10).join(", ")}` : ""));
-		_resolve?.(1);
+function resetIdleTimeout(controller, timeout) {
+	clearParseTimeout(controller);
+	controller.parseTimeout = setTimeout(() => {
+		const pendingModules = Array.from(controller.parseStartSet).filter((moduleId) => !controller.parseEndSet.has(moduleId));
+		mfWarn(`moduleParseIdleTimeout: no module activity for ${timeout}s, forcing resolve. Some shared/remote dependencies may be missing. Consider increasing moduleParseIdleTimeout. Tracked modules: ${controller.parseEndSet.size}/${controller.parseStartSet.size}.` + (controller.lastLoadedModule ? ` Last loaded: ${controller.lastLoadedModule}.` : "") + (controller.lastParsedModule ? ` Last parsed: ${controller.lastParsedModule}.` : "") + (pendingModules.length ? ` Pending modules: ${pendingModules.slice(0, 10).join(", ")}` : ""));
+		controller.resolve?.({
+			complete: false,
+			reason: "idle-timeout"
+		});
 	}, timeout * 1e3);
 }
-function scheduleParseCompletionCheck() {
-	clearSettleTimeout();
-	_settleTimeout = setTimeout(() => {
-		_settleTimeout = null;
-		if (parseStartSet.size > 0 && Array.from(parseStartSet).every((moduleId) => parseEndSet.has(moduleId))) _resolve?.(1);
+function scheduleParseCompletionCheck(controller) {
+	clearSettleTimeout(controller);
+	controller.settleTimeout = setTimeout(() => {
+		controller.settleTimeout = null;
+		if (controller.parseStartSet.size > 0 && Array.from(controller.parseStartSet).every((moduleId) => controller.parseEndSet.has(moduleId))) controller.resolve?.({
+			complete: true,
+			reason: "graph-complete"
+		});
 	}, 10);
 }
-function pluginModuleParseEnd_default(excludeFn, options) {
+function matchesExternal(external, id, importer) {
+	if (!external) return false;
+	if (typeof external === "function") return external(id, importer, true) === true;
+	return (Array.isArray(external) ? external : [external]).some((entry) => {
+		if (typeof entry === "string") return entry === id;
+		entry.lastIndex = 0;
+		return entry.test(id);
+	});
+}
+function getConfiguredInputImports(input) {
+	if (typeof input === "string") return [input];
+	if (Array.isArray(input)) return input.filter((entry) => typeof entry === "string");
+	if (!input || typeof input !== "object") return [];
+	return Object.values(input).filter((entry) => typeof entry === "string");
+}
+function pluginModuleParseEnd_default(excludeFn, options, controller = createModuleParseController()) {
 	const idleTimeout = options.moduleParseIdleTimeout ?? options.moduleParseTimeout;
-	return [
-		{
-			name: "_",
-			apply: "serve",
-			config() {
-				_resolve?.(1);
+	let configuredInputImports = [];
+	let configuredExternal;
+	return [{
+		enforce: "pre",
+		name: "parseStart",
+		apply: "build",
+		configResolved(config) {
+			const buildOptions = config.build;
+			configuredInputImports = getConfiguredInputImports(buildOptions.rollupOptions.input ?? buildOptions.rolldownOptions?.input);
+			configuredExternal = buildOptions.rollupOptions.external ?? buildOptions.rolldownOptions?.external;
+		},
+		async buildStart() {
+			resetParseState(controller);
+			if (idleTimeout) resetIdleTimeout(controller, idleTimeout);
+			else if (options.moduleParseTimeout) setParseTimeout(controller, options.moduleParseTimeout);
+			const entryImports = /* @__PURE__ */ new Set([...options.exposedModuleImports || [], ...configuredInputImports]);
+			for (const importSource of entryImports) {
+				const resolved = await this.resolve(importSource);
+				if (resolved && !resolved.external && !excludeFn(resolved.id)) controller.parseStartSet.add(resolved.id);
 			}
 		},
-		{
-			enforce: "pre",
-			name: "parseStart",
-			apply: "build",
-			async buildStart() {
-				resetParseState();
-				if (idleTimeout) resetIdleTimeout(idleTimeout);
-				else if (options.moduleParseTimeout) setParseTimeout(options.moduleParseTimeout);
-				for (const importSource of options.exposedModuleImports || []) {
-					const resolved = await this.resolve(importSource);
-					if (resolved && !resolved.external && !excludeFn(resolved.id)) parseStartSet.add(resolved.id);
+		load(id) {
+			controller.lastLoadedModule = id;
+			if (excludeFn(id)) return;
+			clearSettleTimeout(controller);
+			if (idleTimeout) resetIdleTimeout(controller, idleTimeout);
+			controller.parseStartSet.add(id);
+		}
+	}, {
+		enforce: "post",
+		name: "parseEnd",
+		apply: "build",
+		moduleParsed(module) {
+			clearSettleTimeout(controller);
+			const id = module.id;
+			controller.lastParsedModule = id;
+			if (idleTimeout) resetIdleTimeout(controller, idleTimeout);
+			const parsedModule = module;
+			const addPendingResolutions = (resolutions) => {
+				for (const resolution of resolutions || []) if (!resolution.external && !excludeFn(resolution.id)) controller.parseStartSet.add(resolution.id);
+			};
+			const probeExternal = (pendingId) => {
+				if (typeof this.resolve !== "function") return;
+				if (controller.resolutionProbed.has(pendingId)) return;
+				controller.resolutionProbed.add(pendingId);
+				this.resolve(pendingId, id, { skipSelf: true }).then((resolved) => {
+					if (!resolved?.external) return;
+					controller.externalSet.add(pendingId);
+					controller.parseStartSet.delete(pendingId);
+					scheduleParseCompletionCheck(controller);
+				}).catch(() => {});
+			};
+			const addPendingIds = (ids) => {
+				for (const pendingId of ids || []) {
+					if (!this.getModuleInfo(pendingId) || controller.externalSet.has(pendingId) || matchesExternal(configuredExternal, pendingId, id) || excludeFn(pendingId)) continue;
+					controller.parseStartSet.add(pendingId);
+					if (!controller.parseEndSet.has(pendingId)) probeExternal(pendingId);
 				}
-			},
-			load(id) {
-				lastLoadedModule = id;
-				if (excludeFn(id)) return;
-				clearSettleTimeout();
-				if (idleTimeout) resetIdleTimeout(idleTimeout);
-				parseStartSet.add(id);
-			}
+			};
+			addPendingResolutions(parsedModule.importedIdResolutions);
+			addPendingResolutions(parsedModule.dynamicallyImportedIdResolutions);
+			if (parsedModule.importedIdResolutions === void 0) addPendingIds(module.importedIds);
+			if (parsedModule.dynamicallyImportedIdResolutions === void 0) addPendingIds(module.dynamicallyImportedIds);
+			if (!excludeFn(id)) controller.parseEndSet.add(id);
+			scheduleParseCompletionCheck(controller);
 		},
-		{
-			enforce: "post",
-			name: "parseEnd",
-			apply: "build",
-			moduleParsed(module) {
-				clearSettleTimeout();
-				const id = module.id;
-				lastParsedModule = id;
-				if (idleTimeout) resetIdleTimeout(idleTimeout);
-				const parsedModule = module;
-				const addPendingResolutions = (resolutions) => {
-					for (const resolution of resolutions || []) if (!resolution.external && !excludeFn(resolution.id)) parseStartSet.add(resolution.id);
-				};
-				addPendingResolutions(parsedModule.importedIdResolutions);
-				addPendingResolutions(parsedModule.dynamicallyImportedIdResolutions);
-				if (!excludeFn(id)) parseEndSet.add(id);
-				scheduleParseCompletionCheck();
-			},
-			buildEnd() {
-				_resolve?.(1);
-			}
+		buildEnd() {
+			controller.resolve?.({
+				complete: false,
+				reason: "build-end"
+			});
 		}
-	];
+	}];
 }
 //#endregion
 //#region src/plugins/pluginProxyRemoteEntry.ts
@@ -6835,7 +8004,7 @@ function resolveDevHashEntryFileName(fileName) {
 	const baseName = path$1.basename(normalized);
 	return path$1.extname(baseName) ? normalized : `${normalized}.js`;
 }
-function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposesId }) {
+function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposesId, getParsePromise = () => Promise.resolve() }) {
 	let viteConfig, _command, root, originalConfigBase;
 	let exposeRemoteDependencies = {};
 	let exposeRemoteDependenciesDirty = true;
@@ -6945,7 +8114,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 			}
 		},
 		async load(id) {
-			if (id === remoteEntryId) return parsePromise.then((_) => generateRemoteEntry(options, virtualExposesId, _command));
+			if (id === remoteEntryId) return getParsePromise().then((_) => generateRemoteEntry(options, virtualExposesId, _command));
 			if (id === virtualExposesId) {
 				await refreshExposeRemoteDependencies(this);
 				return generateExposes(options, exposeRemoteDependencies, _command, reactIslandExposes);
@@ -6955,7 +8124,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		async transform(code, id) {
 			return mapCodeToCodeWithSourcemap(await (async () => {
 				if (!filterId(id)) return;
-				if (id.includes(remoteEntryId)) return parsePromise.then((_) => generateRemoteEntry(options, virtualExposesId, _command));
+				if (id.includes(remoteEntryId)) return getParsePromise().then((_) => generateRemoteEntry(options, virtualExposesId, _command));
 				if (id === virtualExposesId) {
 					await refreshExposeRemoteDependencies(this);
 					return generateExposes(options, exposeRemoteDependencies, _command, reactIslandExposes);
@@ -7091,11 +8260,58 @@ function pluginProxyRemotes_default(options) {
 			enableSsrInit = getSsrCapabilities(parseInt(version, 10), command, Object.keys(remotes).length > 0).enableSsrInitBootstrap;
 		},
 		resolveId(source, importer) {
+			const resolvedIslandConsumerId = resolveReactIslandConsumerId(source);
+			if (resolvedIslandConsumerId) return resolvedIslandConsumerId;
+			const islandRemoteId = getReactIslandImportRemoteId(source);
+			if (islandRemoteId) for (const remoteAlias of Object.keys(remotes)) {
+				if (islandRemoteId !== remoteAlias && !islandRemoteId.startsWith(`${remoteAlias}/`)) continue;
+				addUsedRemote(remoteAlias, islandRemoteId, options);
+				refreshHostAutoInit(options);
+				return `\0${getReactIslandServerImportId(islandRemoteId)}`;
+			}
 			if (!filterId(source)) return;
 			for (const remoteAlias of Object.keys(remotes)) {
 				if (source !== remoteAlias && !source.startsWith(`${remoteAlias}/`)) continue;
 				return resolveRemoteId(this, source, importer, remoteAlias);
 			}
+		},
+		load(id) {
+			return loadReactIslandConsumerModule(id);
+		}
+	};
+}
+//#endregion
+//#region src/plugins/pluginReactMixedModeGuard.ts
+const REACT_DEVELOPMENT_RUNTIME = /[\\/]react[\\/]cjs[\\/]react(?:-jsx-(?:dev-)?runtime)?\.development\.js$/;
+const UNSAFE_GET_OWNER = "return null === dispatcher ? null : dispatcher.getOwner();";
+const SAFE_GET_OWNER = "return typeof dispatcher?.getOwner === \"function\" ? dispatcher.getOwner() : null;";
+const REACT_MIXED_MODE_ROLLDOWN_PLUGIN = "module-federation:react-mixed-mode-rolldown";
+const REACT_MIXED_MODE_ESBUILD_PLUGIN = "module-federation:react-mixed-mode-esbuild";
+function patchReactDevelopmentRuntime(code, id) {
+	if (!REACT_DEVELOPMENT_RUNTIME.test(id)) return;
+	const patched = code.replaceAll(UNSAFE_GET_OWNER, SAFE_GET_OWNER);
+	return patched === code ? void 0 : patched;
+}
+function createRolldownReactMixedModeGuard() {
+	return {
+		name: REACT_MIXED_MODE_ROLLDOWN_PLUGIN,
+		transform(code, id) {
+			return patchReactDevelopmentRuntime(code, id);
+		}
+	};
+}
+function createEsbuildReactMixedModeGuard() {
+	return {
+		name: REACT_MIXED_MODE_ESBUILD_PLUGIN,
+		setup(build) {
+			build.onLoad({ filter: REACT_DEVELOPMENT_RUNTIME }, (args) => {
+				const patched = patchReactDevelopmentRuntime(readFileSync$1(args.path, "utf8"), args.path);
+				if (patched === void 0) return;
+				return {
+					contents: patched,
+					loader: "js"
+				};
+			});
 		}
 	};
 }
@@ -7244,7 +8460,7 @@ function excludeSharedSubDependencies(shared) {
 	}
 }
 function proxySharedModule(options) {
-	const { shared = {}, federationOptions } = options;
+	const { shared = {}, federationOptions, getParsePromise = () => Promise.resolve() } = options;
 	let _config;
 	let _command = "serve";
 	let useDirectReactImport = false;
@@ -7253,6 +8469,7 @@ function proxySharedModule(options) {
 	let devServer;
 	const materializedLoadShareSources = /* @__PURE__ */ new Set();
 	const emittedTreeShakingProviders = /* @__PURE__ */ new Set();
+	const hasAnalyzableShares = Object.values(shared).some((share) => shouldAnalyzeSharedExports(share));
 	const normalizeTreeShakingOutputPath = (value) => {
 		const normalized = normalizePathForImport(value);
 		if (path$1.posix.isAbsolute(normalized) || /^[A-Za-z]:\//.test(normalized) || normalized.split("/").includes("..")) throw new Error(`Invalid treeShakingDir "${value}": absolute paths and parent segments are not allowed.`);
@@ -7297,9 +8514,9 @@ function proxySharedModule(options) {
 				if (source === getLocalSharedImportMapPath(federationOptions)) return getResolvedLocalSharedImportMapId(federationOptions);
 			},
 			load(id) {
-				if (id === getResolvedLocalSharedImportMapId(federationOptions)) return parsePromise.then((_) => {
+				if (id === getResolvedLocalSharedImportMapId(federationOptions)) return getParsePromise().then((_) => {
 					refreshTreeShakingModules(federationOptions);
-					const providerPackages = new Set([...Object.keys(shared).filter((pkg) => !pkg.endsWith("/")), ...getUsedShares(federationOptions)]);
+					const providerPackages = /* @__PURE__ */ new Set([...Object.keys(shared).filter((pkg) => !pkg.endsWith("/")), ...getUsedShares(federationOptions)]);
 					for (const pkg of providerPackages) {
 						const sharedKey = findSharedKeyForSource(pkg, shared);
 						const shareItem = shared[pkg] || (sharedKey ? shared[sharedKey] : void 0);
@@ -7352,10 +8569,10 @@ function proxySharedModule(options) {
 				refreshTreeShakingModules(federationOptions);
 			},
 			shouldTransformCachedModule() {
-				return _command === "build" && Object.values(shared).some((share) => !!share.shareConfig.treeShaking);
+				return _command === "build" && hasAnalyzableShares;
 			},
 			transform(code, id) {
-				if (_command !== "build" || !Object.keys(shared).some((key) => shared[key].shareConfig.treeShaking)) return;
+				if (_command !== "build" || !hasAnalyzableShares) return;
 				collectTreeShakingImports(code, id, shared, findSharedKeyForSource, (sharedKey, exports, request) => recordTreeShakingExports(sharedKey, exports, request, federationOptions), (sharedKey, request) => markTreeShakingPackageUnsafe(sharedKey, request, federationOptions));
 				refreshTreeShakingModules(federationOptions);
 			}
@@ -7459,6 +8676,15 @@ const JS_EXTENSIONS_RE = /\.(?:[mc]?[jt]sx?|vue|svelte)(?:\?|$)/;
 function isAstNode(value) {
 	return !!value && typeof value === "object" && typeof value.type === "string";
 }
+function findStaticRemoteSources(code, isRemoteImport) {
+	const codePositions = createCodePositionMap(code);
+	const sources = /* @__PURE__ */ new Set();
+	for (const pattern of [/\b(?:import|export)\s+[^;]*?\bfrom\s*["']([^"']+)["']/g, /\bimport\s*["']([^"']+)["']/g]) for (const match of code.matchAll(pattern)) {
+		const source = match[1];
+		if (codePositions[match.index] && isRemoteImport(source)) sources.add(source);
+	}
+	return sources;
+}
 function walkAST(root, visitor) {
 	const seen = /* @__PURE__ */ new WeakSet();
 	function visit(node) {
@@ -7611,6 +8837,7 @@ async function collectFromAST(ast, code, isRemoteImport) {
 			if (!value || !isRemoteImport(value)) return;
 			result.push({
 				kind: "dynamic",
+				source: value,
 				start: node.start,
 				end: node.end,
 				originalText: code.slice(node.start, node.end)
@@ -7689,6 +8916,7 @@ function collectFromRegex(code, isRemoteImport) {
 		if (!isRemoteImport(source)) continue;
 		result.push({
 			kind: "dynamic",
+			source,
 			start: match.index,
 			end: match.index + full.length,
 			originalText: full
@@ -7715,6 +8943,7 @@ function pluginRemoteNamedExports(options) {
 			if (!JS_EXTENSIONS_RE.test(id)) return;
 			if (!remoteNames.some((name) => code.includes(name))) return;
 			const matchesRemoteImport = (source) => isRemoteImport(source, id);
+			for (const source of findStaticRemoteSources(code, matchesRemoteImport)) markStaticRemote(source, options);
 			let imports;
 			try {
 				imports = await collectFromAST(this.parse(code), code, matchesRemoteImport);
@@ -7723,6 +8952,7 @@ function pluginRemoteNamedExports(options) {
 				imports = collectFromRegex(code, matchesRemoteImport);
 			}
 			if (!imports) return;
+			for (const remoteImport of imports) if (remoteImport.kind === "dynamic") markDynamicRemote(remoteImport.source, options);
 			return applyRewrites(code, imports, id);
 		}
 	};
@@ -7731,14 +8961,14 @@ function pluginRemoteNamedExports(options) {
 //#region src/plugins/pluginSSRRemoteEntry.ts
 const MAX_RUNNER_BODY_BYTES = 1024 * 1024;
 const MAX_RUNNER_START_OFFSET = 1024 * 1024;
-const ALLOWED_RUNNER_INVOKE_NAMES = new Set(["fetchModule", "getBuiltins"]);
+const ALLOWED_RUNNER_INVOKE_NAMES = /* @__PURE__ */ new Set(["fetchModule", "getBuiltins"]);
 const VITE_FS_PREFIX = "/@fs/";
 function isPlainObject(value) {
 	return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function isSafeRunnerFetchModuleOptions(value) {
 	if (!isPlainObject(value)) return false;
-	const allowedKeys = new Set([
+	const allowedKeys = /* @__PURE__ */ new Set([
 		"cached",
 		"startOffset",
 		"inlineSourceMap"
@@ -7876,7 +9106,7 @@ function pluginSSRRemoteEntry(options) {
 		...options.ssrExternals ?? []
 	];
 	const ssrOnlyExternalPattern = new RegExp(`^(${ssrOnlyExternals.map((e) => e.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&")).join("|")})(\\/.*)?$`);
-	const ssrModuleIds = new Set([remoteEntrySSRId, virtualExposesSSRId]);
+	const ssrModuleIds = /* @__PURE__ */ new Set([remoteEntrySSRId, virtualExposesSSRId]);
 	const resolvedAbsToPackage = /* @__PURE__ */ new Map();
 	let isServe = false;
 	let viteConfig;
@@ -7929,7 +9159,7 @@ function pluginSSRRemoteEntry(options) {
 		},
 		configureServer(server) {
 			const base = "/__mf_ssr__";
-			const basePath = getBasePath$1(viteConfig?.base);
+			const basePath = getBasePath$2(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}`;
@@ -8073,7 +9303,7 @@ function collectEntryOutputFiles(bundle, entryFileName) {
 		const file = bundle[fileName];
 		if (!file) return;
 		files.add(fileName);
-		const dependencies = new Set([
+		const dependencies = /* @__PURE__ */ new Set([
 			...file.imports || [],
 			...file.dynamicImports || [],
 			...file.implicitlyLoadedBefore || [],
@@ -8102,9 +9332,20 @@ const VarRemoteEntry = (providedOptions) => {
 	return [{
 		name: "module-federation-var-remote-entry",
 		apply: "serve",
+		/**
+		* Stores resolved Vite config for later use
+		*/
+		/**
+		* Finalizes configuration after all plugins are resolved
+		* @param config - Fully resolved Vite config
+		*/
 		configResolved(config) {
 			viteConfig = config;
 		},
+		/**
+		* Configures dev server middleware to handle varRemoteEntry requests
+		* @param server - Vite dev server instance
+		*/
 		configureServer(server) {
 			server.middlewares.use((req, res, next) => {
 				if (!varFilename) {
@@ -8121,12 +9362,22 @@ const VarRemoteEntry = (providedOptions) => {
 	}, {
 		name: "module-federation-var-remote-entry",
 		enforce: "post",
+		/**
+		* Initial plugin configuration
+		* @param config - Vite config object
+		* @param command - Current Vite command (serve/build)
+		*/
 		config(config) {
 			if (!config.build) config.build = {};
 		},
 		configResolved(config) {
 			viteConfig = config;
 		},
+		/**
+		* Generates the module federation "var" remote entry file
+		* @param options - Rollup output options
+		* @param bundle - Generated bundle assets
+		*/
 		async generateBundle(_options, bundle) {
 			if (!varFilename) return;
 			if (!isValidVarName(name)) mfWarn(`Provided remote name "${name}" is not valid for "var" remoteEntry type, thus it's placed in globalThis['${name}'].\nIt may cause problems, so you would better want to use valid var name (see https://www.w3schools.com/js/js_variables.asp).`);
@@ -8278,7 +9529,7 @@ const DEFAULT_WEBWORKER_SSR_EXPORT_CONDITIONS = [
 ];
 const VITE_DEV_PROD_CONDITION = "development|production";
 function appendConditions(conditions, fallbackConditions) {
-	return [...new Set([...conditions, ...fallbackConditions])];
+	return [.../* @__PURE__ */ new Set([...conditions, ...fallbackConditions])];
 }
 function resolveViteModeCondition(conditions, isProduction) {
 	const modeCondition = isProduction ? "production" : "development";
@@ -8448,7 +9699,7 @@ function canResolveSharedSubpath(subpath, projectRoot) {
 		return false;
 	}
 }
-const VITE_DEV_IMPORT_CONDITIONS = new Set([
+const VITE_DEV_IMPORT_CONDITIONS = /* @__PURE__ */ new Set([
 	"browser",
 	"development",
 	"import",
@@ -8536,6 +9787,7 @@ function includeLinkedSharedEntries(optimizeDeps, shared, projectRoot, exposes,
 function createEarlyVirtualModulesPlugin(options) {
 	const { shared, remotes } = options;
 	const isLitShare = (pkg) => pkg === "lit" || pkg.startsWith("lit/");
+	const shouldGuardReactMixedMode = Object.keys(remotes ?? {}).length > 0 && shared?.react?.shareConfig.singleton === true;
 	return {
 		name: "vite:module-federation-early-init",
 		enforce: "pre",
@@ -8563,6 +9815,7 @@ function createEarlyVirtualModulesPlugin(options) {
 					if (isRolldown) {
 						optimizeDeps.rolldownOptions ??= {};
 						optimizeDeps.rolldownOptions.plugins ??= [];
+						if (shouldGuardReactMixedMode) optimizeDeps.rolldownOptions.plugins.push(createRolldownReactMixedModeGuard());
 						optimizeDeps.rolldownOptions.plugins.push({
 							name: "module-federation:optimize-shared-resolver",
 							load(id) {
@@ -8607,6 +9860,7 @@ function createEarlyVirtualModulesPlugin(options) {
 					} else {
 						optimizeDeps.esbuildOptions ??= {};
 						optimizeDeps.esbuildOptions.plugins ??= [];
+						if (shouldGuardReactMixedMode) optimizeDeps.esbuildOptions.plugins.push(createEsbuildReactMixedModeGuard());
 						optimizeDeps.esbuildOptions.plugins.push({
 							name: "module-federation:optimize-shared-proxy",
 							setup(build) {
@@ -8738,7 +9992,7 @@ export default __mfShared.default ?? __mfShared;`
 		}
 	};
 }
-const SSR_ONLY_PLUGINS = new Set(["@module-federation/vite/ssrEntryLoader"]);
+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;
@@ -8750,7 +10004,7 @@ function applyBuildTimeRuntimeDefines(define, options, { target, isAstro, defaul
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-Dbbi4cnh.js").then((n) => n.n).then(({ default: pluginDts }) => pluginDts(options))];
+	return [Promise.resolve().then(() => pluginDts_exports).then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {
@@ -8789,6 +10043,14 @@ function federation(mfUserOptions) {
 	if (!name) throw createModuleFederationError("name is required");
 	const remoteEntryId = getRemoteEntryId(options);
 	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__");
+	}, {
+		moduleParseTimeout: options.moduleParseTimeout,
+		moduleParseIdleTimeout: options.moduleParseIdleTimeout,
+		exposedModuleImports: Object.values(options.exposes).map((expose) => expose.import)
+	}, moduleParseController);
 	let command;
 	let desiredRolldownOutput;
 	let isSsrBuild = false;
@@ -8820,7 +10082,7 @@ function federation(mfUserOptions) {
 		writePreBuildLibPath(pkg, shared[key], options, getLoadHookExportConditions(context, loadOptions));
 		return "refreshed";
 	};
-	const refreshLoadShareModuleForEnvironment = (id, context, loadOptions) => {
+	const refreshLoadShareModuleForEnvironment = (id, context, loadOptions, importFalseExportUsage) => {
 		const pkg = getCachedLoadSharePkg(id);
 		if (!pkg) return "not-applicable";
 		const key = findSharedKey(pkg, shared);
@@ -8828,9 +10090,26 @@ function federation(mfUserOptions) {
 		const requestedModule = VirtualModule.findById(id);
 		const ownedModule = VirtualModule.findById(getLoadShareModulePath(pkg, false, options));
 		if (!requestedModule || requestedModule !== ownedModule) return "not-owned";
-		writeLoadShareModule(pkg, shared[key], command, getIsRolldown(context), options, getLoadHookExportConditions(context, loadOptions));
+		writeLoadShareModule(pkg, shared[key], command, getIsRolldown(context), options, getLoadHookExportConditions(context, loadOptions), importFalseExportUsage);
 		return "refreshed";
 	};
+	const getCompleteImportFalseExportUsage = (id) => {
+		if (command !== "build") return void 0;
+		const pkg = getCachedLoadSharePkg(id);
+		if (!pkg) return void 0;
+		const key = findSharedKey(pkg, shared);
+		if (!key || shared[key].shareConfig.import !== false) return void 0;
+		return moduleParseController.parsePromise.then((completion) => {
+			if (!completion.complete) {
+				if (!moduleParseController.discardWarned) {
+					moduleParseController.discardWarned = true;
+					mfWarn(`import: false shared export analysis was discarded (reason: ${completion.reason}) — falling back to the complete export surface, so shared consumers keep every detected named export.` + (completion.reason === "idle-timeout" || completion.reason === "timeout" ? " If the build is simply slow, increasing moduleParseIdleTimeout may let the analysis finish." : ""));
+				}
+				return;
+			}
+			return getSharedExportUsage(pkg, shared[key], key, options);
+		});
+	};
 	return [
 		{
 			name: "vite:module-federation-virtual-modules",
@@ -8936,20 +10215,16 @@ function federation(mfUserOptions) {
 		pluginProxyRemoteEntry_default({
 			options,
 			remoteEntryId,
-			virtualExposesId
+			virtualExposesId,
+			getParsePromise: () => moduleParseController.parsePromise
 		}),
 		pluginProxyRemotes_default(options),
 		pluginRemoteNamedExports(options),
-		...pluginModuleParseEnd_default((id) => {
-			return id.includes(getHostAutoInitImportId(options)) || id.includes(remoteEntryId) || id.includes(virtualExposesId) || id.includes(getLocalSharedImportMapPath(options)) || id.includes("__loadShare__") || id.includes("__prebuild__") || id.includes("__treeShakingProvider__") || id.includes("__mf_tree_shaking_graph__");
-		}, {
-			moduleParseTimeout: options.moduleParseTimeout,
-			moduleParseIdleTimeout: options.moduleParseIdleTimeout,
-			exposedModuleImports: Object.values(options.exposes).map((expose) => expose.import)
-		}),
+		...moduleParsePlugins,
 		...proxySharedModule({
 			shared,
-			federationOptions: options
+			federationOptions: options,
+			getParsePromise: () => moduleParseController.parsePromise
 		}),
 		{
 			name: "module-federation-esm-shims",
@@ -9077,8 +10352,9 @@ function federation(mfUserOptions) {
 				}
 			},
 			load(id, loadOptions) {
-				if (id.includes("__loadShare__") || id.includes("__loadRemote__")) {
-					if (id.includes("__loadShare__") && refreshLoadShareModuleForEnvironment(id, this, loadOptions) === "not-owned") return;
+				const loadVirtualModule = (importFalseExportUsage) => {
+					if (!id.includes("__loadShare__") && !id.includes("__loadRemote__")) return;
+					if (id.includes("__loadShare__") && refreshLoadShareModuleForEnvironment(id, this, loadOptions, importFalseExportUsage) === "not-owned") return;
 					const virtualModule = VirtualModule.findById(id);
 					if (!virtualModule?.code) return null;
 					let code = virtualModule.code;
@@ -9095,7 +10371,10 @@ function federation(mfUserOptions) {
 						code,
 						syntheticNamedExports: "__moduleExports"
 					};
-				}
+				};
+				const pendingImportFalseExportUsage = id.includes("__loadShare__") ? getCompleteImportFalseExportUsage(id) : void 0;
+				if (pendingImportFalseExportUsage) return pendingImportFalseExportUsage.then(loadVirtualModule);
+				return loadVirtualModule();
 			},
 			generateBundle(_outputOptions, bundle, _isWrite) {
 				for (const [fileName, chunk] of Object.entries(bundle)) {
@@ -9230,7 +10509,8 @@ function federation(mfUserOptions) {
 					};
 					res.end = (chunk, ...args) => {
 						if (chunk) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-						return end(normalizeVinextRscPreloadHints(Buffer.concat(chunks).toString()), ...args);
+						const body = normalizeVinextRscPreloadHints(Buffer.concat(chunks).toString());
+						return end(body, ...args);
 					};
 					next();
 				});