@module-federation/vite 1.20.0 → 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-Dbbi4cnh.js";
 import { createRequire } from "node:module";
 import * as fs$2 from "fs";
-import { existsSync, readFileSync, realpathSync, statSync, writeFileSync } from "fs";
+import fs, { existsSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "fs";
 import { createRequire as createRequire$1 } from "module";
 import * as path$1 from "node:path";
 import path, { basename } from "node:path";
@@ -11,9 +10,71 @@ import { createHash } from "node:crypto";
 import * as fs$1 from "node:fs";
 import { existsSync as existsSync$1, readFileSync as readFileSync$1 } from "node:fs";
 import { pathToFileURL as pathToFileURL$1 } from "node:url";
+import { normalizeOptions } from "@module-federation/sdk";
+import { consumeTypesAPI, generateTypesAPI, isTSProject, normalizeConsumeTypesOptions, normalizeDtsOptions, normalizeGenerateTypesOptions } from "@module-federation/dts-plugin";
+import { rpc } from "@module-federation/dts-plugin/core";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/utils/buildPaths.ts
+/**
+* Rebase an import path for a bootstrap file that moved from root into `dir`.
+*
+* When entryFileNames places entries in a subdirectory (e.g. `static/js/`),
+* the bootstrap file moves there too. Paths that resolved from the HTML root
+* must resolve from the new directory instead.
+*
+* Cases: `/static/js/hostInit.js` → `./hostInit.js` (strip dir prefix)
+*        `./src/main.tsx`          → `../../src/main.tsx` (climb back up for each dir level)
+*        `https://cdn.example.com` → unchanged         (absolute URL)
+*/
+function rebaseImport(importSrc, dir) {
+	if (!dir) return importSrc;
+	if (isAbsoluteUrl(importSrc)) return importSrc;
+	const normalizedDir = dir.replace(/^\/+|\/+$/g, "");
+	if (!normalizedDir) return importSrc;
+	const stripDirPrefix = (src, prefix) => {
+		if (src === prefix) return "";
+		if (src.startsWith(prefix + "/")) return src.slice(prefix.length);
+	};
+	const absoluteRemainder = stripDirPrefix(importSrc, "/" + normalizedDir);
+	if (absoluteRemainder !== void 0) {
+		const remainder = absoluteRemainder.replace(/^\/+/, "");
+		return remainder ? "./" + remainder : "./";
+	}
+	const relativeRemainder = stripDirPrefix(importSrc, normalizedDir);
+	if (relativeRemainder !== void 0) {
+		const remainder = relativeRemainder.replace(/^\/+/, "");
+		return remainder ? "./" + remainder : "./";
+	}
+	const upLevels = normalizedDir.split("/").filter(Boolean).length;
+	const prefix = upLevels > 0 ? "../".repeat(upLevels) : "./";
+	if (importSrc.startsWith("./")) return prefix + importSrc.slice(2);
+	if (importSrc.startsWith("/")) return prefix + importSrc.slice(1);
+	return prefix + importSrc;
+}
+function normalizePathForImport(path) {
+	return path.replace(/\\/g, "/");
+}
+const EXTERNAL_URL_RE = /^(?:[a-z]+:|\/\/)/i;
+function isAbsoluteUrl(src) {
+	if (/^[a-z]:[\\/]/i.test(src)) return false;
+	return EXTERNAL_URL_RE.test(src);
+}
+//#endregion
 //#region src/utils/codeRewriter.ts
 const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var CodeRewriter = class {
+	original;
 	replacements = [];
 	constructor(original) {
 		this.original = original;
@@ -149,7 +210,7 @@ async function mapCodeToCodeWithSourcemap(code) {
 }
 //#endregion
 //#region src/utils/codePositionMap.ts
-const REGEX_PREFIX_KEYWORDS = new Set([
+const REGEX_PREFIX_KEYWORDS = /* @__PURE__ */ new Set([
 	"await",
 	"case",
 	"delete",
@@ -321,6 +382,475 @@ function injectEntryScript(html, initSrc) {
 	return html.replace("<head>", `<head><script type="module" src=${JSON.stringify(src)}><\/script>`);
 }
 //#endregion
+//#region src/utils/logger.ts
+const MODULE_FEDERATION_LOG_PREFIX = "[Module Federation]";
+function formatModuleFederationMessage(message) {
+	return `${MODULE_FEDERATION_LOG_PREFIX} ${message}`;
+}
+function createModuleFederationError(message) {
+	return new Error(formatModuleFederationMessage(message));
+}
+function toConsoleArgs(message, rest = []) {
+	if (typeof message === "string") return [formatModuleFederationMessage(message), ...rest];
+	if (message === void 0) return [MODULE_FEDERATION_LOG_PREFIX, ...rest];
+	return [
+		MODULE_FEDERATION_LOG_PREFIX,
+		message,
+		...rest
+	];
+}
+const moduleFederationConsole = {
+	log(message, ...rest) {
+		console.log(...toConsoleArgs(message, rest));
+	},
+	warn(message, ...rest) {
+		console.warn(...toConsoleArgs(message, rest));
+	},
+	error(message, ...rest) {
+		console.error(...toConsoleArgs(message, rest));
+	}
+};
+moduleFederationConsole.log;
+const mfWarn = moduleFederationConsole.warn;
+const mfError = moduleFederationConsole.error;
+//#endregion
+//#region src/utils/packageUtils.ts
+const dependencyPresenceCache = /* @__PURE__ */ new Map();
+let packageDetectionCwd;
+function getDependencyCacheKey(cwd, dependencyName) {
+	return `${cwd}:${dependencyName}`;
+}
+const installedPackageJsonCache = /* @__PURE__ */ new Map();
+function setPackageDetectionCwd(cwd) {
+	packageDetectionCwd = cwd;
+}
+function getPackageDetectionCwd() {
+	return packageDetectionCwd || process.cwd();
+}
+function resolveImportPath(specifier) {
+	const resolved = import.meta.resolve(specifier);
+	if (!resolved.startsWith("file:")) return resolved;
+	const filePath = fileURLToPath(resolved);
+	if (!existsSync(filePath)) {
+		const error = /* @__PURE__ */ new Error(`Cannot find module '${specifier}'`);
+		error.code = "MODULE_NOT_FOUND";
+		throw error;
+	}
+	return filePath;
+}
+const DEFAULT_EXPORT_CONDITIONS = [
+	"browser",
+	"import",
+	"module",
+	"default"
+];
+function resolveExportsEntry(exportsField, conditions = DEFAULT_EXPORT_CONDITIONS) {
+	return resolveExportsEntryWithConditions(exportsField, new Set(conditions));
+}
+function resolveExportsEntryWithConditions(exportsField, conditions) {
+	if (typeof exportsField === "string") return exportsField;
+	if (!exportsField || typeof exportsField !== "object") return void 0;
+	if (Array.isArray(exportsField)) {
+		for (const target of exportsField) {
+			const resolved = resolveExportsEntryWithConditions(target, conditions);
+			if (resolved) return resolved;
+		}
+		return;
+	}
+	const record = exportsField;
+	const rootExport = record["."];
+	if (rootExport) return resolveExportsEntryWithConditions(rootExport, conditions);
+	for (const [condition, value] of Object.entries(record)) {
+		if (condition !== "default" && !conditions.has(condition)) continue;
+		const target = resolveExportsEntryWithConditions(value, conditions);
+		if (target) return target;
+	}
+}
+function substituteExportsWildcard(target, patternMatch) {
+	if (typeof target === "string") return target.split("*").join(patternMatch);
+	if (Array.isArray(target)) return target.map((entry) => substituteExportsWildcard(entry, patternMatch));
+	if (target && typeof target === "object") {
+		const source = target;
+		const out = {};
+		for (const key of Object.keys(source)) out[key] = substituteExportsWildcard(source[key], patternMatch);
+		return out;
+	}
+	return target;
+}
+function matchExportsSubpath(record, subpath) {
+	if (subpath in record) return record[subpath];
+	let bestKey;
+	let bestBaseLength = -1;
+	let bestKeyLength = -1;
+	for (const key of Object.keys(record)) {
+		const wildcardIndex = key.indexOf("*");
+		if (wildcardIndex === -1) continue;
+		const patternBase = key.slice(0, wildcardIndex);
+		const patternTrailer = key.slice(wildcardIndex + 1);
+		if (patternTrailer.includes("*")) continue;
+		if (!subpath.startsWith(patternBase) || !subpath.endsWith(patternTrailer)) continue;
+		if (subpath.length <= patternBase.length + patternTrailer.length) continue;
+		if (patternBase.length > bestBaseLength || patternBase.length === bestBaseLength && key.length > bestKeyLength) {
+			bestKey = key;
+			bestBaseLength = patternBase.length;
+			bestKeyLength = key.length;
+		}
+	}
+	if (bestKey === void 0) return void 0;
+	const patternTrailer = bestKey.slice(bestKey.indexOf("*") + 1);
+	const patternMatch = subpath.slice(bestBaseLength, subpath.length - patternTrailer.length);
+	return substituteExportsWildcard(record[bestKey], patternMatch);
+}
+function getPackageExportsTarget(pkg, packageName, exportsField) {
+	if (typeof exportsField === "string") return pkg === packageName ? exportsField : void 0;
+	if (!exportsField || typeof exportsField !== "object") return void 0;
+	const record = exportsField;
+	const subpath = pkg === packageName ? "." : `.${pkg.slice(packageName.length)}`;
+	if (subpath !== ".") return matchExportsSubpath(record, subpath);
+	return record["."] ?? (!Object.keys(record).some((key) => key.startsWith(".")) ? record : void 0);
+}
+/**
+* Escaping rules:
+* Convert using the format __${mapping}__, where _ and $ are not allowed in npm package names but can be used in variable names.
+*  @ => 1
+*  / => 2
+*  - => 3
+*  . => 4
+*/
+/**
+* Encodes a package name into a valid file name.
+* @param {string} name - The package name, e.g., "@scope/xx-xx.xx".
+* @returns {string} - The encoded file name.
+*/
+function packageNameEncode(name) {
+	if (typeof name !== "string") throw createModuleFederationError("A string package name is required");
+	return name.replace(/@/g, "_mf_0_").replace(/\//g, "_mf_1_").replace(/-/g, "_mf_2_").replace(/\./g, "_mf_3_");
+}
+/**
+* Decodes an encoded file name back to the original package name.
+* @param {string} encoded - The encoded file name, e.g., "_mf_0_scope_mf_1_xx_mf_2_xx_mf_3_xx".
+* @returns {string} - The decoded package name.
+*/
+function packageNameDecode(encoded) {
+	if (typeof encoded !== "string") throw createModuleFederationError("A string encoded file name is required");
+	return encoded.replace(/_mf_0_/g, "@").replace(/_mf_1_/g, "/").replace(/_mf_2_/g, "-").replace(/_mf_3_/g, ".");
+}
+/**
+* Removes any subpath from an npm package specifier and returns the package name only.
+* @param {string} packageString - The package specifier, e.g., "@scope/pkg/runtime" or "react/jsx-runtime".
+* @returns {string} - The base npm package name.
+*/
+function getPackageName(packageString) {
+	const match = packageString.match(/^(?:@[^/]+\/)?[^/]+/);
+	return match ? match[0] : packageString;
+}
+function getPackageNameFromNodeModulePath(source) {
+	const normalized = source.replace(/\\/g, "/");
+	const nodeModulesIndex = normalized.lastIndexOf("/node_modules/");
+	if (nodeModulesIndex < 0) return;
+	const parts = normalized.slice(nodeModulesIndex + 14).split("/");
+	if (!parts[0]) return;
+	if (parts[0].startsWith("@")) return parts[1] ? `${parts[0]}/${parts[1]}` : void 0;
+	return parts[0];
+}
+function getSharedCacheKeyParts(input) {
+	const scope = (Array.isArray(input.scope) ? input.scope[0] : input.scope) || "default";
+	const id = input.singleton || !input.version ? input.pkg : `${input.pkg}@${input.version}`;
+	return {
+		scope,
+		id,
+		key: `${scope}:${id}`
+	};
+}
+function getSharedCacheDescriptor(pkg, shareItem) {
+	const parts = getSharedCacheKeyParts({
+		pkg,
+		singleton: shareItem.shareConfig.singleton,
+		version: shareItem.version,
+		scope: shareItem.scope
+	});
+	return {
+		canonical: parts.key,
+		...parts.scope === "default" ? { aliases: [parts.id] } : {}
+	};
+}
+const sharedCacheHelperCode = `const __mfGetSharedCacheDescriptor = (pkg, singleton, version, scope) => {
+            const normalizedScope = Array.isArray(scope) ? scope[0] : scope;
+            const scopeName = normalizedScope || "default";
+            const id = singleton || !version ? pkg : pkg + "@" + version;
+            const descriptor = { canonical: scopeName + ":" + id };
+            if (scopeName === "default") descriptor.aliases = [id];
+            return descriptor;
+          };
+          const __mfReadSharedCache = (cache, descriptor) => {
+            const value = cache[descriptor.canonical];
+            if (value !== undefined) return value;
+            const aliases = descriptor.aliases || [];
+            for (const alias of aliases) {
+              if (!Object.prototype.hasOwnProperty.call(cache, alias)) continue;
+              const aliasValue = cache[alias];
+              if (aliasValue !== undefined) {
+                cache[descriptor.canonical] = aliasValue;
+                return aliasValue;
+              }
+            }
+            return undefined;
+          };
+          const __mfSharedCacheListenersKey = Symbol.for("module-federation.shared-cache-listeners");
+          const __mfGetSharedCacheListeners = (cache) => {
+            let listeners = cache[__mfSharedCacheListenersKey];
+            if (listeners === undefined) {
+              listeners = Object.create(null);
+              Object.defineProperty(cache, __mfSharedCacheListenersKey, {
+                value: listeners,
+                enumerable: false,
+                configurable: false,
+                writable: false
+              });
+            }
+            return listeners;
+          };
+          const __mfSubscribeSharedCache = (cache, descriptor, listener) => {
+            const listeners = __mfGetSharedCacheListeners(cache);
+            (listeners[descriptor.canonical] ||= new Set()).add(listener);
+          };
+          const __mfSharedCacheOwnersKey = Symbol.for("module-federation.shared-cache-owners");
+          const __mfGetSharedCacheOwners = (cache) => {
+            let owners = cache[__mfSharedCacheOwnersKey];
+            if (owners === undefined) {
+              owners = Object.create(null);
+              Object.defineProperty(cache, __mfSharedCacheOwnersKey, {
+                value: owners,
+                enumerable: false,
+                configurable: false,
+                writable: false
+              });
+            }
+            return owners;
+          };
+          const __mfReadSharedCacheOwner = (cache, descriptor) =>
+            cache[__mfSharedCacheOwnersKey]?.[descriptor.canonical];
+          const __mfWriteSharedCache = (cache, descriptor, value, owner) => {
+            cache[descriptor.canonical] = value;
+            const aliases = descriptor.aliases || [];
+            for (const alias of aliases) {
+              Object.defineProperty(cache, alias, {
+                value,
+                enumerable: true,
+                configurable: true,
+                writable: true
+              });
+            }
+            const owners = cache[__mfSharedCacheOwnersKey];
+            if (owner === undefined) {
+              if (owners) delete owners[descriptor.canonical];
+            } else {
+              __mfGetSharedCacheOwners(cache)[descriptor.canonical] = owner;
+            }
+            const listeners = cache[__mfSharedCacheListenersKey]?.[descriptor.canonical];
+            if (listeners) {
+              for (const listener of listeners) listener(value);
+            }
+            return value;
+          };
+          const __mfTreeShakingSharedCacheKey = Symbol.for("module-federation.tree-shaking-shared-cache");
+          const __mfGetTreeShakingSharedCache = (cache) => {
+            let metadata = cache[__mfTreeShakingSharedCacheKey];
+            if (metadata === undefined) {
+              metadata = Object.create(null);
+              Object.defineProperty(cache, __mfTreeShakingSharedCacheKey, {
+                value: metadata,
+                enumerable: false,
+                configurable: false,
+                writable: false
+              });
+            }
+            return metadata;
+          };
+          const __mfReadTreeShakingSharedCache = (cache, descriptor, requiredExports) => {
+            const fullModule = __mfReadSharedCache(cache, descriptor);
+            if (fullModule !== undefined) return fullModule;
+            if (!Array.isArray(requiredExports)) return undefined;
+            const metadata = cache[__mfTreeShakingSharedCacheKey];
+            const entries = metadata?.[descriptor.canonical] || [];
+            let compatibleEntry;
+            for (const entry of entries) {
+              if (!requiredExports.every((name) => entry.providedExports.includes(name))) continue;
+              if (!compatibleEntry || entry.providedExports.length < compatibleEntry.providedExports.length) {
+                compatibleEntry = entry;
+              }
+            }
+            return compatibleEntry?.value;
+          };
+          const __mfWriteTreeShakingSharedCache = (cache, descriptor, providedExports, value) => {
+            if (!Array.isArray(providedExports)) return value;
+            const normalizedExports = [...new Set(providedExports)].sort();
+            const metadata = __mfGetTreeShakingSharedCache(cache);
+            const entries = (metadata[descriptor.canonical] ||= []);
+            const existing = entries.find((entry) =>
+              entry.providedExports.length === normalizedExports.length &&
+              entry.providedExports.every((name, index) => name === normalizedExports[index])
+            );
+            if (existing) existing.value = value;
+            else entries.push({ providedExports: normalizedExports, value });
+            return value;
+          };
+          const __mfTreeShakingSelectionCacheKey = Symbol.for("module-federation.tree-shaking-shared-selection-cache");
+          const __mfGetTreeShakingSelectionCache = (cache) => {
+            let selections = cache[__mfTreeShakingSelectionCacheKey];
+            if (selections === undefined) {
+              selections = Object.create(null);
+              Object.defineProperty(cache, __mfTreeShakingSelectionCacheKey, {
+                value: selections,
+                enumerable: false,
+                configurable: false,
+                writable: false
+              });
+            }
+            return selections;
+          };
+          const __mfReadTreeShakingSharedSelection = (cache, descriptor, consumer) => {
+            const fullModule = __mfReadSharedCache(cache, descriptor);
+            if (fullModule !== undefined) return fullModule;
+            return cache[__mfTreeShakingSelectionCacheKey]?.[descriptor.canonical]?.[consumer];
+          };
+          const __mfWriteTreeShakingSharedSelection = (cache, descriptor, consumer, value) => {
+            const selections = __mfGetTreeShakingSelectionCache(cache);
+            const byConsumer = (selections[descriptor.canonical] ||= Object.create(null));
+            byConsumer[consumer] = value;
+            return value;
+          };`;
+function getInstalledPackageJson(pkg, opts) {
+	const cwd = opts?.cwd || getPackageDetectionCwd();
+	const packageName = opts?.packageName || getPackageName(pkg);
+	const cacheKey = `${cwd}\0${pkg}\0${packageName}\0${opts?.fromResolvedEntry ?? ""}`;
+	if (installedPackageJsonCache.has(cacheKey)) return installedPackageJsonCache.get(cacheKey);
+	const result = resolveInstalledPackageJson(pkg, cwd, packageName, opts);
+	installedPackageJsonCache.set(cacheKey, result);
+	return result;
+}
+function resolveInstalledPackageJson(pkg, cwd, packageName, opts) {
+	const tryReadPackageJson = (packageJsonPath) => {
+		if (!existsSync(packageJsonPath)) return void 0;
+		try {
+			return {
+				path: packageJsonPath,
+				dir: path$1.dirname(packageJsonPath),
+				packageJson: JSON.parse(readFileSync(packageJsonPath, "utf-8"))
+			};
+		} catch {
+			return;
+		}
+	};
+	const findPackageInPnpmStore = (startDir) => {
+		let currentDir = startDir;
+		const rootDir = path$1.parse(currentDir).root;
+		while (true) {
+			const pnpmStoreDir = path$1.join(currentDir, "node_modules", ".pnpm");
+			if (existsSync(pnpmStoreDir)) try {
+				for (const entry of readdirSync(pnpmStoreDir, { withFileTypes: true })) {
+					if (!entry.isDirectory()) continue;
+					const candidate = tryReadPackageJson(path$1.join(pnpmStoreDir, entry.name, "node_modules", packageName, "package.json"));
+					if (candidate?.packageJson.name === packageName) return candidate;
+				}
+			} catch {}
+			if (currentDir === rootDir) break;
+			currentDir = path$1.dirname(currentDir);
+		}
+	};
+	try {
+		const projectRequire = createRequire$1(pathToFileURL(path$1.join(cwd, "package.json")));
+		let resolvedPath;
+		if (opts?.fromResolvedEntry) resolvedPath = opts.fromResolvedEntry;
+		else try {
+			resolvedPath = projectRequire.resolve(pkg);
+		} catch {
+			resolvedPath = projectRequire.resolve(packageName);
+		}
+		let currentDir = path$1.dirname(resolvedPath);
+		const rootDir = path$1.parse(currentDir).root;
+		while (true) {
+			const packageJsonPath = path$1.join(currentDir, "package.json");
+			if (existsSync(packageJsonPath)) {
+				const packageJsonContent = readFileSync(packageJsonPath, "utf-8");
+				try {
+					const packageJson = JSON.parse(packageJsonContent);
+					if (packageJson.name === packageName) return {
+						path: packageJsonPath,
+						dir: currentDir,
+						packageJson
+					};
+				} catch (error) {
+					if (!(error instanceof SyntaxError)) throw error;
+				}
+			}
+			if (currentDir === rootDir) break;
+			currentDir = path$1.dirname(currentDir);
+		}
+	} catch {
+		let currentDir = cwd;
+		const rootDir = path$1.parse(currentDir).root;
+		while (true) {
+			const directCandidate = tryReadPackageJson(path$1.join(currentDir, "node_modules", packageName, "package.json"));
+			if (directCandidate?.packageJson.name === packageName) return directCandidate;
+			if (currentDir === rootDir) break;
+			currentDir = path$1.dirname(currentDir);
+		}
+		return findPackageInPnpmStore(cwd);
+	}
+}
+function getInstalledPackageEntry(pkg, opts) {
+	const installed = getInstalledPackageJson(pkg, opts);
+	if (!installed) return void 0;
+	const cwd = opts?.cwd || getPackageDetectionCwd();
+	const packageName = opts?.packageName || getPackageName(pkg);
+	const packageJson = installed.packageJson;
+	if (pkg !== packageName && (opts?.resolveSubpathWithRequire !== false || packageJson.exports === void 0)) try {
+		return createRequire$1(pathToFileURL(path$1.join(cwd, "package.json"))).resolve(pkg);
+	} catch {}
+	const explicitEntry = resolveExportsEntry(getPackageExportsTarget(pkg, packageName, packageJson.exports), opts?.conditions) || (typeof packageJson.module === "string" ? packageJson.module : void 0) || (typeof packageJson.main === "string" ? packageJson.main : void 0) || "index.js";
+	return path$1.join(installed.dir, explicitEntry);
+}
+/**
+* Detect whether the current runtime is Vite 8+ by checking for a Vite version flag
+* on the plugin hook context, with Rolldown metadata kept as a compatibility fallback.
+*/
+function getIsRolldown(ctx) {
+	const viteVersion = ctx?.meta?.viteVersion;
+	const viteMajor = Number(String(viteVersion ?? "").split(".")[0]);
+	return Number.isFinite(viteMajor) && viteMajor >= 8 || !!ctx?.meta?.rolldownVersion;
+}
+/** Walk up from Vite `config.root` (Nuxt may point at `.nuxt` cache dirs). */
+function isNuxtProjectRoot(root) {
+	let dir = root;
+	for (let i = 0; i < 8; i++) {
+		if (hasPackageDependency("nuxt", dir) || hasPackageDependency("nuxt-nightly", dir)) return true;
+		const parent = path$1.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return false;
+}
+function hasPackageDependency(dependencyName, cwd = packageDetectionCwd || process.cwd()) {
+	const cacheKey = getDependencyCacheKey(cwd, dependencyName);
+	const cached = dependencyPresenceCache.get(cacheKey);
+	if (cached !== void 0) return cached;
+	try {
+		const packageJson = JSON.parse(readFileSync(path$1.join(cwd, "package.json"), "utf8"));
+		const hasDependency = [
+			packageJson.dependencies,
+			packageJson.devDependencies,
+			packageJson.peerDependencies,
+			packageJson.optionalDependencies
+		].some((deps) => !!deps?.[dependencyName]);
+		dependencyPresenceCache.set(cacheKey, hasDependency);
+		return hasDependency;
+	} catch {
+		dependencyPresenceCache.set(cacheKey, false);
+		return false;
+	}
+}
+//#endregion
 //#region src/utils/pathNormalization.ts
 const COMMON_SHARED_SUBPATHS = {
 	react: [
@@ -396,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(/\?.*$/, "");
@@ -1016,6 +1546,104 @@ function generateReactIslandSSRDefinition(enabled) {
             }
           }`;
 }
+const REACT_ISLAND_CLIENT_ID_PREFIX = "virtual:mf-react-island-client:";
+const REACT_ISLAND_SERVER_ID_PREFIX = "virtual:mf-react-island-server:";
+const RESOLVED_REACT_ISLAND_CLIENT_ID_PREFIX = `\0${REACT_ISLAND_CLIENT_ID_PREFIX}`;
+const RESOLVED_REACT_ISLAND_SERVER_ID_PREFIX = `\0${REACT_ISLAND_SERVER_ID_PREFIX}`;
+function encodeIslandRemoteId(remoteId) {
+	return encodeURIComponent(remoteId);
+}
+function decodeIslandRemoteId(encodedRemoteId) {
+	return decodeURIComponent(encodedRemoteId);
+}
+function getReactIslandImportRemoteId(source) {
+	const queryIndex = source.indexOf("?");
+	if (queryIndex === -1) return;
+	if (!new URLSearchParams(source.slice(queryIndex + 1)).has("mf-island")) return;
+	return source.slice(0, queryIndex);
+}
+function getReactIslandServerImportId(remoteId) {
+	return `${REACT_ISLAND_SERVER_ID_PREFIX}${encodeIslandRemoteId(remoteId)}`;
+}
+function getReactIslandClientImportId(remoteId) {
+	return `${REACT_ISLAND_CLIENT_ID_PREFIX}${encodeIslandRemoteId(remoteId)}`;
+}
+function resolveReactIslandConsumerId(id) {
+	if (id.startsWith("virtual:mf-react-island-server:")) return `\0${id}`;
+	if (id.startsWith("virtual:mf-react-island-client:")) return `\0${id}`;
+}
+function remoteIdFromResolvedIslandId(id, prefix) {
+	if (!id.startsWith(prefix)) return;
+	return decodeIslandRemoteId(id.slice(prefix.length));
+}
+/** Generates the server half of the opt-in `?mf-island` consumer component. */
+function generateReactIslandConsumerServer(remoteId) {
+	const source = JSON.stringify(remoteId);
+	return `import * as React from "react";
+import IslandClient from ${JSON.stringify(getReactIslandClientImportId(remoteId))};
+
+const islandModulePromise = import(${source});
+
+async function loadIslandModule() {
+  const namespace = await islandModulePromise;
+  const pending = namespace && namespace.__mf_remote_pending;
+  if (pending && typeof pending.then === "function") return pending;
+  return namespace && namespace.__moduleExports || namespace;
+}
+
+export default async function ModuleFederationIsland(props) {
+  const remoteModule = await loadIslandModule();
+  const shell = remoteModule && remoteModule.__mf_island;
+  if (!shell || typeof shell.renderToHtml !== "function") {
+    throw new Error(${JSON.stringify(`[Module Federation] ${remoteId} does not expose an SSR island capability`)});
+  }
+  const html = await shell.renderToHtml(props);
+  return React.createElement(IslandClient, { html, islandProps: props });
+}`;
+}
+/** Generates the client boundary which hydrates with the remote-owned React. */
+function generateReactIslandConsumerClient(remoteId) {
+	return `"use client";
+
+import * as React from "react";
+
+const islandModulePromise = import(${JSON.stringify(remoteId)});
+
+async function loadIslandModule() {
+  const namespace = await islandModulePromise;
+  const pending = namespace && namespace.__mf_remote_pending;
+  if (pending && typeof pending.then === "function") return pending;
+  return namespace && namespace.__moduleExports || namespace;
+}
+
+export default function ModuleFederationIslandClient({ html, islandProps }) {
+  const ref = React.useRef(null);
+
+  React.useEffect(() => {
+    const element = ref.current;
+    if (!element) return;
+    void loadIslandModule().then((remoteModule) => {
+      const shell = remoteModule && remoteModule.__mf_island;
+      if (!shell || typeof shell.hydrate !== "function") {
+        throw new Error(${JSON.stringify(`[Module Federation] ${remoteId} does not expose a client island capability`)});
+      }
+      return shell.hydrate(element, islandProps);
+    });
+  }, []);
+
+  return React.createElement("div", {
+    ref,
+    suppressHydrationWarning: true,
+    dangerouslySetInnerHTML: { __html: html },
+  });
+}`;
+}
+function loadReactIslandConsumerModule(id) {
+	const serverRemoteId = remoteIdFromResolvedIslandId(id, RESOLVED_REACT_ISLAND_SERVER_ID_PREFIX);
+	if (serverRemoteId !== void 0) return generateReactIslandConsumerServer(serverRemoteId);
+	const clientRemoteId = remoteIdFromResolvedIslandId(id, RESOLVED_REACT_ISLAND_CLIENT_ID_PREFIX);
+	if (clientRemoteId !== void 0) return generateReactIslandConsumerClient(clientRemoteId);
+}
 //#endregion
 //#region src/virtualModules/virtualExposes.ts
 const EXPOSES_CSS_MAP_PLACEHOLDER = "__MF_EXPOSES_CSS_MAP__";
@@ -1684,7 +2312,18 @@ function hasCodeMatch(source, regex, codePositions) {
 	return false;
 }
 function hasCommonJsExports(source) {
-	return hasCodeMatch(source, /\bmodule\s*(?:\.exports|\[\s*['"]exports['"]\s*\])|\bexports\s*(?:\.|\[|[,)]|=(?!=|>))/g, createCodePositionMap(source));
+	const codePositions = createCodePositionMap(source);
+	if (hasCodeMatch(source, /\bmodule\s*(?:\.exports|\[\s*['"]exports['"]\s*\])/g, codePositions)) return true;
+	const exportsRegex = /\bexports\s*(?:\.|\[|[,)]|=(?!=|>))/g;
+	let match;
+	while ((match = exportsRegex.exec(source)) !== null) {
+		if (!codePositions[match.index]) continue;
+		let previousCodeIndex = match.index - 1;
+		while (previousCodeIndex >= 0 && (/\s/.test(source[previousCodeIndex]) || !codePositions[previousCodeIndex])) previousCodeIndex--;
+		if (source[previousCodeIndex] === ".") continue;
+		return true;
+	}
+	return false;
 }
 function inspectSharedExportsFromFile(entryPath, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
 	try {
@@ -1701,6 +2340,64 @@ function inspectSharedExportsFromFile(entryPath, exportConditions = DEFAULT_SHAR
 		return;
 	}
 }
+function getMutableExportsFromFile(entryPath, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS, visited = /* @__PURE__ */ new Set()) {
+	if (!entryPath || visited.has(entryPath)) return [];
+	visited.add(entryPath);
+	try {
+		const source = readFileSync(entryPath, "utf-8");
+		const codePositions = createCodePositionMap(source);
+		const mutableBindings = /* @__PURE__ */ new Set();
+		const mutableExports = /* @__PURE__ */ new Set();
+		let match;
+		const declarationRegex = new RegExp(`\\b(?:export\\s+)?(?:let|var)\\s+(${JS_IDENTIFIER_PATTERN})`, "gu");
+		let declarationScanIndex = 0;
+		let braceDepth = 0;
+		while ((match = declarationRegex.exec(source)) !== null) {
+			if (!codePositions[match.index]) continue;
+			for (let index = declarationScanIndex; index < match.index; index++) {
+				if (!codePositions[index]) continue;
+				if (source[index] === "{") braceDepth++;
+				else if (source[index] === "}") braceDepth--;
+			}
+			declarationScanIndex = match.index;
+			if (braceDepth !== 0) continue;
+			mutableBindings.add(match[1]);
+			if (match[0].trimStart().startsWith("export")) mutableExports.add(match[1]);
+		}
+		const listRegex = /export\s*\{([^}]+)\}(?:\s*from\s*['"]([^'"]+)['"])?/g;
+		while ((match = listRegex.exec(source)) !== null) {
+			if (!codePositions[match.index]) continue;
+			const reExportPath = match[2] ? resolveReExportModule(entryPath, match[2], exportConditions) : void 0;
+			const reExportedMutable = new Set(reExportPath ? getMutableExportsFromFile(reExportPath, exportConditions, visited) : []);
+			for (const rawSpecifier of match[1].split(",")) {
+				const specifier = rawSpecifier.trim();
+				if (!specifier || specifier.startsWith("type ")) continue;
+				const parts = specifier.split(/\s+as\s+/);
+				const local = parts[0].trim();
+				const exported = (parts[1] || local).trim();
+				if (isValidEsmExportName(exported) && (mutableBindings.has(local) || reExportedMutable.has(local))) mutableExports.add(exported);
+			}
+		}
+		const starExportRegex = /export\s+\*\s+from\s+['"]([^'"]+)['"]/g;
+		while ((match = starExportRegex.exec(source)) !== null) {
+			if (!codePositions[match.index]) continue;
+			const resolved = resolveReExportModule(entryPath, match[1], exportConditions);
+			for (const name of getMutableExportsFromFile(resolved, exportConditions, visited)) mutableExports.add(name);
+		}
+		visited.delete(entryPath);
+		return Array.from(mutableExports);
+	} catch {
+		visited.delete(entryPath);
+		return [];
+	}
+}
+function getSharedMutableExports(pkg, shareItem, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
+	const configuredImport = shareItem?.shareConfig.import;
+	return getMutableExportsFromFile(typeof configuredImport === "string" ? resolveConfiguredImportPath(configuredImport, exportConditions) : getInstalledPackageEntry(pkg, {
+		conditions: exportConditions,
+		resolveSubpathWithRequire: false
+	}), exportConditions);
+}
 function resolveConfiguredImportPath(importSource, exportConditions = DEFAULT_SHARED_EXPORT_CONDITIONS) {
 	if (path$1.isAbsolute(importSource)) return resolveFileLikeModule(importSource);
 	const projectRoot = getPackageDetectionCwd();
@@ -1948,6 +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) {
@@ -2163,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);
@@ -2317,6 +3018,7 @@ export default { get, init };
 	materializedTreeShakingProviders.add(pkg);
 }
 function writePreBuildLibPath(pkg, shareItem, options, exportConditions) {
+	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const { preBuildCacheMap, preBuildShareItemMap } = getSharedVirtualModuleState(options);
 	if (!preBuildCacheMap[pkg]) preBuildCacheMap[pkg] = createScopedSharedVirtualModule(pkg, PREBUILD_TAG, options);
 	preBuildShareItemMap[pkg] = shareItem;
@@ -2368,14 +3070,19 @@ function writePreBuildLibPath(pkg, shareItem, options, exportConditions) {
 	}
 	const namedExports = getSharedNamedExports(pkg, shareItem, exportConditions) ?? [];
 	if (namedExports.length > 0) {
-		const namedExportVars = namedExports.map((_name, i) => `__mf_${i}`);
-		const declarations = namedExports.map((name, i) => `const ${namedExportVars[i]} = __mfPrebuildExports[${escapeGeneratedStringLiteral(name)}];`).join("\n    ");
-		const namedExportLine = `export { ${namedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };`;
+		const mutableExports = new Set(isLocalOnlyContainer(resolvedOptions) ? getSharedMutableExports(pkg, shareItem, exportConditions) : []);
+		const copiedExports = namedExports.filter((name) => !mutableExports.has(name));
+		const liveExports = namedExports.filter((name) => mutableExports.has(name));
+		const namedExportVars = copiedExports.map((_name, i) => `__mf_${i}`);
+		const declarations = copiedExports.map((name, i) => `const ${namedExportVars[i]} = __mfPrebuildExports[${escapeGeneratedStringLiteral(name)}];`).join("\n    ");
+		const namedExportLine = copiedExports.length ? `export { ${copiedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : "";
+		const liveExportLine = liveExports.length ? `export { ${liveExports.join(", ")} } from ${escapeGeneratedStringLiteral(importSource)};` : "";
 		preBuildCacheMap[pkg].writeSync(`
     import * as __mfPrebuildNamespace from ${escapeGeneratedStringLiteral(importSource)};
     const __mfPrebuildExports = __mfPrebuildNamespace;
     ${declarations}
     ${namedExportLine}
+    ${liveExportLine}
     export default Reflect.get(__mfPrebuildNamespace, "default") ?? __mfPrebuildNamespace;
   `, true);
 		return;
@@ -2463,11 +3170,13 @@ function findCurrentLoadShareForStaleOwnerId(id, shared, findSharedKey, options)
 function getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer) {
 	return treeShakingConsumer ? `__mfReadTreeShakingSharedSelection(__mfModuleCache.share, ${cacheDescriptor}, ${JSON.stringify(treeShakingConsumer)})` : `__mfReadSharedCache(__mfModuleCache.share, ${cacheDescriptor})`;
 }
-function generateEagerWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer) {
-	const namedExportVars = namedExports.map((_name, i) => `__mf_${i}`);
+function generateEagerWorkspaceSingletonExports(namedExports, importSource, cacheDescriptor, cacheOwner, treeShakingConsumer, mutableExports = []) {
+	const copiedExports = namedExports.filter((name) => !mutableExports.includes(name));
+	const namedExportVars = copiedExports.map((_name, i) => `__mf_${i}`);
 	const declarations = namedExports.length > 0 ? ["let __mf_default;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ") : "let __mf_default;";
-	const assignments = [...namedExports.map((name, i) => `${namedExportVars[i]} = mod[${escapeGeneratedStringLiteral(name)}];`), "__mf_default = mod.default ?? mod;"].join("\n      ");
-	const namedExportLine = namedExports.length > 0 ? `\n    export { ${namedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : "";
+	const assignments = [...copiedExports.map((name, i) => `${namedExportVars[i]} = mod[${escapeGeneratedStringLiteral(name)}];`), "__mf_default = mod.default ?? mod;"].join("\n      ");
+	const namedExportLine = copiedExports.length > 0 ? `\n    export { ${copiedExports.map((name, i) => `${namedExportVars[i]} as ${name}`).join(", ")} };` : "";
+	const mutableExportLine = mutableExports.length ? `\n    export { ${mutableExports.join(", ")} } from ${escapeGeneratedStringLiteral(importSource)};` : "";
 	return `import * as __mfLocalShare from ${escapeGeneratedStringLiteral(importSource)};
     let exportModule = ${getSharedCacheReadExpression(cacheDescriptor, treeShakingConsumer)};
     if (exportModule === undefined) {
@@ -2484,13 +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);`;
@@ -2519,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) {
@@ -2619,6 +3330,10 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	const skipServePrebuildWarmup = command !== "build" && (pkg === "lit" || pkg.startsWith("lit/"));
 	const detectedNamedExports = getSharedNamedExports(pkg, shareItem, exportConditions);
 	const namedExports = detectedNamedExports ?? [];
+	const mutableExports = new Set(isLocalOnlyContainer(resolvedOptions) ? getSharedMutableExports(pkg, shareItem, exportConditions) : []);
+	const copiedNamedExports = namedExports.filter((name) => !mutableExports.has(name));
+	const liveNamedExports = namedExports.filter((name) => mutableExports.has(name));
+	const liveNamedExportLine = liveNamedExports.length ? `export { ${liveNamedExports.join(", ")} } from ${escapeGeneratedStringLiteral(sharedImportSource)};` : "";
 	const hasCompleteExportCoverage = detectedNamedExports !== void 0;
 	const isWorkspaceSingleton = isWorkspacePackage && shareItem.shareConfig.singleton === true;
 	const isDefaultShareScope = shareItem.scope === void 0 || shareItem.scope === "default" || Array.isArray(shareItem.scope) && shareItem.scope[0] === "default";
@@ -2632,11 +3347,11 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 	let initBlock = "";
 	if (usesDeferredTreeShakingFallback) {
 		importLine = `${getRuntimeInitPromiseBootstrapCode(false, runtimeInitOwnerImportId)}\n    ${importLine}`;
-		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && (isWorkspaceSingleton || isWorkspacePackage || servesRemoteSingletonFallback));
-	} else if (usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback) exportLine = generateEagerWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer);
+		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && (isWorkspaceSingleton || isWorkspacePackage || servesRemoteSingletonFallback), liveNamedExports);
+	} else if (usesEagerWorkspaceFallback || usesEntryInjectedRemoteFallback) exportLine = generateEagerWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, liveNamedExports);
 	else if (usesDeferredSingletonFallback) {
 		importLine = `${getRuntimeInitPromiseBootstrapCode(false, runtimeInitOwnerImportId)}\n    ${importLine}`;
-		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && (isWorkspaceSingleton || isWorkspacePackage || servesRemoteSingletonFallback));
+		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && (isWorkspaceSingleton || isWorkspacePackage || servesRemoteSingletonFallback), liveNamedExports);
 	} else if (detectedNamedExports === void 0) {
 		exportLine = `const __mfDefaultExport = (() => {
       ${generateShareModuleUnwrapCode({
@@ -2650,10 +3365,10 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
       __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
 	} else if (namedExports.length > 0 && shareItem.shareConfig.singleton === true) {
-		const namedExportVars = namedExports.map((_name, i) => `__mf_${i}`);
+		const namedExportVars = copiedNamedExports.map((_name, i) => `__mf_${i}`);
 		exportLine = `${["let __mfDefaultExport;", ...namedExportVars.map((name) => `let ${name};`)].join("\n    ")}
     const __mfApplySharedExports = (mod) => {
-      ${[...namedExports.map((name, i) => `${namedExportVars[i]} = mod[${escapeGeneratedStringLiteral(name)}];`), `__mfDefaultExport = (() => {
+      ${[...copiedNamedExports.map((name, i) => `${namedExportVars[i]} = mod[${escapeGeneratedStringLiteral(name)}];`), `__mfDefaultExport = (() => {
         ${generateShareModuleUnwrapCode({
 			source: "mod",
 			preserveNamedExports: false,
@@ -2664,12 +3379,13 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
     __mfSubscribeSharedCache(__mfModuleCache.share, ${cacheDescriptor}, __mfApplySharedExports);
     __mfApplySharedExports(exportModule);
     export { __mfDefaultExport as default };
-    ${`export { ${namedExports.map((name, i) => `__mf_${i} as ${name}`).join(", ")} };`}`;
+    ${copiedNamedExports.length ? `export { ${copiedNamedExports.map((name, i) => `__mf_${i} as ${name}`).join(", ")} };` : ""}
+    ${liveNamedExportLine}`;
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
       __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
 	} else if (namedExports.length > 0) {
-		const destructure = `const { ${namedExports.map((name, i) => `${name}: __mf_${i}`).join(", ")} } = exportModule;`;
-		const namedExportLine = `export { ${namedExports.map((name, i) => `__mf_${i} as ${name}`).join(", ")} };`;
+		const destructure = copiedNamedExports.length ? `const { ${copiedNamedExports.map((name, i) => `${name}: __mf_${i}`).join(", ")} } = exportModule;` : "";
+		const namedExportLine = copiedNamedExports.length ? `export { ${copiedNamedExports.map((name, i) => `__mf_${i} as ${name}`).join(", ")} };` : "";
 		exportLine = `const __mfDefaultExport = (() => {
       ${generateShareModuleUnwrapCode({
 			source: "exportModule",
@@ -2679,7 +3395,8 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options, exp
     })();
     export default __mfDefaultExport;
     ${destructure}
-    ${namedExportLine}`;
+    ${namedExportLine}
+    ${liveNamedExportLine}`;
 		initBlock = `exportModule = __mfNormalizeShareModule(__mfLocalShare);
       __mfWriteSharedCache(__mfModuleCache.share, ${cacheDescriptor}, exportModule, ${cacheOwner});`;
 	} else if (shareItem.shareConfig.singleton === true) {
@@ -2754,7 +3471,8 @@ function getLocalOwnerKey(options) {
 }
 function getLocalSharedImportMapPath(options) {
 	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
-	return `${LOCAL_SHARED_IMPORT_MAP_ID}:${packageNameEncode(options ? getLocalOwnerKey(resolvedOptions) : resolvedOptions.internalName || resolvedOptions.name)}`;
+	const ownerName = options ? getLocalOwnerKey(resolvedOptions) : resolvedOptions.internalName || resolvedOptions.name;
+	return `${LOCAL_SHARED_IMPORT_MAP_ID}:${packageNameEncode(ownerName)}`;
 }
 function getResolvedLocalSharedImportMapId(options) {
 	return `\0${getLocalSharedImportMapPath(options)}`;
@@ -3272,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) {
@@ -4240,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"
 		};
@@ -4943,10 +5663,11 @@ const __mfCurrentScript = document.currentScript;
 					const entrySrc = stripBase(originalSrc);
 					addEntryRemoteImports(entrySrc);
 					const resolvedEntrySrc = entrySrc.startsWith("virtual:") ? toViteEncodedId(entrySrc) : entrySrc;
-					return toViteEncodedId(`${DEV_HTML_PROXY_PREFIX}${new URLSearchParams({
+					const query = new URLSearchParams({
 						init: sanitizeDevEntryPath(stripBase(devEntryPath)),
 						entry: sanitizeDevEntryPath(resolvedEntrySrc)
-					}).toString()}`);
+					}).toString();
+					return toViteEncodedId(`${DEV_HTML_PROXY_PREFIX}${query}`);
 				});
 				return html === c ? injectEntryScript(c, stripBase(devEntryPath)) : html;
 			}
@@ -5332,7 +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 || "/";
@@ -5342,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}`;
 }
@@ -6267,7 +6988,8 @@ function generateExposesSSR(options, reactIslandExposes = /* @__PURE__ */ new Se
 //#region src/virtualModules/virtualRemoteEntrySSR.ts
 const REMOTE_ENTRY_SSR_ID = "virtual:mf-REMOTE_ENTRY_SSR_ID";
 function getRemoteEntrySSRId(options) {
-	return `${REMOTE_ENTRY_SSR_ID}:${`${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+	const scopedKey = `${options.internalName}__${options.filename}`.replace(/[^a-zA-Z0-9_-]/g, "_");
+	return `${REMOTE_ENTRY_SSR_ID}:${scopedKey}`;
 }
 function getSsrRemoteEntryFileName(browserFilename) {
 	const ext = browserFilename.match(/\.[^.]+$/)?.[0] || ".js";
@@ -6345,6 +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.
@@ -6447,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);
@@ -6507,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 = {};
@@ -6521,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;
@@ -7091,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);
 		}
 	};
 }
@@ -7299,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);
@@ -7731,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"
@@ -7876,7 +8943,7 @@ function pluginSSRRemoteEntry(options) {
 		...options.ssrExternals ?? []
 	];
 	const ssrOnlyExternalPattern = new RegExp(`^(${ssrOnlyExternals.map((e) => e.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&")).join("|")})(\\/.*)?$`);
-	const ssrModuleIds = new Set([remoteEntrySSRId, virtualExposesSSRId]);
+	const ssrModuleIds = /* @__PURE__ */ new Set([remoteEntrySSRId, virtualExposesSSRId]);
 	const resolvedAbsToPackage = /* @__PURE__ */ new Map();
 	let isServe = false;
 	let viteConfig;
@@ -7929,7 +8996,7 @@ function pluginSSRRemoteEntry(options) {
 		},
 		configureServer(server) {
 			const base = "/__mf_ssr__";
-			const basePath = getBasePath$1(viteConfig?.base);
+			const basePath = getBasePath$2(viteConfig?.base);
 			const ssrEntryFileName = getSsrRemoteEntryFileName(options.filename);
 			if (isNuxtProject || isNuxtClientBase(basePath)) server.middlewares.use((req, _res, next) => {
 				if (req.url?.replace(/\?.*/, "") === `${basePath}/${ssrEntryFileName}`) req.url = `${basePath}/__mf_ssr__/${ssrEntryFileName}`;
@@ -8073,7 +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 || [],
@@ -8102,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) {
@@ -8121,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).`);
@@ -8278,7 +9366,7 @@ const DEFAULT_WEBWORKER_SSR_EXPORT_CONDITIONS = [
 ];
 const VITE_DEV_PROD_CONDITION = "development|production";
 function appendConditions(conditions, fallbackConditions) {
-	return [...new Set([...conditions, ...fallbackConditions])];
+	return [.../* @__PURE__ */ new Set([...conditions, ...fallbackConditions])];
 }
 function resolveViteModeCondition(conditions, isProduction) {
 	const modeCondition = isProduction ? "production" : "development";
@@ -8448,7 +9536,7 @@ function canResolveSharedSubpath(subpath, projectRoot) {
 		return false;
 	}
 }
-const VITE_DEV_IMPORT_CONDITIONS = new Set([
+const VITE_DEV_IMPORT_CONDITIONS = /* @__PURE__ */ new Set([
 	"browser",
 	"development",
 	"import",
@@ -8738,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;
@@ -8750,7 +9838,7 @@ function applyBuildTimeRuntimeDefines(define, options, { target, isAstro, defaul
 }
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-Dbbi4cnh.js").then((n) => n.n).then(({ default: pluginDts }) => pluginDts(options))];
+	return [Promise.resolve().then(() => pluginDts_exports).then(({ default: pluginDts }) => pluginDts(options))];
 }
 const INJECT_EXTERNAL_RUNTIME_CORE_PLUGIN = "@module-federation/vite/injectExternalRuntimeCorePlugin";
 function isInjectExternalRuntimeCorePlugin(specifier) {
@@ -9230,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();
 				});