@module-federation/vite 1.19.1 → 1.20.1

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-9RTNVO8v.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;
@@ -148,7 +209,156 @@ async function mapCodeToCodeWithSourcemap(code) {
 	};
 }
 //#endregion
+//#region src/utils/codePositionMap.ts
+const REGEX_PREFIX_KEYWORDS = /* @__PURE__ */ new Set([
+	"await",
+	"case",
+	"delete",
+	"in",
+	"instanceof",
+	"new",
+	"return",
+	"throw",
+	"typeof",
+	"void",
+	"yield"
+]);
+function isJsxClosingTagSlash(code, slashIndex) {
+	if (code[slashIndex - 1] !== "<") return false;
+	let cursor = slashIndex + 1;
+	while (/\s/.test(code[cursor] || "")) cursor++;
+	if (code[cursor] === ">") return true;
+	const tagStart = cursor;
+	while (/[-:.$_\u200C\u200D\p{ID_Continue}]/u.test(code[cursor] || "")) cursor++;
+	if (cursor === tagStart) return false;
+	while (/\s/.test(code[cursor] || "")) cursor++;
+	return code[cursor] === ">";
+}
+/** Mark comments, string/template literals, and regular expressions as non-code. */
+function createCodePositionMap(code) {
+	const positions = Array(code.length).fill(true);
+	const mask = (start, end) => {
+		for (let index = start; index < end; index++) positions[index] = false;
+	};
+	let canStartRegex = true;
+	for (let index = 0; index < code.length;) {
+		const char = code[index];
+		const next = code[index + 1];
+		if (/\s/.test(char)) {
+			index++;
+			continue;
+		}
+		if (char === "/" && next === "/") {
+			const start = index;
+			index += 2;
+			while (index < code.length && code[index] !== "\n" && code[index] !== "\r") index++;
+			mask(start, index);
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			const start = index;
+			index += 2;
+			while (index < code.length && !(code[index] === "*" && code[index + 1] === "/")) index++;
+			index = Math.min(code.length, index + 2);
+			mask(start, index);
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			const quote = char;
+			const start = index++;
+			while (index < code.length) {
+				if (code[index] === "\\") {
+					index += 2;
+					continue;
+				}
+				if (code[index] === quote) {
+					index++;
+					break;
+				}
+				index++;
+			}
+			mask(start, index);
+			canStartRegex = false;
+			continue;
+		}
+		const closesJsxTag = isJsxClosingTagSlash(code, index);
+		if (char === "/" && canStartRegex && !closesJsxTag) {
+			const start = index;
+			let cursor = index + 1;
+			let escaped = false;
+			let inCharacterClass = false;
+			let closed = false;
+			for (; cursor < code.length; cursor++) {
+				const regexChar = code[cursor];
+				if (regexChar === "\n" || regexChar === "\r") break;
+				if (escaped) {
+					escaped = false;
+					continue;
+				}
+				if (regexChar === "\\") {
+					escaped = true;
+					continue;
+				}
+				if (regexChar === "[") {
+					inCharacterClass = true;
+					continue;
+				}
+				if (regexChar === "]" && inCharacterClass) {
+					inCharacterClass = false;
+					continue;
+				}
+				if (regexChar === "/" && !inCharacterClass) {
+					cursor++;
+					while (/[$_\p{ID_Continue}]/u.test(code[cursor] || "")) cursor++;
+					closed = true;
+					break;
+				}
+			}
+			if (closed) {
+				mask(start, cursor);
+				index = cursor;
+				canStartRegex = false;
+				continue;
+			}
+		}
+		if (/[$_\p{ID_Start}]/u.test(char)) {
+			const start = index++;
+			while (/[$_\u200C\u200D\p{ID_Continue}]/u.test(code[index] || "")) index++;
+			canStartRegex = REGEX_PREFIX_KEYWORDS.has(code.slice(start, index));
+			continue;
+		}
+		if (/\d/.test(char)) {
+			index++;
+			while (/[\w.]/.test(code[index] || "")) index++;
+			canStartRegex = false;
+			continue;
+		}
+		if ((char === "+" || char === "-") && next === char) {
+			index += 2;
+			continue;
+		}
+		if (char === "!" && next !== "=") {
+			index++;
+			continue;
+		}
+		if (char === ")" || char === "]" || char === "}") canStartRegex = false;
+		else if (char !== ".") canStartRegex = true;
+		index++;
+	}
+	return positions;
+}
+//#endregion
 //#region src/utils/htmlEntryUtils.ts
+function findModuleImportSources(code) {
+	const codePositions = createCodePositionMap(code);
+	const sources = /* @__PURE__ */ new Set();
+	for (const pattern of [
+		/\b(?:import|export)\s+[^;]*?\bfrom\s*["']([^"']+)["']/g,
+		/\bimport\s*\(\s*["']([^"']+)["']/g,
+		/\bimport\s*["']([^"']+)["']/g
+	]) for (const match of code.matchAll(pattern)) if (codePositions[match.index]) sources.add(match[1]);
+	return Array.from(sources);
+}
 function sanitizeDevEntryPath(devEntryPath) {
 	return devEntryPath.replace(/\\\\?/g, "/");
 }
@@ -172,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: [
@@ -247,11 +926,11 @@ 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(/\?.*$/, "");
@@ -492,6 +1171,13 @@ function normalizeManifest(manifest) {
 		fileName: manifest.fileName || "mf-manifest.json"
 	};
 }
+function normalizeExperiments(experiments) {
+	return {
+		externalRuntime: experiments?.externalRuntime === true,
+		provideExternalRuntime: experiments?.provideExternalRuntime === true,
+		ssrMode: experiments?.ssrMode === "ISLAND" ? "ISLAND" : void 0
+	};
+}
 let config;
 let explicitSharedKeys = /* @__PURE__ */ new Set();
 const explicitSharedKeysByOptions = /* @__PURE__ */ new WeakMap();
@@ -551,8 +1237,10 @@ function normalizeModuleFederationOptions(options) {
 		target: options.target,
 		disableRemote: options.disableRemote,
 		disableShared: options.disableShared,
-		disableSnapshot: options.disableSnapshot
+		disableSnapshot: options.disableSnapshot,
+		experiments: normalizeExperiments(options.experiments)
 	};
+	if (normalized.experiments.ssrMode === "ISLAND" && Object.prototype.hasOwnProperty.call(normalized.shared, "react")) mfWarn("Island expose generation is disabled because experiments.ssrMode is \"ISLAND\" and React is configured as shared. Remove \"react\" from shared to generate island exposes, or remove ssrMode to use standard shared rendering.");
 	explicitSharedKeysByOptions.set(normalized, new Set(explicitSharedKeys));
 	return config = normalized;
 }
@@ -569,6 +1257,7 @@ const cacheMap = {};
 const idCacheMap = {};
 const VITE_ID_PREFIX = "/@id/";
 const VITE_ENCODED_NULL_BYTE_PREFIX = `${VITE_ID_PREFIX}__x00__`;
+const MF_OWNER_INFIX = "__mf_owner__";
 function escapeRegExp$2(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -717,6 +1406,245 @@ function serializeRuntimeOptions(options) {
 	return `{${topLevelProps.join(", ")}}`;
 }
 //#endregion
+//#region src/utils/reactIsland.ts
+const SOURCE_EXTENSIONS = [
+	".tsx",
+	".jsx",
+	".ts",
+	".js",
+	".mts",
+	".mjs",
+	".cts",
+	".cjs"
+];
+function stripQueryAndHash$2(id) {
+	return id.split(/[?#]/, 1)[0];
+}
+function resolveSourceFile(importPath, root) {
+	const cleanImport = stripQueryAndHash$2(importPath);
+	if (!cleanImport.startsWith(".") && !path$1.isAbsolute(cleanImport)) return;
+	const candidate = path$1.isAbsolute(cleanImport) ? cleanImport : path$1.resolve(root, cleanImport);
+	return [
+		candidate,
+		...SOURCE_EXTENSIONS.map((extension) => `${candidate}${extension}`),
+		...SOURCE_EXTENSIONS.map((extension) => path$1.join(candidate, `index${extension}`))
+	].find((filePath) => {
+		try {
+			return fs$1.statSync(filePath).isFile();
+		} catch {
+			return false;
+		}
+	});
+}
+function localDefaultReexport(source) {
+	const match = source.match(/export\s*{\s*(?:default(?:\s+as\s+default)?|[A-Za-z_$][\w$]*\s+as\s+default)\s*}\s*from\s*["']([^"']+)["']/);
+	return match?.[1]?.startsWith(".") ? match[1] : void 0;
+}
+function isReactComponentSource(source, filePath = "component.tsx") {
+	if (!(/\bexport\s+default\b/.test(source) || /\bexport\s*{[^}]*\bdefault\b[^}]*}(?:\s*from\s*["'][^"']+["'])?/.test(source))) return false;
+	const extension = path$1.extname(stripQueryAndHash$2(filePath)).toLowerCase();
+	const canContainJsx = extension === ".tsx" || extension === ".jsx";
+	const hasJsx = /<>|<\s*[A-Za-z][\w.:-]*(?:\s[^<>]*?)?\s*\/?>/.test(source);
+	const importsReact = /\bfrom\s*["']react["']|\brequire\(\s*["']react["']\s*\)/.test(source);
+	const usesReactApi = /\b(?:React\.)?(?:createElement|jsx|jsxs)\s*\(/.test(source);
+	const isClientModule = /^\s*["']use client["']\s*;?/m.test(source);
+	return canContainJsx && hasJsx || importsReact && (hasJsx || usesReactApi || isClientModule);
+}
+function isReactComponentFile(filePath, seen = /* @__PURE__ */ new Set()) {
+	const normalizedPath = path$1.resolve(filePath);
+	if (seen.has(normalizedPath)) return false;
+	seen.add(normalizedPath);
+	let source;
+	try {
+		source = fs$1.readFileSync(normalizedPath, "utf8");
+	} catch {
+		return false;
+	}
+	if (isReactComponentSource(source, normalizedPath)) return true;
+	const reexport = localDefaultReexport(source);
+	if (!reexport) return false;
+	const reexportPath = resolveSourceFile(reexport, path$1.dirname(normalizedPath));
+	return reexportPath ? isReactComponentFile(reexportPath, seen) : false;
+}
+/**
+* React is shared by the normal MF runtime when explicitly configured. When it
+* is local, UI exposes can safely advertise an island capability in addition
+* to their unchanged default export.
+*/
+function getReactIslandExposes(options, root) {
+	if (options.experiments.ssrMode !== "ISLAND") return /* @__PURE__ */ new Set();
+	if (Object.prototype.hasOwnProperty.call(options.shared, "react")) return /* @__PURE__ */ new Set();
+	const islandExposes = /* @__PURE__ */ new Set();
+	for (const [key, expose] of Object.entries(options.exposes)) {
+		const sourceFile = resolveSourceFile(expose.import, root);
+		if (sourceFile && isReactComponentFile(sourceFile)) islandExposes.add(key);
+	}
+	return islandExposes;
+}
+function generateReactIslandBrowserDefinition(enabled) {
+	if (!enabled) return "";
+	return `
+          exportModule.__mf_island = {
+            version: 1,
+            renderToHtml() {
+              return Promise.reject(new Error("[Module Federation] renderToHtml is only available in the SSR remote entry"));
+            },
+            hydrate(element, props) {
+              const root = element && element.hasAttribute && element.hasAttribute("data-mf-island-state")
+                ? element
+                : element && element.querySelector
+                  ? element.querySelector("[data-mf-island-state]") || element
+                  : element;
+              if (!root) {
+                return Promise.reject(new Error("[Module Federation] Cannot hydrate an island without a root element"));
+              }
+              let serverProps = {};
+              const encodedState = root.getAttribute && root.getAttribute("data-mf-island-state");
+              if (encodedState) {
+                try {
+                  serverProps = JSON.parse(decodeURIComponent(encodedState));
+                } catch {
+                  serverProps = {};
+                }
+              }
+              const finalProps = Object.assign({}, serverProps, props || {});
+              return Promise.all([import("react"), import("react-dom/client")]).then(([React, ReactDOMClient]) => {
+                if (typeof ReactDOMClient.hydrateRoot !== "function") {
+                  throw new Error("[Module Federation] react-dom/client does not provide hydrateRoot");
+                }
+                return ReactDOMClient.hydrateRoot(
+                  root,
+                  React.createElement(importModule.default, finalProps)
+                );
+              });
+            }
+          }`;
+}
+function generateReactIslandSSRDefinition(enabled) {
+	if (!enabled) return "";
+	return `
+          exportModule.__mf_island = {
+            version: 1,
+            async renderToHtml(props) {
+              if (typeof importModule.default !== "function" && typeof importModule.default !== "object") {
+                throw new Error("[Module Federation] A React island expose must have a default component export");
+              }
+              const loadedProps = typeof importModule.load === "function" ? await importModule.load() : {};
+              const finalProps = Object.assign({}, loadedProps || {}, props || {});
+              const [React, ReactDOMServer] = await Promise.all([
+                import("react"),
+                import("react-dom/server")
+              ]);
+              const body = ReactDOMServer.renderToString(
+                React.createElement(importModule.default, finalProps)
+              );
+              const state = encodeURIComponent(JSON.stringify(finalProps));
+              return '<div data-mf-island-state="' + state + '">' + body + '</div>';
+            },
+            hydrate() {
+              return Promise.reject(new Error("[Module Federation] hydrate is only available in the browser remote entry"));
+            }
+          }`;
+}
+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__";
 function getExposesCssMapPlaceholder() {
@@ -725,7 +1653,7 @@ function getExposesCssMapPlaceholder() {
 function getVirtualExposesId(options) {
 	return `virtual:mf-exposes:${`${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
 }
-function generateExposes(options, remoteDependencyMap = {}, command = "build") {
+function generateExposes(options, remoteDependencyMap = {}, command = "build", reactIslandExposes = /* @__PURE__ */ new Set()) {
 	return `
     const cssAssetMap = ${JSON.stringify(options.bundleAllCSS ? EXPOSES_CSS_MAP_PLACEHOLDER : {})};
     const injectedCssHrefs = new Set();
@@ -801,6 +1729,7 @@ function generateExposes(options, remoteDependencyMap = {}, command = "build") {
           }
           const exportModule = {}
           Object.assign(exportModule, importModule)
+          ${generateReactIslandBrowserDefinition(reactIslandExposes.has(key))}
           Object.defineProperty(exportModule, "__esModule", {
             value: true,
             enumerable: false
@@ -832,7 +1761,7 @@ function getRuntimeInitModule(options) {
 	let runtimeInitModule = runtimeInitModules.get(options);
 	if (!runtimeInitModule) {
 		const ownerId = getRuntimeInitOwnerId(options);
-		runtimeInitModule = new VirtualModule("runtimeInit", "__mf_v__", "", `${options.internalName}__mf_owner__${ownerId}`);
+		runtimeInitModule = new VirtualModule("runtimeInit", "__mf_v__", "", `${options.internalName}${MF_OWNER_INFIX}${ownerId}`);
 		runtimeInitModules.set(options, runtimeInitModule);
 	}
 	return runtimeInitModule;
@@ -845,7 +1774,7 @@ function getRuntimeRemoteCachePrefix(options) {
 }
 function getRuntimeRemoteAlias(alias, options) {
 	if (!options) return alias;
-	return `${options.internalName}__mf_owner__${getRuntimeInitOwnerId(options)}__${alias}`;
+	return `${options.internalName}${MF_OWNER_INFIX}${getRuntimeInitOwnerId(options)}__${alias}`;
 }
 function getRuntimeInitGlobalKey(ownerImportId) {
 	return `__mf_init__${ownerImportId ?? virtualRuntimeInitStatus.getImportId()}__`;
@@ -974,154 +1903,15 @@ function getRuntimeInitResolveBootstrapCode(enableSsrInit = false, ownerImportId
 		ssrRemotes
 	});
 }
-function writeRuntimeInitStatus(command, enableSsrInit = false, hostInitImportId, options, ssrRemotes = _ssrRemotes) {
-	const exportStatement = command === "build" ? `const { initPromise, initResolve, initReject, moduleCache } = globalThis[globalKey];
-export { initPromise, initResolve, initReject, moduleCache };` : `module.exports = globalThis[globalKey];`;
-	const ownerImportId = options ? getRuntimeInitStatusImportId(options) : hostInitImportId;
-	getRuntimeInitModule(options).writeSync(`
-${getRuntimeInitBootstrapCode(enableSsrInit, ownerImportId, ssrRemotes, hostInitImportId)}
-${exportStatement}
-`);
-}
-//#endregion
-//#region src/utils/codePositionMap.ts
-const REGEX_PREFIX_KEYWORDS = new Set([
-	"await",
-	"case",
-	"delete",
-	"in",
-	"instanceof",
-	"new",
-	"return",
-	"throw",
-	"typeof",
-	"void",
-	"yield"
-]);
-function isJsxClosingTagSlash(code, slashIndex) {
-	if (code[slashIndex - 1] !== "<") return false;
-	let cursor = slashIndex + 1;
-	while (/\s/.test(code[cursor] || "")) cursor++;
-	if (code[cursor] === ">") return true;
-	const tagStart = cursor;
-	while (/[-:.$_\u200C\u200D\p{ID_Continue}]/u.test(code[cursor] || "")) cursor++;
-	if (cursor === tagStart) return false;
-	while (/\s/.test(code[cursor] || "")) cursor++;
-	return code[cursor] === ">";
-}
-/** Mark comments, string/template literals, and regular expressions as non-code. */
-function createCodePositionMap(code) {
-	const positions = Array(code.length).fill(true);
-	const mask = (start, end) => {
-		for (let index = start; index < end; index++) positions[index] = false;
-	};
-	let canStartRegex = true;
-	for (let index = 0; index < code.length;) {
-		const char = code[index];
-		const next = code[index + 1];
-		if (/\s/.test(char)) {
-			index++;
-			continue;
-		}
-		if (char === "/" && next === "/") {
-			const start = index;
-			index += 2;
-			while (index < code.length && code[index] !== "\n" && code[index] !== "\r") index++;
-			mask(start, index);
-			continue;
-		}
-		if (char === "/" && next === "*") {
-			const start = index;
-			index += 2;
-			while (index < code.length && !(code[index] === "*" && code[index + 1] === "/")) index++;
-			index = Math.min(code.length, index + 2);
-			mask(start, index);
-			continue;
-		}
-		if (char === "\"" || char === "'" || char === "`") {
-			const quote = char;
-			const start = index++;
-			while (index < code.length) {
-				if (code[index] === "\\") {
-					index += 2;
-					continue;
-				}
-				if (code[index] === quote) {
-					index++;
-					break;
-				}
-				index++;
-			}
-			mask(start, index);
-			canStartRegex = false;
-			continue;
-		}
-		const closesJsxTag = isJsxClosingTagSlash(code, index);
-		if (char === "/" && canStartRegex && !closesJsxTag) {
-			const start = index;
-			let cursor = index + 1;
-			let escaped = false;
-			let inCharacterClass = false;
-			let closed = false;
-			for (; cursor < code.length; cursor++) {
-				const regexChar = code[cursor];
-				if (regexChar === "\n" || regexChar === "\r") break;
-				if (escaped) {
-					escaped = false;
-					continue;
-				}
-				if (regexChar === "\\") {
-					escaped = true;
-					continue;
-				}
-				if (regexChar === "[") {
-					inCharacterClass = true;
-					continue;
-				}
-				if (regexChar === "]" && inCharacterClass) {
-					inCharacterClass = false;
-					continue;
-				}
-				if (regexChar === "/" && !inCharacterClass) {
-					cursor++;
-					while (/[$_\p{ID_Continue}]/u.test(code[cursor] || "")) cursor++;
-					closed = true;
-					break;
-				}
-			}
-			if (closed) {
-				mask(start, cursor);
-				index = cursor;
-				canStartRegex = false;
-				continue;
-			}
-		}
-		if (/[$_\p{ID_Start}]/u.test(char)) {
-			const start = index++;
-			while (/[$_\u200C\u200D\p{ID_Continue}]/u.test(code[index] || "")) index++;
-			canStartRegex = REGEX_PREFIX_KEYWORDS.has(code.slice(start, index));
-			continue;
-		}
-		if (/\d/.test(char)) {
-			index++;
-			while (/[\w.]/.test(code[index] || "")) index++;
-			canStartRegex = false;
-			continue;
-		}
-		if ((char === "+" || char === "-") && next === char) {
-			index += 2;
-			continue;
-		}
-		if (char === "!" && next !== "=") {
-			index++;
-			continue;
-		}
-		if (char === ")" || char === "]" || char === "}") canStartRegex = false;
-		else if (char !== ".") canStartRegex = true;
-		index++;
-	}
-	return positions;
-}
+function writeRuntimeInitStatus(command, enableSsrInit = false, hostInitImportId, options, ssrRemotes = _ssrRemotes) {
+	const exportStatement = command === "build" ? `const { initPromise, initResolve, initReject, moduleCache } = globalThis[globalKey];
+export { initPromise, initResolve, initReject, moduleCache };` : `module.exports = globalThis[globalKey];`;
+	const ownerImportId = options ? getRuntimeInitStatusImportId(options) : hostInitImportId;
+	getRuntimeInitModule(options).writeSync(`
+${getRuntimeInitBootstrapCode(enableSsrInit, ownerImportId, ssrRemotes, hostInitImportId)}
+${exportStatement}
+`);
+}
 //#endregion
 //#region src/utils/treeShaking.ts
 const legacyTreeShakingState = {
@@ -1385,6 +2175,79 @@ function collectTreeShakingImports(code, id, shared, findSharedKey, record, mark
 	});
 }
 //#endregion
+//#region src/utils/typeArgumentScanner.ts
+function getTypeArgumentStartContext(source, start) {
+	let previous = start - 1;
+	while (previous >= 0 && /\s/.test(source[previous])) previous--;
+	const previousChar = source[previous] || "";
+	const followsNamedExpression = /[$_\u200C\u200D\p{ID_Continue})\]>]/u.test(previousChar);
+	const startsStandaloneGeneric = previousChar !== "" && "=([{,:".includes(previousChar);
+	if (!followsNamedExpression && !startsStandaloneGeneric) return void 0;
+	return { followsNamedExpression };
+}
+function updateTypeArgumentGroupDepth(char, state) {
+	if (char === "(" || char === "[" || char === "{") {
+		state.groupDepth++;
+		return "handled";
+	}
+	if (char !== ")" && char !== "]" && char !== "}") return void 0;
+	if (state.groupDepth === 0) return "invalid";
+	state.groupDepth--;
+	return "handled";
+}
+function updateTypeArgumentAngleDepth(source, index, state) {
+	const char = source[index];
+	if (char === "<") {
+		if (source[index + 1] === "=" || source[index + 1] === "<") return "invalid";
+		state.angleDepth++;
+		return "handled";
+	}
+	if (char !== ">") return void 0;
+	if (source[index - 1] === "=" || source[index + 1] === "=") return "handled";
+	state.angleDepth--;
+	return state.angleDepth === 0 ? "closed" : "handled";
+}
+function hasLikelyTypeArgumentFollower(source, end, codePositions, followsNamedExpression) {
+	let next = end + 1;
+	while (next < source.length && (!codePositions[next] || /\s/.test(source[next]))) next++;
+	if (next >= source.length || /[([.!?=;,)\]}:|&]/.test(source[next])) return true;
+	const followingToken = source.slice(next).match(/^[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}]*/u)?.[0];
+	return followingToken === "as" || followingToken === "satisfies" || !followsNamedExpression && followingToken !== void 0;
+}
+function isInvalidTypeArgumentTerminator(source, index, followsNamedExpression) {
+	const char = source[index];
+	return char === ";" || char === "=" && source[index + 1] !== ">" && followsNamedExpression;
+}
+/**
+* Finds the end of a balanced, type-like angle-bracket range that contains a
+* comma. Ambiguous syntax returns `undefined` so callers can fail closed.
+*/
+function findLikelyTypeArgumentEnd(source, start, codePositions) {
+	const context = getTypeArgumentStartContext(source, start);
+	if (!context) return void 0;
+	const state = {
+		angleDepth: 1,
+		groupDepth: 0,
+		sawTypeComma: false
+	};
+	for (let index = start + 1; index < source.length; index++) {
+		if (!codePositions[index]) continue;
+		const char = source[index];
+		const groupAction = updateTypeArgumentGroupDepth(char, state);
+		if (groupAction === "invalid") return void 0;
+		if (groupAction === "handled") continue;
+		const angleAction = updateTypeArgumentAngleDepth(source, index, state);
+		if (angleAction === "invalid") return void 0;
+		if (angleAction === "closed") return state.sawTypeComma && hasLikelyTypeArgumentFollower(source, index, codePositions, context.followsNamedExpression) ? index : void 0;
+		if (angleAction === "handled") continue;
+		if (char === "," && state.groupDepth === 0) {
+			state.sawTypeComma = true;
+			continue;
+		}
+		if (state.angleDepth === 1 && state.groupDepth === 0 && isInvalidTypeArgumentTerminator(source, index, context.followsNamedExpression)) return;
+	}
+}
+//#endregion
 //#region src/virtualModules/virtualShared_preBuild.ts
 /**
 * Even the resolveId hook cannot interfere with vite pre-build,
@@ -1436,6 +2299,12 @@ function getPackageEsmEntryPath(pkg) {
 		resolveSubpathWithRequire: false
 	}) || resolvePackageEntryFromProjectRoot(pkg);
 }
+const DEFAULT_SHARED_EXPORT_CONDITIONS = [
+	"browser",
+	"import",
+	"module",
+	"default"
+];
 function hasCodeMatch(source, regex, codePositions) {
 	regex.lastIndex = 0;
 	let match;
@@ -1443,14 +2312,25 @@ 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) {
+function inspectSharedExportsFromFile(entryPath, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
 	try {
 		if (!entryPath) return void 0;
 		const source = readFileSync(entryPath, "utf-8");
 		const scanState = { complete: true };
-		const namedExports = getNamedExportsViaRegex(source, entryPath, void 0, scanState);
+		const namedExports = getNamedExportsViaRegex(source, entryPath, void 0, scanState, exportConditions);
 		const commonJs = hasCommonJsExports(source);
 		return {
 			namedExports: scanState.complete && !commonJs ? namedExports : void 0,
@@ -1460,17 +2340,70 @@ function inspectSharedExportsFromFile(entryPath) {
 		return;
 	}
 }
-function resolveConfiguredImportPath(importSource) {
+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();
 	if (importSource.startsWith(".")) return resolveFileLikeModule(path$1.resolve(projectRoot, importSource));
 	const esmEntry = getInstalledPackageEntry(importSource, {
-		conditions: [
-			"browser",
-			"import",
-			"module",
-			"default"
-		],
+		conditions: exportConditions,
 		resolveSubpathWithRequire: false
 	});
 	if (esmEntry) return esmEntry;
@@ -1521,16 +2454,11 @@ function resolveRelativeModule(filePath, specifier) {
 		if (existsSync(candidate)) return candidate;
 	}
 }
-function resolveReExportModule(filePath, specifier) {
+function resolveReExportModule(filePath, specifier, exportConditions) {
 	if (specifier.startsWith(".")) return resolveRelativeModule(filePath, specifier);
 	const esmEntry = getInstalledPackageEntry(specifier, {
 		cwd: path$1.dirname(filePath),
-		conditions: [
-			"browser",
-			"import",
-			"module",
-			"default"
-		],
+		conditions: exportConditions,
 		resolveSubpathWithRequire: false
 	});
 	if (esmEntry) return esmEntry;
@@ -1540,7 +2468,7 @@ function resolveReExportModule(filePath, specifier) {
 		return;
 	}
 }
-function hasTopLevelDeclaratorComma(source, start) {
+function hasTopLevelDeclaratorComma(source, start, codePositions) {
 	let depth = 0;
 	let quote;
 	let escaped = false;
@@ -1623,6 +2551,14 @@ function hasTopLevelDeclaratorComma(source, start) {
 			continue;
 		}
 		if (char === "!" && source[index + 1] !== "=") continue;
+		if (char === "<") {
+			const typeArgumentEnd = findLikelyTypeArgumentEnd(source, index, codePositions);
+			if (typeArgumentEnd !== void 0) {
+				index = typeArgumentEnd;
+				canStartRegex = false;
+				continue;
+			}
+		}
 		if (char === "(" || char === "[" || char === "{") {
 			depth++;
 			canStartRegex = true;
@@ -1663,7 +2599,7 @@ function hasUnsupportedBindingPattern(source, start) {
 	}
 	return true;
 }
-function getNamedExportsViaRegex(source, filePath, visited, scanState = { complete: true }) {
+function getNamedExportsViaRegex(source, filePath, visited, scanState = { complete: true }, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
 	const names = /* @__PURE__ */ new Set();
 	const codePositions = createCodePositionMap(source);
 	const recognizedExportStarts = /* @__PURE__ */ new Set();
@@ -1680,7 +2616,7 @@ function getNamedExportsViaRegex(source, filePath, visited, scanState = { comple
 	const exportedVariableDeclarationRegex = /export\s+(?:const|let|var)\s+/g;
 	while ((match = exportedVariableDeclarationRegex.exec(source)) !== null) {
 		if (!codePositions[match.index]) continue;
-		if (hasTopLevelDeclaratorComma(source, exportedVariableDeclarationRegex.lastIndex)) scanState.complete = false;
+		if (hasTopLevelDeclaratorComma(source, exportedVariableDeclarationRegex.lastIndex, codePositions)) scanState.complete = false;
 		if (hasUnsupportedBindingPattern(source, exportedVariableDeclarationRegex.lastIndex)) scanState.complete = false;
 	}
 	if (hasCodeMatch(source, /export\s+import\s+/g, codePositions) || hasCodeMatch(source, /export\s*=/g, codePositions)) scanState.complete = false;
@@ -1709,6 +2645,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) {
@@ -1733,23 +2670,24 @@ function getNamedExportsViaRegex(source, filePath, visited, scanState = { comple
 			if (!codePositions[match.index]) continue;
 			recognizedExportStarts.add(match.index);
 			const specifier = match[1];
-			const resolvedPath = resolveReExportModule(filePath, specifier);
+			const resolvedPath = resolveReExportModule(filePath, specifier, exportConditions);
 			if (!resolvedPath) {
 				scanState.complete = false;
 				continue;
 			}
 			if (visited.has(resolvedPath)) continue;
-			if (path$1.extname(resolvedPath) === ".cjs") {
-				scanState.complete = false;
-				continue;
-			}
 			try {
 				const reExportSource = readFileSync(resolvedPath, "utf-8");
-				if (hasCommonJsExports(reExportSource)) {
-					scanState.complete = false;
+				if (path$1.extname(resolvedPath) === ".cjs" || hasCommonJsExports(reExportSource)) {
+					const requiredNames = getRequiredNamedExports(resolvedPath);
+					if (!requiredNames?.length) {
+						scanState.complete = false;
+						continue;
+					}
+					for (const name of requiredNames) names.add(name);
 					continue;
 				}
-				const reExportNames = getNamedExportsViaRegex(reExportSource, resolvedPath, visited, scanState);
+				const reExportNames = getNamedExportsViaRegex(reExportSource, resolvedPath, visited, scanState, exportConditions);
 				for (const name of reExportNames) names.add(name);
 			} catch {
 				scanState.complete = false;
@@ -1781,34 +2719,29 @@ function getRequiredNamedExports(specifier) {
 		return;
 	}
 }
-function getPackageNamedExports(pkg) {
+function getPackageNamedExports(pkg, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
 	const esmEntryPath = getInstalledPackageEntry(pkg, {
-		conditions: [
-			"browser",
-			"import",
-			"module",
-			"default"
-		],
+		conditions: exportConditions,
 		resolveSubpathWithRequire: false
 	});
 	if (esmEntryPath) {
-		const inspection = inspectSharedExportsFromFile(esmEntryPath);
+		const inspection = inspectSharedExportsFromFile(esmEntryPath, exportConditions);
 		if (!inspection || inspection.commonJs || path$1.extname(esmEntryPath) === ".cjs") return getRequiredNamedExports(esmEntryPath);
 		if (inspection.namedExports !== void 0) return inspection.namedExports;
 		return;
 	}
 	return getRequiredNamedExports(pkg);
 }
-function getSharedNamedExports(pkg, shareItem) {
+function getSharedNamedExports(pkg, shareItem, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
 	const configuredImport = shareItem?.shareConfig.import;
 	if (typeof configuredImport === "string") {
-		const configuredImportPath = resolveConfiguredImportPath(configuredImport);
-		const inspection = inspectSharedExportsFromFile(configuredImportPath);
+		const configuredImportPath = resolveConfiguredImportPath(configuredImport, exportConditions);
+		const inspection = inspectSharedExportsFromFile(configuredImportPath, exportConditions);
 		if (configuredImportPath && (inspection?.commonJs || path$1.extname(configuredImportPath) === ".cjs")) return getRequiredNamedExports(configuredImportPath);
 		if (inspection?.namedExports !== void 0) return inspection.namedExports;
 		return;
 	}
-	return getPackageNamedExports(pkg);
+	return getPackageNamedExports(pkg, exportConditions);
 }
 function getLocalProviderImportPath(pkg) {
 	try {
@@ -1928,11 +2861,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);
@@ -1980,7 +2916,7 @@ function getSharedVirtualModuleState(options) {
 			treeShakingProviderCacheMap: {},
 			materializedTreeShakingProviders: /* @__PURE__ */ new Set(),
 			loadShareCacheMap: {},
-			ownerKey: `${options.internalName}__mf_owner__${nextSharedVirtualModuleOwnerId++}`
+			ownerKey: `${options.internalName}${MF_OWNER_INFIX}${nextSharedVirtualModuleOwnerId++}`
 		};
 		sharedVirtualModuleStates.set(options, state);
 	}
@@ -2081,7 +3017,8 @@ export default { get, init };
 `, true);
 	materializedTreeShakingProviders.add(pkg);
 }
-function writePreBuildLibPath(pkg, shareItem, options) {
+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;
@@ -2131,16 +3068,21 @@ function writePreBuildLibPath(pkg, shareItem, options) {
   `, true);
 		return;
 	}
-	const namedExports = getSharedNamedExports(pkg, shareItem) ?? [];
+	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;
@@ -2185,17 +3127,23 @@ function getLoadShareModulePath(pkg, isRolldown, options) {
 	if (!loadShareCacheMap[pkg]) getLoadShareImportId(pkg, isRolldown, options);
 	return loadShareCacheMap[pkg].getImportId();
 }
-function getCachedLoadSharePkg(id) {
-	if (!id.includes("__loadShare__")) return;
+function getCachedSharedVirtualPkg(id, tag) {
+	if (!id.includes(tag)) return;
 	const normalized = normalizeVirtualModuleId(id);
 	if (!normalized.startsWith("virtual:mf:")) return;
-	const start = normalized.indexOf(LOAD_SHARE_TAG);
+	const start = normalized.indexOf(tag);
 	if (start === -1) return;
-	const encodedPkgStart = start + 13;
-	const end = normalized.indexOf(LOAD_SHARE_TAG, encodedPkgStart);
+	const encodedPkgStart = start + tag.length;
+	const end = normalized.indexOf(tag, encodedPkgStart);
 	if (end === -1) return;
 	return packageNameDecode(normalized.slice(encodedPkgStart, end));
 }
+function getCachedPreBuildPkg(id) {
+	return getCachedSharedVirtualPkg(id, PREBUILD_TAG);
+}
+function getCachedLoadSharePkg(id) {
+	return getCachedSharedVirtualPkg(id, LOAD_SHARE_TAG);
+}
 function materializeCachedLoadShareModule(options) {
 	const pkg = getCachedLoadSharePkg(options.id);
 	if (!pkg) return;
@@ -2207,14 +3155,28 @@ function materializeCachedLoadShareModule(options) {
 	options.addUsedShares(pkg);
 	options.writeLocalSharedImportMap();
 }
+function findCurrentLoadShareForStaleOwnerId(id, shared, findSharedKey, options) {
+	const pkg = getCachedLoadSharePkg(id);
+	if (!pkg) return;
+	const normalized = normalizeVirtualModuleId(id);
+	if (!normalized.startsWith("virtual:mf:")) return;
+	const encodedKey = normalized.slice(11);
+	const ownerStart = encodedKey.indexOf(MF_OWNER_INFIX);
+	if (ownerStart === -1) return;
+	if (encodedKey.slice(0, ownerStart) !== packageNameEncode(options.internalName)) return;
+	if (!findSharedKey(pkg, shared)) return;
+	return getSharedVirtualModuleState(options).loadShareCacheMap[pkg];
+}
 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) {
@@ -2231,13 +3193,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);`;
@@ -2266,7 +3230,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) {
@@ -2330,7 +3294,7 @@ const normalizeLocalShareModuleCode = `const __mfNormalizeShareModule = (mod) =>
         ? Object.assign({}, normalized)
         : normalized;
     };`;
-function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options) {
+function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exportConditions) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const { loadShareCacheMap } = getSharedVirtualModuleState(options);
 	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = createScopedSharedVirtualModule(pkg, LOAD_SHARE_TAG, options);
@@ -2340,7 +3304,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options) {
 	const runtimeInitOwnerImportId = options ? getRuntimeInitStatusImportId(options) : void 0;
 	const treeShakingConsumer = command === "build" && shareItem.shareConfig.treeShaking ? resolvedOptions.name : void 0;
 	if (shareItem.shareConfig.import === false) {
-		const detectedNamedExports = getPackageNamedExports(pkg);
+		const detectedNamedExports = getPackageNamedExports(pkg, exportConditions);
 		const namedExports = detectedNamedExports ?? [];
 		let exportLine;
 		if (namedExports.length > 0) exportLine = generateDeferredHostProvidedExports(namedExports, pkg, cacheDescriptor, treeShakingConsumer);
@@ -2364,8 +3328,12 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options) {
 	const isWorkspacePackage = isWorkspacePackageEntry(pkg, localProviderPath) || isWorkspacePackageEntry(pkg, concreteSharedImportSource);
 	const lazyLocalFallbackSource = command !== "build" ? concreteSharedImportSource || localProviderPath || devImportSource : concreteSharedImportSource || localProviderPath || sharedImportSource;
 	const skipServePrebuildWarmup = command !== "build" && (pkg === "lit" || pkg.startsWith("lit/"));
-	const detectedNamedExports = getSharedNamedExports(pkg, shareItem);
+	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";
@@ -2379,11 +3347,11 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options) {
 	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({
@@ -2397,10 +3365,10 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options) {
 		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,
@@ -2411,12 +3379,13 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options) {
     __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",
@@ -2426,7 +3395,8 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options) {
     })();
     export default __mfDefaultExport;
     ${destructure}
-    ${namedExportLine}`;
+    ${namedExportLine}
+    ${liveNamedExportLine}`;
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
       __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
 	} else if (shareItem.shareConfig.singleton === true) {
@@ -2497,11 +3467,12 @@ function getLocalOwnerKey(options) {
 		ownerId = nextLocalOwnerId++;
 		localOwnerIds.set(options, ownerId);
 	}
-	return `${options.internalName}__mf_owner__${ownerId}`;
+	return `${options.internalName}${MF_OWNER_INFIX}${ownerId}`;
 }
 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)}`;
@@ -3019,9 +3990,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) {
@@ -3987,8 +4959,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"
 		};
@@ -4093,7 +5066,7 @@ function getRemoteVirtualModule(remote, command, enableSsrInit = false, consumer
 	}
 	const cacheKey = `${remote}__${command}__${options.shareStrategy}__${consumer}__${enableSsrInit ? "ssr-init" : "no-ssr-init"}`;
 	if (!instanceCache.has(cacheKey)) {
-		const virtual = new VirtualModule(`${consumer === "unified" ? remote : `${remote}__mf_consumer__${consumer}`}__mf_owner__${getRemoteOptionsId(options)}`, LOAD_REMOTE_TAG, ".js", options.internalName);
+		const virtual = new VirtualModule(`${consumer === "unified" ? remote : `${remote}__mf_consumer__${consumer}`}${MF_OWNER_INFIX}${getRemoteOptionsId(options)}`, LOAD_REMOTE_TAG, ".js", options.internalName);
 		virtual.writeSync(generateRemotes(remote, command, enableSsrInit, consumer, options));
 		instanceCache.set(cacheKey, virtual);
 	}
@@ -4418,6 +5391,9 @@ function getFirstHtmlEntryFile(entryFiles) {
 function stripQueryAndHash$1(file) {
 	return file.split(/[?#]/)[0];
 }
+function isReactRouterClientRouteInput(file) {
+	return /[?&]__react-router-build-client-route(?:[=&]|$)/.test(file);
+}
 function resolveDevHashEntryFileName$1(fileName) {
 	if (!fileName.includes("[hash")) return fileName;
 	const normalized = fileName.replace(/(?:[._-]?\[hash(?::\d+)?\])/g, "");
@@ -4536,7 +5512,11 @@ const __mfCurrentScript = document.currentScript;
     : import(src);
 ` : "";
 		const importExpression = (src) => useSystemImportFallback ? `__mfImport(${JSON.stringify(src)})` : `import(${JSON.stringify(src)})`;
-		const remotePreloads = !options?.skipRemotePreload && (federationOptions ?? getNormalizeModuleFederationOptions())?.shareStrategy !== "loaded-first" ? Object.entries(getUsedRemotesMap(federationOptions)).flatMap(([remoteKey, remotes]) => Array.from(remotes).filter((remote) => remote !== remoteKey)).sort().map((remote) => `__mfPreloadRemote(${JSON.stringify(getRuntimeRemoteId(remote, (federationOptions ?? getNormalizeModuleFederationOptions()).remotes, federationOptions))}, ${JSON.stringify(remote)})`).join(",") : "";
+		const isEncodedVirtualEntry = entrySrc.startsWith(VITE_ENCODED_NULL_BYTE_PREFIX);
+		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 remoteCachePrefix = getRuntimeRemoteCachePrefix(federationOptions);
 		const preloadBlock = remotePreloads ? `
   const runtime = await initHost();
@@ -4568,11 +5548,12 @@ const __mfCurrentScript = document.currentScript;
   if (__mfModuleCache.pendingShareLoads) {
     await Promise.all(__mfModuleCache.pendingShareLoads);
   }
-})().then(() => ${importExpression(entrySrc)});
+})().then(() => ${entryImportExpression});
 `;
 		return [
 			getRuntimeModuleCacheBootstrapCode(),
 			importHelper,
+			entryImportDeclaration,
 			importCode
 		].join("\n");
 	}
@@ -4616,6 +5597,16 @@ const __mfCurrentScript = document.currentScript;
 			addEntryFile(scriptSrc.startsWith("/") ? path$1.resolve(viteConfig.root, scriptSrc.slice(1)) : path$1.resolve(path$1.dirname(htmlPath), scriptSrc));
 		}
 	}
+	function addEntryRemoteImports(entrySrc) {
+		if (!federationOptions || /^(?:[a-z]+:)?\/\//i.test(entrySrc)) return;
+		const file = path$1.resolve(viteConfig.root, stripQueryAndHash$1(entrySrc).replace(/^\//, ""));
+		if (!fs$2.existsSync(file)) return;
+		const code = fs$2.readFileSync(file, "utf-8");
+		for (const source of findModuleImportSources(code)) {
+			const remote = Object.keys(federationOptions.remotes).find((name) => source === name || source.startsWith(`${name}/`));
+			if (remote) addUsedRemote(remote, source, federationOptions);
+		}
+	}
 	return [{
 		name: "add-entry",
 		apply: "serve",
@@ -4643,9 +5634,10 @@ const __mfCurrentScript = document.currentScript;
 					const initSrc = params.get("init");
 					const entrySrc = params.get("entry");
 					if (initSrc && entrySrc) {
+						const withBase = (src) => viteConfig.base + src.replace(/^\//, "");
 						res.statusCode = 200;
 						res.setHeader("Content-Type", "application/javascript");
-						res.end(getBootstrapSource(initSrc, entrySrc));
+						res.end(getBootstrapSource(withBase(initSrc), withBase(entrySrc)));
 						return;
 					}
 				}
@@ -4668,10 +5660,14 @@ const __mfCurrentScript = document.currentScript;
 				const base = viteConfig.base.replace(/\/$/, "");
 				const stripBase = (p) => base && p.startsWith(base + "/") ? p.slice(base.length) : p;
 				const html = rewriteEntryScripts(c, (originalSrc) => {
-					return toViteEncodedId(`${DEV_HTML_PROXY_PREFIX}${new URLSearchParams({
+					const entrySrc = stripBase(originalSrc);
+					addEntryRemoteImports(entrySrc);
+					const resolvedEntrySrc = entrySrc.startsWith("virtual:") ? toViteEncodedId(entrySrc) : entrySrc;
+					const query = new URLSearchParams({
 						init: sanitizeDevEntryPath(stripBase(devEntryPath)),
-						entry: sanitizeDevEntryPath(stripBase(originalSrc))
-					}).toString()}`);
+						entry: sanitizeDevEntryPath(resolvedEntrySrc)
+					}).toString();
+					return toViteEncodedId(`${DEV_HTML_PROXY_PREFIX}${query}`);
 				});
 				return html === c ? injectEntryScript(c, stripBase(devEntryPath)) : html;
 			}
@@ -4710,8 +5706,8 @@ const __mfCurrentScript = document.currentScript;
 			const inputOptions = getBuildInput(config);
 			if (!inputOptions) htmlFilePath = path$1.resolve(config.root, "index.html");
 			else if (typeof inputOptions === "string") entryFiles = [resolveProjectId(inputOptions)];
-			else if (Array.isArray(inputOptions)) entryFiles = inputOptions.map(resolveProjectId);
-			else if (typeof inputOptions === "object") entryFiles = Object.values(inputOptions).map((input) => resolveProjectId(String(input)));
+			else if (Array.isArray(inputOptions)) entryFiles = inputOptions.filter((input) => !isReactRouterClientRouteInput(String(input))).map(resolveProjectId);
+			else if (typeof inputOptions === "object") entryFiles = Object.values(inputOptions).filter((input) => !isReactRouterClientRouteInput(String(input))).map((input) => resolveProjectId(String(input)));
 			if (entryFiles.length > 0) htmlFilePath = getFirstHtmlEntryFile(entryFiles);
 			if (htmlFilePath) addHtmlScriptEntries(htmlFilePath);
 		},
@@ -4898,6 +5894,7 @@ function checkAliasConflicts(options) {
 //#region src/plugins/hmr/react.ts
 const REACT_REFRESH_PATH = "/@react-refresh";
 const LOCAL_REACT_REFRESH_PATH = "/@mf-react-refresh-local";
+const HOST_REACT_REFRESH_URL = "__MF_REACT_REFRESH_URL__";
 function stripQuery(url) {
 	return url?.replace(/\?.*$/, "");
 }
@@ -4923,7 +5920,7 @@ function resolveReactRefreshRuntime(root) {
 */
 const REACT_REFRESH_PROXY_MODULE = [
 	`const __remoteUrl = new URL(import.meta.url);`,
-	`const __target = window.location.origin === __remoteUrl.origin ? new URL('.${LOCAL_REACT_REFRESH_PATH}', __remoteUrl).href : window.location.origin + '${REACT_REFRESH_PATH}';`,
+	`const __target = window.location.origin === __remoteUrl.origin ? new URL('.${LOCAL_REACT_REFRESH_PATH}', __remoteUrl).href : globalThis.${HOST_REACT_REFRESH_URL} || window.location.origin + '${REACT_REFRESH_PATH}';`,
 	`const __rt = await import(__target);`,
 	`export const injectIntoGlobalHook = __rt.injectIntoGlobalHook;`,
 	`export const register = __rt.register;`,
@@ -4936,6 +5933,14 @@ const REACT_REFRESH_PROXY_MODULE = [
 const reactAdapter = {
 	name: "react",
 	pluginNames: ["vite:react-refresh", "vite:react-swc"],
+	host: { transformIndexHtml({ server }) {
+		const refreshPath = `${server.config.base.replace(/\/$/, "")}${REACT_REFRESH_PATH}`;
+		return [{
+			tag: "script",
+			children: `globalThis.${HOST_REACT_REFRESH_URL} = new URL(${JSON.stringify(refreshPath)}, window.location.origin).href;`,
+			injectTo: "head-prepend"
+		}];
+	} },
 	remote: { configureServer({ server }) {
 		let reactRefreshRuntime;
 		server.middlewares.use((req, res, next) => {
@@ -5048,7 +6053,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 || "/";
@@ -5058,11 +6063,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}`;
 }
@@ -5368,6 +6373,203 @@ function pluginDevRemoteHmr(options) {
 	};
 }
 //#endregion
+//#region src/plugins/pluginExternalRuntimeCore.ts
+const EXTERNAL_RUNTIME_CORE_VIRTUAL_ID = "\0virtual:mf-external-runtime-core";
+/** Package remotes import — rewritten to the host global shim. */
+const RUNTIME_CORE_PACKAGE = "@module-federation/runtime-core";
+/**
+* Already depended on via `@module-federation/runtime`. Prefer this for Node
+* introspection so we do not need a direct `runtime-core` dependency.
+*/
+const RUNTIME_CORE_INTROSPECT_PACKAGE = "@module-federation/runtime/core";
+function isRuntimeCoreId(id) {
+	return id === "@module-federation/runtime-core" || id === `@module-federation/runtime-core/`;
+}
+/** True when the importer is part of an SSR remote graph (skip browser shim). */
+function isSsrRemoteRuntimeImporter(importer) {
+	if (!importer) return false;
+	return importer.includes("virtual:mf-REMOTE_ENTRY_SSR_ID") || importer.includes("virtual:mf-exposes-ssr:") || importer.includes("/__mf_ssr__/");
+}
+function collectRuntimeCoreExportShapes(runtimeCoreModule) {
+	return Object.keys(runtimeCoreModule).filter((key) => key !== "default" && key !== "__esModule").sort().map((name) => ({
+		name,
+		callable: typeof runtimeCoreModule[name] === "function"
+	}));
+}
+/**
+* Builds a shim that defers reading `globalThis._FEDERATION_RUNTIME_CORE` until
+* an export is accessed. Vite dev does not guarantee host `beforeInit` runs
+* before remote graph modules evaluate, so an eager throw at import time can
+* fail even when `provideExternalRuntime` is correctly configured.
+*/
+function buildExternalRuntimeCoreShimCode(exportShapes) {
+	return `${[
+		"function __mfGetExternalRuntimeCore() {",
+		"  const mod = globalThis._FEDERATION_RUNTIME_CORE;",
+		"  if (!mod) {",
+		"    throw new Error(\"[Module Federation] experiments.externalRuntime is enabled, but globalThis._FEDERATION_RUNTIME_CORE is missing. Enable experiments.provideExternalRuntime on the host consumer.\");",
+		"  }",
+		"  return mod;",
+		"}",
+		"function __mfCreateLazyRuntimeCoreFunction(exportName) {",
+		"  const target = function (...args) {",
+		"    return Reflect.apply(__mfGetExternalRuntimeCore()[exportName], this, args);",
+		"  };",
+		"  return new Proxy(target, {",
+		"    get(_target, prop) {",
+		"      if (prop === \"__mf_is_external_runtime_core_export\") return true;",
+		"      // Avoid thenable detection / introspection throwing before host init.",
+		"      if (prop === \"then\") return undefined;",
+		"      const value = __mfGetExternalRuntimeCore()[exportName];",
+		"      if (prop === \"prototype\") return value?.prototype;",
+		"      if (prop === Symbol.hasInstance) {",
+		"        return (instance) => instance instanceof value;",
+		"      }",
+		"      if (value == null) return value;",
+		"      const inner = Reflect.get(value, prop, value);",
+		"      return typeof inner === \"function\" ? inner.bind(value) : inner;",
+		"    },",
+		"    set(_target, prop, nextValue) {",
+		"      __mfGetExternalRuntimeCore()[exportName][prop] = nextValue;",
+		"      return true;",
+		"    },",
+		"    has(_target, prop) {",
+		"      if (prop === \"then\" || prop === \"__mf_is_external_runtime_core_export\") {",
+		"        return prop === \"__mf_is_external_runtime_core_export\";",
+		"      }",
+		"      const mod = globalThis._FEDERATION_RUNTIME_CORE;",
+		"      if (!mod) return false;",
+		"      return prop in Object(mod[exportName]);",
+		"    },",
+		"    ownKeys() {",
+		"      const mod = globalThis._FEDERATION_RUNTIME_CORE;",
+		"      if (!mod) return [];",
+		"      return Reflect.ownKeys(Object(mod[exportName]));",
+		"    },",
+		"    getOwnPropertyDescriptor(_target, prop) {",
+		"      if (prop === \"then\") return undefined;",
+		"      const mod = globalThis._FEDERATION_RUNTIME_CORE;",
+		"      if (!mod) return undefined;",
+		"      return Object.getOwnPropertyDescriptor(Object(mod[exportName]), prop);",
+		"    },",
+		"    apply(_target, thisArg, args) {",
+		"      return Reflect.apply(__mfGetExternalRuntimeCore()[exportName], thisArg, args);",
+		"    },",
+		"    construct(_target, args) {",
+		"      const Ctor = __mfGetExternalRuntimeCore()[exportName];",
+		"      return new Ctor(...args);",
+		"    },",
+		"  });",
+		"}",
+		"function __mfCreateLazyRuntimeCoreObject(exportName) {",
+		"  return new Proxy(Object.create(null), {",
+		"    get(_target, prop) {",
+		"      if (prop === \"__mf_is_external_runtime_core_export\") return true;",
+		"      if (prop === \"then\") return undefined;",
+		"      const value = __mfGetExternalRuntimeCore()[exportName];",
+		"      const inner = Reflect.get(value, prop, value);",
+		"      return typeof inner === \"function\" ? inner.bind(value) : inner;",
+		"    },",
+		"    set(_target, prop, nextValue) {",
+		"      __mfGetExternalRuntimeCore()[exportName][prop] = nextValue;",
+		"      return true;",
+		"    },",
+		"    has(_target, prop) {",
+		"      if (prop === \"then\" || prop === \"__mf_is_external_runtime_core_export\") {",
+		"        return prop === \"__mf_is_external_runtime_core_export\";",
+		"      }",
+		"      const mod = globalThis._FEDERATION_RUNTIME_CORE;",
+		"      return !!mod && prop in Object(mod[exportName]);",
+		"    },",
+		"    ownKeys() {",
+		"      const mod = globalThis._FEDERATION_RUNTIME_CORE;",
+		"      return mod ? Reflect.ownKeys(Object(mod[exportName])) : [];",
+		"    },",
+		"    getOwnPropertyDescriptor(_target, prop) {",
+		"      if (prop === \"then\") return undefined;",
+		"      const mod = globalThis._FEDERATION_RUNTIME_CORE;",
+		"      if (!mod) return undefined;",
+		"      const descriptor = Object.getOwnPropertyDescriptor(Object(mod[exportName]), prop);",
+		"      return descriptor && { ...descriptor, configurable: true };",
+		"    },",
+		"  });",
+		"}",
+		"export default /*#__PURE__*/ new Proxy(Object.create(null), {",
+		"  get(_target, prop) {",
+		"    if (prop === \"__esModule\") return true;",
+		"    if (prop === \"then\") return undefined;",
+		"    const mod = __mfGetExternalRuntimeCore();",
+		"    const resolved = mod.default ?? mod;",
+		"    const value = resolved[prop];",
+		"    return typeof value === \"function\" ? value.bind(resolved) : value;",
+		"  },",
+		"  has(_target, prop) {",
+		"    if (prop === \"then\") return false;",
+		"    if (prop === \"__esModule\") return true;",
+		"    const mod = globalThis._FEDERATION_RUNTIME_CORE;",
+		"    if (!mod) return false;",
+		"    const resolved = mod.default ?? mod;",
+		"    return prop in Object(resolved);",
+		"  },",
+		"});",
+		exportShapes.map(({ name, callable }) => `export const ${name} = /*#__PURE__*/ ${callable ? "__mfCreateLazyRuntimeCoreFunction" : "__mfCreateLazyRuntimeCoreObject"}(${JSON.stringify(name)});`).join("\n")
+	].filter(Boolean).join("\n")}\n`;
+}
+let cachedExportShapes;
+async function importRuntimeCoreForIntrospection(packageName) {
+	try {
+		return await import(pathToFileURL$1(resolveImportPath(packageName)).href);
+	} catch {
+		return await import(packageName);
+	}
+}
+async function resolveRuntimeCoreExportShapes() {
+	if (cachedExportShapes) return cachedExportShapes;
+	try {
+		cachedExportShapes = collectRuntimeCoreExportShapes(await importRuntimeCoreForIntrospection(RUNTIME_CORE_INTROSPECT_PACKAGE));
+	} catch {
+		try {
+			cachedExportShapes = collectRuntimeCoreExportShapes(await importRuntimeCoreForIntrospection(RUNTIME_CORE_PACKAGE));
+		} catch {
+			cachedExportShapes = [];
+		}
+	}
+	return cachedExportShapes;
+}
+/**
+* Replaces `@module-federation/runtime-core` with a virtual module that reads
+* `globalThis._FEDERATION_RUNTIME_CORE` (webpack/Rspack `externalRuntime` parity).
+*/
+function pluginExternalRuntimeCore() {
+	let shimCodePromise;
+	const getShimCode = () => {
+		if (!shimCodePromise) shimCodePromise = resolveRuntimeCoreExportShapes().then((shapes) => {
+			if (shapes.length === 0) throw createModuleFederationError(`Unable to introspect exports from ${RUNTIME_CORE_INTROSPECT_PACKAGE} for experiments.externalRuntime.`);
+			return buildExternalRuntimeCoreShimCode(shapes);
+		});
+		return shimCodePromise;
+	};
+	return {
+		name: "module-federation-external-runtime-core",
+		enforce: "pre",
+		config(config) {
+			config.optimizeDeps ??= {};
+			config.optimizeDeps.exclude ??= [];
+			if (!config.optimizeDeps.exclude.includes("@module-federation/runtime-core")) config.optimizeDeps.exclude.push(RUNTIME_CORE_PACKAGE);
+			if (Array.isArray(config.optimizeDeps.include)) config.optimizeDeps.include = config.optimizeDeps.include.filter((dep) => dep !== "@module-federation/runtime-core" && !String(dep).startsWith(`@module-federation/runtime-core/`));
+		},
+		resolveId(source, importer) {
+			if (!isRuntimeCoreId(source)) return;
+			if (isSsrRemoteRuntimeImporter(importer)) return;
+			return EXTERNAL_RUNTIME_CORE_VIRTUAL_ID;
+		},
+		async load(id) {
+			if (id !== "\0virtual:mf-external-runtime-core") return;
+			return getShimCode();
+		}
+	};
+}
+//#endregion
 //#region src/virtualModules/index.ts
 function initVirtualModules(command, remoteEntryId, enableSsrInit = false, options) {
 	writeLocalSharedImportMap(options);
@@ -5761,7 +6963,7 @@ function getVirtualExposesSSRId(options) {
 *   build so Node resolves them via its own module cache — this is what
 *   guarantees the React singleton is shared with react-dom/server.
 */
-function generateExposesSSR(options) {
+function generateExposesSSR(options, reactIslandExposes = /* @__PURE__ */ new Set()) {
 	return `
     export default {
     ${Object.keys(options.exposes).map((key) => {
@@ -5770,6 +6972,7 @@ function generateExposesSSR(options) {
           const importModule = await import(${JSON.stringify(options.exposes[key].import)})
           const exportModule = {}
           Object.assign(exportModule, importModule)
+          ${generateReactIslandSSRDefinition(reactIslandExposes.has(key))}
           Object.defineProperty(exportModule, "__esModule", {
             value: true,
             enumerable: false
@@ -5785,7 +6988,8 @@ function generateExposesSSR(options) {
 //#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";
@@ -5863,6 +7067,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.
@@ -5965,9 +7481,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);
@@ -6025,6 +7552,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 = {};
@@ -6039,6 +7571,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;
@@ -6354,12 +7891,16 @@ function resolveDevHashEntryFileName(fileName) {
 	return path$1.extname(baseName) ? normalized : `${normalized}.js`;
 }
 function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposesId }) {
-	let viteConfig, _command, root;
+	let viteConfig, _command, root, originalConfigBase;
 	let exposeRemoteDependencies = {};
 	let exposeRemoteDependenciesDirty = true;
 	let refreshPromise;
 	let dependencyInvalidationVersion = 0;
-	const isHostAutoInitId = (id) => id.includes(getHostAutoInitPath(options)) || id.includes(getHostAutoInitPath());
+	let reactIslandExposes = /* @__PURE__ */ new Set();
+	const isHostAutoInitId = (id) => {
+		const cleanId = id.split("?")[0];
+		return cleanId.includes(getHostAutoInitPath(options)) || cleanId.includes(getHostAutoInitPath());
+	};
 	function isRemoteImport(source) {
 		return Object.keys(options.remotes).some((name) => source === name || source.startsWith(name + "/"));
 	}
@@ -6425,9 +7966,11 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		configResolved(config) {
 			viteConfig = config;
 			root = config.root;
+			reactIslandExposes = getReactIslandExposes(options, root);
 		},
-		config(_config, { command }) {
+		config(config, { command }) {
 			_command = command;
+			originalConfigBase = config.base;
 		},
 		async buildStart() {
 			await refreshExposeRemoteDependencies(this);
@@ -6460,7 +8003,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 			if (id === remoteEntryId) return parsePromise.then((_) => generateRemoteEntry(options, virtualExposesId, _command));
 			if (id === virtualExposesId) {
 				await refreshExposeRemoteDependencies(this);
-				return generateExposes(options, exposeRemoteDependencies, _command);
+				return generateExposes(options, exposeRemoteDependencies, _command, reactIslandExposes);
 			}
 			if (_command === "serve" && isHostAutoInitId(id)) return id;
 		},
@@ -6470,12 +8013,12 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 				if (id.includes(remoteEntryId)) return parsePromise.then((_) => generateRemoteEntry(options, virtualExposesId, _command));
 				if (id === virtualExposesId) {
 					await refreshExposeRemoteDependencies(this);
-					return generateExposes(options, exposeRemoteDependencies, _command);
+					return generateExposes(options, exposeRemoteDependencies, _command, reactIslandExposes);
 				}
 				if (isHostAutoInitId(id)) {
 					if (_command === "serve") {
 						const host = typeof viteConfig.server?.host === "string" && viteConfig.server.host !== "0.0.0.0" ? viteConfig.server.host : "localhost";
-						const resolvedPublicPath = resolvePublicPath(options, viteConfig.base);
+						const resolvedPublicPath = resolvePublicPath(options, viteConfig.base, originalConfigBase);
 						const publicPath = JSON.stringify((resolvedPublicPath === "auto" ? "/" : resolvedPublicPath) + resolveDevHashEntryFileName(options.filename));
 						const fallbackOrigin = `//${host}:${viteConfig.server?.port}`;
 						const ssrRemoteEntry = "data:text/javascript," + encodeURIComponent("export async function init(){return {loadRemote:async()=>({}),loadShare:async()=>({})}}");
@@ -6603,11 +8146,23 @@ 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);
 		}
 	};
 }
@@ -6811,7 +8366,7 @@ function proxySharedModule(options) {
 			load(id) {
 				if (id === getResolvedLocalSharedImportMapId(federationOptions)) return parsePromise.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);
@@ -7243,14 +8798,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"
@@ -7388,11 +8943,12 @@ 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;
 	let isNuxtProject = false;
+	let reactIslandExposes = /* @__PURE__ */ new Set();
 	const findNuxtExposesChunk = (bundle) => {
 		const exposeKeys = Object.keys(options.exposes);
 		if (exposeKeys.length === 0) return;
@@ -7436,10 +8992,11 @@ function pluginSSRRemoteEntry(options) {
 		configResolved(config) {
 			viteConfig = config;
 			isNuxtProject = isNuxtProjectRoot(config.root);
+			reactIslandExposes = getReactIslandExposes(options, config.root);
 		},
 		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}`;
@@ -7503,7 +9060,7 @@ function pluginSSRRemoteEntry(options) {
 			server.middlewares.use(exposesPath, (_req, res) => {
 				res.setHeader("Content-Type", "application/javascript");
 				res.setHeader("Access-Control-Allow-Origin", "*");
-				res.end(generateExposesSSR(options));
+				res.end(generateExposesSSR(options, reactIslandExposes));
 			});
 		},
 		resolveId(id) {
@@ -7514,7 +9071,7 @@ function pluginSSRRemoteEntry(options) {
 		},
 		load(id) {
 			if (id === remoteEntrySSRId || id.startsWith(remoteEntrySSRId)) return generateRemoteEntrySSR(options);
-			if (id === virtualExposesSSRId || id.startsWith(virtualExposesSSRId)) return generateExposesSSR(options);
+			if (id === virtualExposesSSRId || id.startsWith(virtualExposesSSRId)) return generateExposesSSR(options, reactIslandExposes);
 		},
 		buildStart() {
 			if (isServe) return;
@@ -7583,7 +9140,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 || [],
@@ -7612,9 +9169,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) {
@@ -7631,12 +9199,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).`);
@@ -7766,6 +9344,42 @@ function isTestEnv() {
 	return process.env.NODE_ENV === "test" || process.env.VITEST != null || process.env.JEST_WORKER_ID != null;
 }
 //#endregion
+//#region src/utils/sharedExportConditions.ts
+const DEFAULT_CLIENT_EXPORT_CONDITIONS = [
+	"browser",
+	"import",
+	"module",
+	"default"
+];
+const DEFAULT_NODE_SSR_EXPORT_CONDITIONS = [
+	"node",
+	"import",
+	"module",
+	"default"
+];
+const DEFAULT_WEBWORKER_SSR_EXPORT_CONDITIONS = [
+	"worker",
+	"browser",
+	"import",
+	"module",
+	"default"
+];
+const VITE_DEV_PROD_CONDITION = "development|production";
+function appendConditions(conditions, fallbackConditions) {
+	return [.../* @__PURE__ */ new Set([...conditions, ...fallbackConditions])];
+}
+function resolveViteModeCondition(conditions, isProduction) {
+	const modeCondition = isProduction ? "production" : "development";
+	return [...new Set(conditions.map((condition) => condition === VITE_DEV_PROD_CONDITION ? modeCondition : condition))];
+}
+function getSharedExportConditions({ environmentConditions, isProduction, isSsr, rootConditions, ssrConditions, ssrTarget = "node" }) {
+	if (environmentConditions !== void 0) return resolveViteModeCondition(appendConditions(environmentConditions, ["import", "default"]), isProduction);
+	const defaultConditions = isSsr ? ssrTarget === "webworker" ? DEFAULT_WEBWORKER_SSR_EXPORT_CONDITIONS : DEFAULT_NODE_SSR_EXPORT_CONDITIONS : DEFAULT_CLIENT_EXPORT_CONDITIONS;
+	const configuredConditions = isSsr ? ssrConditions ?? rootConditions : rootConditions;
+	if (configuredConditions !== void 0) return resolveViteModeCondition(appendConditions(configuredConditions, defaultConditions), isProduction);
+	return [...defaultConditions];
+}
+//#endregion
 //#region src/utils/normalizeOptimizeDeps.ts
 var normalizeOptimizeDeps_default = {
 	name: "normalizeOptimizeDeps",
@@ -7857,6 +9471,9 @@ function isSharedResolverInternalImporter(importer) {
 function isCommonJsImporter(importer) {
 	return !!importer && (importer.endsWith(".cjs") || importer.includes("/cjs/"));
 }
+function isReactDomSelfReference(source, importer) {
+	return source === "react-dom" && getPackageNameFromNodeModulePath(importer ?? "") === "react-dom";
+}
 function isOutputChunk(chunk) {
 	return chunk.type === "chunk";
 }
@@ -7911,10 +9528,57 @@ function isFederationHtmlPreloadDependency(dep, includeSharedRuntime = false) {
 function canResolveSharedSubpath(subpath, projectRoot) {
 	try {
 		return isViteOptimizableEntry(createRequire$1(pathToFileURL(path$1.join(projectRoot, "package.json"))).resolve(subpath));
-	} catch {
+	} catch (error) {
+		if (error?.code === "ERR_PACKAGE_PATH_NOT_EXPORTED" && !isBarePackageSubpath(subpath)) {
+			const entry = resolveViteImportPackageEntry(subpath, projectRoot);
+			return entry !== void 0 && existsSync(entry) && isViteOptimizableEntry(entry);
+		}
 		return false;
 	}
 }
+const VITE_DEV_IMPORT_CONDITIONS = /* @__PURE__ */ new Set([
+	"browser",
+	"development",
+	"import",
+	"module",
+	"default"
+]);
+function resolveConditionalExportTarget(target) {
+	if (typeof target === "string") return target;
+	if (Array.isArray(target)) {
+		for (const candidate of target) {
+			const resolved = resolveConditionalExportTarget(candidate);
+			if (resolved) return resolved;
+		}
+		return;
+	}
+	if (!target || typeof target !== "object") return void 0;
+	for (const [condition, candidate] of Object.entries(target)) {
+		if (!VITE_DEV_IMPORT_CONDITIONS.has(condition)) continue;
+		const resolved = resolveConditionalExportTarget(candidate);
+		if (resolved) return resolved;
+	}
+}
+function resolveViteImportPackageEntry(packageName, projectRoot) {
+	const installed = getInstalledPackageJson(packageName, { cwd: projectRoot });
+	if (!installed) return void 0;
+	const exportsField = installed.packageJson.exports;
+	let rootExport = exportsField;
+	if (exportsField && typeof exportsField === "object" && !Array.isArray(exportsField)) {
+		const exportsRecord = exportsField;
+		if (Object.keys(exportsRecord).some((key) => key.startsWith("."))) rootExport = exportsRecord["."];
+	}
+	const target = resolveConditionalExportTarget(rootExport);
+	if (!target?.startsWith("./")) return void 0;
+	const resolved = path$1.resolve(installed.dir, target);
+	const relative = path$1.relative(installed.dir, resolved);
+	if (relative.startsWith(`..${path$1.sep}`) || path$1.isAbsolute(relative)) return void 0;
+	return resolved;
+}
+function isBarePackageSubpath(specifier) {
+	const segments = specifier.split("/");
+	return specifier.startsWith("@") ? segments.length > 2 : segments.length > 1;
+}
 /**
 * Vite's dependency scanner cannot see through the virtual loadShare modules
 * generated for shared packages. As a result, dependencies of a linked/shared
@@ -7990,8 +9654,10 @@ function createEarlyVirtualModulesPlugin(options) {
 						optimizeDeps.rolldownOptions.plugins.push({
 							name: "module-federation:optimize-shared-resolver",
 							load(id) {
-								if (id !== "module-federation:optimized-require-react") return;
-								const loadSharePath = getLoadShareModulePath("react", isRolldown, options);
+								if (!id.startsWith("module-federation:optimized-require-")) return;
+								const sourcePackage = id.slice(36);
+								if (sourcePackage !== "react" && sourcePackage !== "react-dom") return;
+								const loadSharePath = getLoadShareModulePath(sourcePackage, isRolldown, options);
 								const source = JSON.stringify(loadSharePath);
 								return "import * as __mfShared from " + source + ";\nexport * from " + source + ";\nexport default __mfShared.default ?? __mfShared;";
 							},
@@ -8007,13 +9673,14 @@ function createEarlyVirtualModulesPlugin(options) {
 								const shareItem = shared[key];
 								const isReactSingleton = source === "react" && key === "react" && shareItem.shareConfig?.singleton === true;
 								const isReactRequire = resolveOptions?.kind?.startsWith("require") && isReactSingleton;
-								if (resolveOptions?.kind?.startsWith("require") && !isReactSingleton) return;
-								if (isCommonJsImporter(importer) && !isReactSingleton) return;
-								if (isReactRequire) {
+								const isReactDomRequire = resolveOptions?.kind?.startsWith("require") && isReactDomSelfReference(source, importer);
+								if (resolveOptions?.kind?.startsWith("require") && !isReactRequire && !isReactDomRequire) return;
+								if (isCommonJsImporter(importer) && !isReactSingleton && !isReactDomRequire) return;
+								if (isReactRequire || isReactDomRequire) {
 									writeLoadShareModule(source, shareItem, _command, isRolldown, options);
 									if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(source, shareItem, options);
 									addUsedShares(source, options);
-									return { id: "module-federation:optimized-require-react" };
+									return { id: `module-federation:optimized-require-${source}` };
 								}
 								const loadSharePath = getLoadShareModulePath(source, isRolldown, options);
 								writeLoadShareModule(source, shareItem, _command, isRolldown, options);
@@ -8040,7 +9707,7 @@ function createEarlyVirtualModulesPlugin(options) {
 									if (!args.importer || args.namespace === "mf-shared") return;
 									if (isSharedResolverInternalImporter(args.importer)) return;
 									if (!findSharedKey(args.path, shared) || isAssetLikeImport(args.path)) return;
-									if (getPackageNameFromNodeModulePath(args.importer) === getPackageName(args.path)) return;
+									if (getPackageNameFromNodeModulePath(args.importer) === getPackageName(args.path) && !isReactDomSelfReference(args.path, args.importer)) return;
 									return {
 										path: args.path,
 										namespace: "mf-shared"
@@ -8110,8 +9777,10 @@ export default __mfShared.default ?? __mfShared;`
 							writeLoadShareModule(subpath, shareItem, _command, isRolldown, options);
 							writePreBuildLibPath(subpath, shareItem, options);
 							addUsedShares(subpath, options);
-							if (canResolveSubpath) optimizeDeps.include.push(subpath);
-							else optimizeDeps.exclude.push(subpath);
+							if (canResolveSubpath) {
+								optimizeDeps.include.push(subpath);
+								if (key === "react-dom") optimizeDeps.include.push(`${key} > ${subpath}`);
+							} else optimizeDeps.exclude.push(subpath);
 						}
 					}
 				}
@@ -8157,7 +9826,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;
@@ -8169,11 +9838,39 @@ function applyBuildTimeRuntimeDefines(define, options, { target, isAstro, defaul
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-9RTNVO8v.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) {
+	return specifier === INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN || specifier.includes("injectExternalRuntimeCorePlugin") || specifier.includes("inject-external-runtime-core-plugin");
+}
+function hasInjectExternalRuntimeCorePlugin(runtimePlugins) {
+	return runtimePlugins.some((plugin) => {
+		return isInjectExternalRuntimeCorePlugin(typeof plugin === "string" ? plugin : plugin[0]);
+	});
+}
+function resolveInjectExternalRuntimeCorePlugin() {
+	try {
+		return normalizePathForImport(resolveImportPath(INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN));
+	} catch {
+		for (const rel of ["./utils/injectExternalRuntimeCorePlugin.js", "./utils/injectExternalRuntimeCorePlugin.ts"]) {
+			const candidate = fileURLToPath(new URL(rel, import.meta.url));
+			if (existsSync(candidate)) return normalizePathForImport(candidate);
+		}
+		return INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN;
+	}
+}
+function applyExternalRuntimeExperiments(options) {
+	const { experiments } = options;
+	if (experiments.provideExternalRuntime) {
+		if (Object.keys(options.exposes).length > 0) throw createModuleFederationError("You can only set provideExternalRuntime: true in pure consumer which not expose modules.");
+		if (!hasInjectExternalRuntimeCorePlugin(options.runtimePlugins)) options.runtimePlugins = options.runtimePlugins.concat(resolveInjectExternalRuntimeCorePlugin());
+	}
 }
 function federation(mfUserOptions) {
 	if (isTestEnv()) return [];
 	const options = normalizeModuleFederationOptions(mfUserOptions);
+	applyExternalRuntimeExperiments(options);
 	const isVinext = hasPackageDependency("vinext");
 	const { name, shared, filename, hostInitInjectLocation } = options;
 	const hasTreeShakingShared = Object.values(shared).some((share) => !!share.shareConfig.treeShaking);
@@ -8183,7 +9880,45 @@ function federation(mfUserOptions) {
 	let command;
 	let desiredRolldownOutput;
 	let isSsrBuild = false;
+	let isProduction = false;
+	let rootResolveConditions;
+	let ssrResolveConditions;
+	let ssrTarget = "node";
 	const emittedRuntimeCapabilityWarnings = /* @__PURE__ */ new Set();
+	const getLoadHookExportConditions = (context, loadOptions) => {
+		const environment = context.environment;
+		const isSsr = loadOptions?.ssr === true || isSsrBuild || environment?.config?.consumer === "server" || Boolean(environment?.config?.build?.ssr) || environment?.name === "ssr" || environment?.name === "server";
+		return getSharedExportConditions({
+			environmentConditions: environment?.config?.resolve?.conditions,
+			isProduction: environment?.config?.isProduction ?? isProduction,
+			isSsr,
+			rootConditions: rootResolveConditions,
+			ssrConditions: ssrResolveConditions,
+			ssrTarget
+		});
+	};
+	const refreshPreBuildModuleForEnvironment = (id, context, loadOptions) => {
+		const pkg = getCachedPreBuildPkg(id);
+		if (!pkg) return "not-applicable";
+		const key = findSharedKey(pkg, shared);
+		if (!key) return "not-applicable";
+		const requestedModule = VirtualModule.findById(id);
+		const ownedModule = VirtualModule.findById(getPreBuildLibImportId(pkg, options));
+		if (!requestedModule || requestedModule !== ownedModule) return "not-owned";
+		writePreBuildLibPath(pkg, shared[key], options, getLoadHookExportConditions(context, loadOptions));
+		return "refreshed";
+	};
+	const refreshLoadShareModuleForEnvironment = (id, context, loadOptions) => {
+		const pkg = getCachedLoadSharePkg(id);
+		if (!pkg) return "not-applicable";
+		const key = findSharedKey(pkg, shared);
+		if (!key) return "not-applicable";
+		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));
+		return "refreshed";
+	};
 	return [
 		{
 			name: "vite:module-federation-virtual-modules",
@@ -8201,18 +9936,21 @@ function federation(mfUserOptions) {
 						writeLocalSharedImportMap: () => writeLocalSharedImportMap(options),
 						federationOptions: options
 					});
-					virtualModule = VirtualModule.findById(id);
+					virtualModule = VirtualModule.findById(id) ?? findCurrentLoadShareForStaleOwnerId(id, options.shared, findSharedKey, options);
 				}
 				if (!virtualModule) return;
 				return virtualModule.getResolvedId();
 			},
-			load(id) {
+			load(id, loadOptions) {
+				if (command !== "build" && id.includes("__loadShare__") && refreshLoadShareModuleForEnvironment(id, this, loadOptions) === "not-owned") return;
+				if (id.includes("__prebuild__") && refreshPreBuildModuleForEnvironment(id, this, loadOptions) === "not-owned") return;
 				const virtualModule = VirtualModule.findById(id);
 				if (!virtualModule) return;
 				if (command === "build" && (id.includes("__loadShare__") || id.includes("__loadRemote__"))) return;
 				return virtualModule.code;
 			}
 		},
+		...options.experiments.externalRuntime ? [pluginExternalRuntimeCore()] : [],
 		createEarlyVirtualModulesPlugin(options),
 		...isVinext ? [{
 			name: "module-federation-vinext-react-server-build-alias",
@@ -8238,7 +9976,11 @@ function federation(mfUserOptions) {
 			config(_config, env) {
 				command = env.command;
 			},
-			configResolved() {
+			configResolved(config) {
+				rootResolveConditions = config.resolve?.conditions ? [...config.resolve.conditions] : void 0;
+				ssrResolveConditions = config.ssr?.resolve?.conditions ? [...config.ssr.resolve.conditions] : void 0;
+				ssrTarget = config.ssr?.target ?? "node";
+				isProduction = config.isProduction;
 				const ssrCapabilities = getSsrCapabilities(parseInt(version, 10), command, Object.keys(options.remotes).length > 0);
 				initVirtualModules(command, remoteEntryId, ssrCapabilities.enableSsrInitBootstrap, options);
 			}
@@ -8302,7 +10044,7 @@ function federation(mfUserOptions) {
 			enforce: "pre",
 			apply: "build",
 			config(config) {
-				isSsrBuild = config.build?.ssr === true;
+				isSsrBuild = Boolean(config.build?.ssr);
 				const runtimeInitId = getRuntimeInitStatusImportId(options);
 				config.build = config.build || {};
 				if (config.build.modulePreload !== false) {
@@ -8422,8 +10164,9 @@ function federation(mfUserOptions) {
 					};
 				}
 			},
-			load(id) {
+			load(id, loadOptions) {
 				if (id.includes("__loadShare__") || id.includes("__loadRemote__")) {
+					if (id.includes("__loadShare__") && refreshLoadShareModuleForEnvironment(id, this, loadOptions) === "not-owned") return;
 					const virtualModule = VirtualModule.findById(id);
 					if (!virtualModule?.code) return null;
 					let code = virtualModule.code;
@@ -8490,7 +10233,7 @@ function federation(mfUserOptions) {
 			_options: options,
 			config(config, { command: _command }) {
 				const isRolldown = getIsRolldown(this);
-				isSsrBuild = _command === "build" && config.build?.ssr === true;
+				isSsrBuild = _command === "build" && Boolean(config.build?.ssr);
 				const needsRuntimeHelpers = Object.keys(options.shared ?? {}).length > 0;
 				if (needsRuntimeHelpers) appendResolveAlias(config, {
 					find: /^@module-federation\/runtime\/helpers$/,
@@ -8575,7 +10318,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();
 				});