@module-federation/vite 1.18.1 → 1.19.0

package/lib/index.js

@@ -1,4 +1,4 @@
-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-CGDIZCsD.js";
+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-Cd2opGcZ.js";
 import { createRequire } from "node:module";
 import * as fs$2 from "fs";
 import { existsSync, readFileSync, realpathSync, statSync, writeFileSync } from "fs";
@@ -237,6 +237,10 @@ const ASSET_LIKE_IMPORT_RE = new RegExp(`\\.(${[...[
 function isAssetLikeImport(source) {
 	return ASSET_LIKE_IMPORT_RE.test(source);
 }
+const VITE_OPTIMIZABLE_ENTRY_RE = /\.[cm]?[jt]s$/;
+function isViteOptimizableEntry(resolvedPath) {
+	return VITE_OPTIMIZABLE_ENTRY_RE.test(resolvedPath);
+}
 function removeTrailingSlash(value) {
 	return value.endsWith("/") ? value.slice(0, -1) : value;
 }
@@ -490,6 +494,7 @@ function normalizeManifest(manifest) {
 }
 let config;
 let explicitSharedKeys = /* @__PURE__ */ new Set();
+const explicitSharedKeysByOptions = /* @__PURE__ */ new WeakMap();
 function resolveRuntimeImplementation() {
 	const fallback = resolveImportPath("@module-federation/runtime");
 	try {
@@ -505,17 +510,16 @@ function resolveRuntimeImplementation() {
 function getNormalizeModuleFederationOptions() {
 	return config;
 }
-function isExplicitSharedKey(key) {
-	return explicitSharedKeys.has(key);
+function isExplicitSharedKey(key, options) {
+	return (options ? explicitSharedKeysByOptions.get(options) : explicitSharedKeys)?.has(key) ?? false;
 }
-function getNormalizeShareItem(key) {
-	const options = getNormalizeModuleFederationOptions();
+function getNormalizeShareItem(key, options = getNormalizeModuleFederationOptions()) {
 	return options.shared[key] || options.shared[getPackageName(key)] || options.shared[getPackageName(key) + "/"];
 }
 function normalizeModuleFederationOptions(options) {
 	warnOnReservedInternalNamePrefix(options.name, "containerName");
 	if (options.virtualModuleDir && options.virtualModuleDir.includes("/")) throw createModuleFederationError(`Invalid virtualModuleDir: "${options.virtualModuleDir}". The virtualModuleDir option cannot contain slashes (/). Please use a single directory name like '__mf__virtual__your_app_name'.`);
-	return config = {
+	const normalized = {
 		exposes: normalizeExposes(options.exposes),
 		filename: options.filename || "remoteEntry-[hash]",
 		internalName: toInternalModuleFederationName(options.name),
@@ -544,8 +548,13 @@ function normalizeModuleFederationOptions(options) {
 		moduleParseTimeout: options.moduleParseTimeout || 10,
 		moduleParseIdleTimeout: options.moduleParseIdleTimeout,
 		varFilename: options.varFilename,
-		target: options.target
+		target: options.target,
+		disableRemote: options.disableRemote,
+		disableShared: options.disableShared,
+		disableSnapshot: options.disableSnapshot
 	};
+	explicitSharedKeysByOptions.set(normalized, new Set(explicitSharedKeys));
+	return config = normalized;
 }
 //#endregion
 //#region src/utils/VirtualModule.ts
@@ -575,7 +584,7 @@ function decodeViteId(id) {
 	return viteId.startsWith("__x00__") ? `\0${viteId.slice(7)}` : viteId;
 }
 function assertModuleFound(tag, str = "") {
-	const module = VirtualModule.findModule(tag, str);
+	const module = VirtualModule.findById(str) ?? VirtualModule.findModule(tag, str);
 	if (!module) throw createModuleFederationError(`Module Federation shared module '${str}' not found. Please ensure it's installed as a dependency in your package.json.`);
 	return module;
 }
@@ -594,6 +603,7 @@ var VirtualModule = class VirtualModule {
 	code;
 	importId;
 	importIdKey;
+	scopeName;
 	static findName(tag, str = "") {
 		if (!patternMap[tag]) patternMap[tag] = new RegExp(`(.*${packageNameEncode(tag)}(.+?)${packageNameEncode(tag)}.*)`);
 		const moduleName = (normalizeVirtualModuleId(str).match(patternMap[tag]) || [])[2];
@@ -607,16 +617,16 @@ var VirtualModule = class VirtualModule {
 		const normalized = normalizeVirtualModuleId(id);
 		return normalized.startsWith("virtual:mf:") ? idCacheMap[normalized] : void 0;
 	}
-	constructor(name, tag = "__mf_v__", suffix = "") {
+	constructor(name, tag = "__mf_v__", suffix = "", scopeName) {
 		this.name = name;
 		this.tag = tag;
 		this.suffix = suffix || getSuffix(name);
+		this.scopeName = scopeName;
 		if (!cacheMap[this.tag]) cacheMap[this.tag] = {};
 		cacheMap[this.tag][this.name] = this;
 	}
 	getImportId() {
-		const { internalName: mfName } = getNormalizeModuleFederationOptions();
-		const importIdKey = `${mfName}${this.tag}${this.name}${this.tag}`;
+		const importIdKey = `${this.scopeName ?? getNormalizeModuleFederationOptions().internalName}${this.tag}${this.name}${this.tag}`;
 		if (this.importId && this.importIdKey === importIdKey) return this.importId;
 		if (this.importId) delete idCacheMap[this.importId];
 		this.importIdKey = importIdKey;
@@ -774,7 +784,7 @@ function generateExposes(options, remoteDependencyMap = {}, command = "build") {
     export default {
     ${Object.keys(options.exposes).map((key) => {
 		const remoteDependencyPreloads = (remoteDependencyMap[key] ?? []).map((remoteId) => {
-			const virtualRemote = getRemoteVirtualModule(remoteId, command);
+			const virtualRemote = getRemoteVirtualModule(remoteId, command, false, "unified", options);
 			return `import(${JSON.stringify(virtualRemote.getImportId())})
             .then((mod) => mod.__mf_remote_pending)`;
 		}).join(",");
@@ -805,9 +815,40 @@ function generateExposes(options, remoteDependencyMap = {}, command = "build") {
 //#endregion
 //#region src/virtualModules/virtualRuntimeInitStatus.ts
 const virtualRuntimeInitStatus = new VirtualModule("runtimeInit");
+const runtimeInitModules = /* @__PURE__ */ new WeakMap();
+const runtimeInitOwnerIds = /* @__PURE__ */ new WeakMap();
+let nextRuntimeInitOwnerId = 1;
 const MODULE_CACHE_GLOBAL_KEY = "__mf_module_cache__";
-function getRuntimeInitGlobalKey() {
-	return `__mf_init__${virtualRuntimeInitStatus.getImportId()}__`;
+function getRuntimeInitOwnerId(options) {
+	let ownerId = runtimeInitOwnerIds.get(options);
+	if (!ownerId) {
+		ownerId = nextRuntimeInitOwnerId++;
+		runtimeInitOwnerIds.set(options, ownerId);
+	}
+	return ownerId;
+}
+function getRuntimeInitModule(options) {
+	if (!options) return virtualRuntimeInitStatus;
+	let runtimeInitModule = runtimeInitModules.get(options);
+	if (!runtimeInitModule) {
+		const ownerId = getRuntimeInitOwnerId(options);
+		runtimeInitModule = new VirtualModule("runtimeInit", "__mf_v__", "", `${options.internalName}__mf_owner__${ownerId}`);
+		runtimeInitModules.set(options, runtimeInitModule);
+	}
+	return runtimeInitModule;
+}
+function getRuntimeInitStatusImportId(options) {
+	return getRuntimeInitModule(options).getImportId();
+}
+function getRuntimeRemoteCachePrefix(options) {
+	return options ? `${getRuntimeInitStatusImportId(options)}::` : "";
+}
+function getRuntimeRemoteAlias(alias, options) {
+	if (!options) return alias;
+	return `${options.internalName}__mf_owner__${getRuntimeInitOwnerId(options)}__${alias}`;
+}
+function getRuntimeInitGlobalKey(ownerImportId) {
+	return `__mf_init__${ownerImportId ?? virtualRuntimeInitStatus.getImportId()}__`;
 }
 function getDeferredInitPromiseCode() {
 	return `let initResolve, initReject;
@@ -817,10 +858,7 @@ function getDeferredInitPromiseCode() {
   });`;
 }
 let _ssrRemotes = [];
-function setSsrRemotes(remotes) {
-	_ssrRemotes = remotes;
-}
-function getSsrNoopResolveCode(enableSsrInit, hostInitImportId, initResolveExpression = "initResolve") {
+function getSsrNoopResolveCode(enableSsrInit, hostInitImportId, initResolveExpression = "initResolve", ssrRemotes = _ssrRemotes) {
 	if (!enableSsrInit) return "";
 	return `if (${SERVER_ENV_GUARD}) {
     var _noop = { loadRemote: function() { return Promise.resolve(undefined); }, loadShare: function() { return Promise.resolve(undefined); } };
@@ -840,7 +878,7 @@ function getSsrNoopResolveCode(enableSsrInit, hostInitImportId, initResolveExpre
           function() { return [runtimeMod, []]; }
         );
       }).then(function(pair) {
-        var runtime = pair[0].init({ name: '__mf_ssr_host__', remotes: ${JSON.stringify(_ssrRemotes)}, shared: {}, plugins: pair[1] });
+        var runtime = pair[0].init({ name: '__mf_ssr_host__', remotes: ${JSON.stringify(ssrRemotes)}, shared: {}, plugins: pair[1] });
         ${initResolveExpression}(runtime);
       }, function() {
         ${initResolveExpression}(_noop);
@@ -850,7 +888,7 @@ function getSsrNoopResolveCode(enableSsrInit, hostInitImportId, initResolveExpre
 }
 function getRuntimeInitStateBootstrapCode(options) {
 	return `
-const ${options.globalKeyVar} = ${JSON.stringify(getRuntimeInitGlobalKey())};
+const ${options.globalKeyVar} = ${JSON.stringify(getRuntimeInitGlobalKey(options.ownerImportId))};
 let ${options.stateVar} = globalThis[${options.globalKeyVar}];
 if (!${options.stateVar}) {
   ${getDeferredInitPromiseCode()}
@@ -859,14 +897,14 @@ if (!${options.stateVar}) {
     initResolve,
     initReject,
   };
-  ${getSsrNoopResolveCode(options.enableSsrInit)}
+  ${getSsrNoopResolveCode(options.enableSsrInit, options.hostInitImportId, "initResolve", options.ssrRemotes)}
 }
 const ${options.exposedConst} = ${options.stateVar}.${options.exposedProperty};
 `;
 }
-function getRuntimeInitBootstrapCode(enableSsrInit = false, hostInitImportId) {
+function getRuntimeInitBootstrapCode(enableSsrInit = false, ownerImportId, ssrRemotes, hostInitImportId = ownerImportId) {
 	return `
-const globalKey = ${JSON.stringify(getRuntimeInitGlobalKey())};
+const globalKey = ${JSON.stringify(getRuntimeInitGlobalKey(ownerImportId))};
 const moduleCacheGlobalKey = ${JSON.stringify(MODULE_CACHE_GLOBAL_KEY)};
 globalThis[moduleCacheGlobalKey] ||= { share: {}, remote: {} };
 globalThis[moduleCacheGlobalKey].share ||= {};
@@ -883,7 +921,7 @@ globalThis[globalKey] = {
 ${enableSsrInit ? `
 if (${SERVER_ENV_GUARD} && !globalThis[globalKey].ssrInitStarted) {
   globalThis[globalKey].ssrInitStarted = true;
-  ${getSsrNoopResolveCode(enableSsrInit, hostInitImportId, "globalThis[globalKey].initResolve")}
+  ${getSsrNoopResolveCode(enableSsrInit, hostInitImportId, "globalThis[globalKey].initResolve", ssrRemotes)}
 }` : ""}
 globalThis[globalKey].moduleCache ||= globalThis[moduleCacheGlobalKey];
 globalThis[globalKey].moduleCache.share ||= {};
@@ -912,29 +950,36 @@ for (const __mfShareKey of Object.keys(__mfModuleCache.share)) {
 }
 `;
 }
-function getRuntimeInitPromiseBootstrapCode(enableSsrInit = false) {
+function getRuntimeInitPromiseBootstrapCode(enableSsrInit = false, ownerImportId, ssrRemotes, hostInitImportId = ownerImportId) {
 	return getRuntimeInitStateBootstrapCode({
 		globalKeyVar: "__mfPromiseGlobalKey",
 		stateVar: "__mfPromiseState",
 		exposedConst: "initPromise",
 		exposedProperty: "initPromise",
-		enableSsrInit
+		enableSsrInit,
+		ownerImportId,
+		hostInitImportId,
+		ssrRemotes
 	});
 }
-function getRuntimeInitResolveBootstrapCode(enableSsrInit = false) {
+function getRuntimeInitResolveBootstrapCode(enableSsrInit = false, ownerImportId, ssrRemotes, hostInitImportId = ownerImportId) {
 	return getRuntimeInitStateBootstrapCode({
 		globalKeyVar: "__mfResolveGlobalKey",
 		stateVar: "__mfResolveState",
 		exposedConst: "initResolve",
 		exposedProperty: "initResolve",
-		enableSsrInit
+		enableSsrInit,
+		ownerImportId,
+		hostInitImportId,
+		ssrRemotes
 	});
 }
-function writeRuntimeInitStatus(command, enableSsrInit = false, hostInitImportId) {
+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];`;
-	virtualRuntimeInitStatus.writeSync(`
-${getRuntimeInitBootstrapCode(enableSsrInit, hostInitImportId)}
+	const ownerImportId = options ? getRuntimeInitStatusImportId(options) : hostInitImportId;
+	getRuntimeInitModule(options).writeSync(`
+${getRuntimeInitBootstrapCode(enableSsrInit, ownerImportId, ssrRemotes, hostInitImportId)}
 ${exportStatement}
 `);
 }
@@ -1079,25 +1124,35 @@ function createCodePositionMap(code) {
 }
 //#endregion
 //#region src/utils/treeShaking.ts
-/**
-* Analysis is scoped by both the configured share key and the concrete module
-* request. A prefix share such as `lodash/` may materialize separate wrappers
-* for `lodash/get` and `lodash/debounce`; combining those export sets would
-* generate invalid wrappers and defeat per-subpath tree shaking.
-*/
-const inferredTreeShakingUsage = /* @__PURE__ */ new Map();
-let treeShakingBuildMode = false;
-function setTreeShakingBuildMode(enabled) {
-	treeShakingBuildMode = enabled;
+const legacyTreeShakingState = {
+	inferredUsage: /* @__PURE__ */ new Map(),
+	buildMode: false
+};
+const treeShakingStates = /* @__PURE__ */ new WeakMap();
+function getTreeShakingState(options) {
+	if (!options) return legacyTreeShakingState;
+	let state = treeShakingStates.get(options);
+	if (!state) {
+		state = {
+			inferredUsage: /* @__PURE__ */ new Map(),
+			buildMode: false
+		};
+		treeShakingStates.set(options, state);
+	}
+	return state;
+}
+function setTreeShakingBuildMode(enabled, options) {
+	getTreeShakingState(options).buildMode = enabled;
 }
-function resetTreeShakingExports() {
-	inferredTreeShakingUsage.clear();
+function resetTreeShakingExports(options) {
+	getTreeShakingState(options).inferredUsage.clear();
 }
-function getOrCreateExportRecord(sharedKey, request) {
-	let byRequest = inferredTreeShakingUsage.get(sharedKey);
+function getOrCreateExportRecord(sharedKey, request, options) {
+	const inferredUsage = getTreeShakingState(options).inferredUsage;
+	let byRequest = inferredUsage.get(sharedKey);
 	if (!byRequest) {
 		byRequest = /* @__PURE__ */ new Map();
-		inferredTreeShakingUsage.set(sharedKey, byRequest);
+		inferredUsage.set(sharedKey, byRequest);
 	}
 	let record = byRequest.get(request);
 	if (!record) {
@@ -1109,22 +1164,23 @@ function getOrCreateExportRecord(sharedKey, request) {
 	}
 	return record;
 }
-function recordTreeShakingExports(sharedKey, exports, request = sharedKey) {
-	const record = getOrCreateExportRecord(sharedKey, request);
+function recordTreeShakingExports(sharedKey, exports, request = sharedKey, options) {
+	const record = getOrCreateExportRecord(sharedKey, request, options);
 	exports.forEach((name) => record.usedExports.add(name));
 }
-function markTreeShakingPackageUnsafe(sharedKey, request = sharedKey) {
-	getOrCreateExportRecord(sharedKey, request).requiresFullBundle = true;
+function markTreeShakingPackageUnsafe(sharedKey, request = sharedKey, options) {
+	getOrCreateExportRecord(sharedKey, request, options).requiresFullBundle = true;
 }
-function getExportRecords(sharedKey, request) {
+function getExportRecords(sharedKey, request, options) {
+	const inferredUsage = getTreeShakingState(options).inferredUsage;
 	if (sharedKey) {
-		const records = inferredTreeShakingUsage.get(sharedKey);
+		const records = inferredUsage.get(sharedKey);
 		const wildcard = records?.get("*");
 		const exact = records?.get(request);
 		return [wildcard, exact === wildcard ? void 0 : exact].filter((record) => !!record);
 	}
 	const records = [];
-	inferredTreeShakingUsage.forEach((byRequest, configuredKey) => {
+	inferredUsage.forEach((byRequest, configuredKey) => {
 		const wildcard = byRequest.get("*");
 		const exact = byRequest.get(request);
 		const keyBase = configuredKey.endsWith("/") ? configuredKey.slice(0, -1) : configuredKey;
@@ -1141,10 +1197,10 @@ function getExportRecords(sharedKey, request) {
 * fallback lookup across keys keeps aliases/backwards-compatible callers
 * working, while still keeping each concrete request's exports isolated.
 */
-function getTreeShakingExportUsage(request, shareItem, sharedKey) {
+function getTreeShakingExportUsage(request, shareItem, sharedKey, options) {
 	const treeShaking = shareItem?.shareConfig.treeShaking;
-	if (!treeShaking || !treeShakingBuildMode) return void 0;
-	const records = getExportRecords(sharedKey, request);
+	if (!treeShaking || !getTreeShakingState(options).buildMode) return void 0;
+	const records = getExportRecords(sharedKey, request, options);
 	if (records.some((record) => record.requiresFullBundle)) return { kind: "full" };
 	const configured = treeShaking.usedExports ?? [];
 	const result = new Set(configured);
@@ -1661,7 +1717,7 @@ function getNamedExportsViaRegex(source, filePath, visited, scanState = { comple
 			}
 			const name = asMatch[1];
 			if (isValidEsmExportName(name)) names.add(name);
-			else scanState.complete = false;
+			else if (name === "default" || name === "__esModule") {} else scanState.complete = false;
 		}
 	}
 	const namespaceReExportRegex = new RegExp(`export\\s+\\*\\s+as\\s+(${JS_IDENTIFIER_PATTERN})\\s+from\\s+['"][^'"]+['"]`, "gu");
@@ -1852,8 +1908,8 @@ function getDependencyNames(packageJson) {
 	}
 	return Array.from(names);
 }
-function isSharedSingletonConsumedByPeer(pkg) {
-	const shared = getNormalizeModuleFederationOptions()?.shared || {};
+function isSharedSingletonConsumedByPeer(pkg, options = getNormalizeModuleFederationOptions()) {
+	const shared = options?.shared || {};
 	if (Object.entries(shared).some(([key, item]) => key !== pkg && key.startsWith(`${pkg}/`) && item.shareConfig.singleton === true)) return true;
 	const sharedKeyByPackageName = /* @__PURE__ */ new Map();
 	Object.entries(shared).filter(([, item]) => item.shareConfig.singleton === true).forEach(([key]) => {
@@ -1874,8 +1930,7 @@ function isSharedSingletonConsumedByPeer(pkg) {
 	};
 	return Array.from(sharedKeyByPackageName.values()).some((sharedPkg) => sharedPkg !== pkg && reachesPkg(sharedPkg, new Set([sharedPkg])));
 }
-function isRemoteOnlyContainer() {
-	const options = getNormalizeModuleFederationOptions();
+function isRemoteOnlyContainer(options = getNormalizeModuleFederationOptions()) {
 	return Object.keys(options.exposes || {}).length > 0 && Object.keys(options.remotes || {}).length === 0;
 }
 function tryResolveImportFromPackageRoot(pkg, root) {
@@ -1898,13 +1953,42 @@ function getConcreteSharedImportSource(pkg, shareItem) {
 	}
 	return tryResolveImportFromPackageRoot(pkg, currentDir);
 }
-const preBuildCacheMap = {};
-const preBuildShareItemMap = {};
 const PREBUILD_TAG = "__prebuild__";
-const treeShakingProviderCacheMap = {};
-const materializedTreeShakingProviders = /* @__PURE__ */ new Set();
 const TREE_SHAKING_PROVIDER_TAG = "__treeShakingProvider__";
 const TREE_SHAKING_GRAPH_QUERY = "__mf_tree_shaking_graph__";
+const legacySharedVirtualModuleState = {
+	preBuildCacheMap: {},
+	preBuildShareItemMap: {},
+	treeShakingProviderCacheMap: {},
+	materializedTreeShakingProviders: /* @__PURE__ */ new Set(),
+	loadShareCacheMap: {}
+};
+const sharedVirtualModuleStates = /* @__PURE__ */ new WeakMap();
+let nextSharedVirtualModuleOwnerId = 1;
+function getSharedVirtualModuleState(options) {
+	if (!options) try {
+		const currentOptions = getNormalizeModuleFederationOptions();
+		return sharedVirtualModuleStates.get(currentOptions) ?? legacySharedVirtualModuleState;
+	} catch {
+		return legacySharedVirtualModuleState;
+	}
+	let state = sharedVirtualModuleStates.get(options);
+	if (!state) {
+		state = {
+			preBuildCacheMap: {},
+			preBuildShareItemMap: {},
+			treeShakingProviderCacheMap: {},
+			materializedTreeShakingProviders: /* @__PURE__ */ new Set(),
+			loadShareCacheMap: {},
+			ownerKey: `${options.internalName}__mf_owner__${nextSharedVirtualModuleOwnerId++}`
+		};
+		sharedVirtualModuleStates.set(options, state);
+	}
+	return state;
+}
+function createScopedSharedVirtualModule(pkg, tag, options) {
+	return new VirtualModule(pkg, tag, ".js", getSharedVirtualModuleState(options).ownerKey);
+}
 function getTreeShakingGraphToken(id) {
 	if (!id) return void 0;
 	const queryStart = id.indexOf("?");
@@ -1935,19 +2019,21 @@ function addTreeShakingGraphQuery(id, token) {
 	const hash = hashStart === -1 ? "" : cleanId.slice(hashStart);
 	return `${base}${base.includes("?") ? "&" : "?"}${TREE_SHAKING_GRAPH_QUERY}=${encodeURIComponent(token)}${hash}`;
 }
-function getConcreteTreeShakingExportUsage(pkg, shareItem) {
-	return getTreeShakingExportUsage(pkg, shareItem, shareItem?.name);
+function getConcreteTreeShakingExportUsage(pkg, shareItem, options) {
+	return getTreeShakingExportUsage(pkg, shareItem, shareItem?.name, options);
 }
-function getTreeShakingSharedProviderName(pkg) {
-	const { internalName, name } = getNormalizeModuleFederationOptions();
-	return `${internalName || name}__tree_shaking__${packageNameEncode(pkg)}`;
+function getTreeShakingSharedProviderName(pkg, options) {
+	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
+	return `${getSharedVirtualModuleState(options).ownerKey ?? resolvedOptions.internalName ?? resolvedOptions.name}__tree_shaking__${packageNameEncode(pkg)}`;
 }
-function getTreeShakingSharedProviderImportId(pkg) {
-	if (!treeShakingProviderCacheMap[pkg]) treeShakingProviderCacheMap[pkg] = new VirtualModule(pkg, TREE_SHAKING_PROVIDER_TAG, ".js");
+function getTreeShakingSharedProviderImportId(pkg, options) {
+	const { treeShakingProviderCacheMap } = getSharedVirtualModuleState(options);
+	if (!treeShakingProviderCacheMap[pkg]) treeShakingProviderCacheMap[pkg] = createScopedSharedVirtualModule(pkg, TREE_SHAKING_PROVIDER_TAG, options);
 	return treeShakingProviderCacheMap[pkg].getImportId();
 }
-function hasTreeShakingSharedProvider(pkg, shareItem) {
-	const usage = getConcreteTreeShakingExportUsage(pkg, shareItem);
+function hasTreeShakingSharedProvider(pkg, shareItem, options) {
+	const { materializedTreeShakingProviders } = getSharedVirtualModuleState(options);
+	const usage = getConcreteTreeShakingExportUsage(pkg, shareItem, options);
 	return materializedTreeShakingProviders.has(pkg) && usage?.kind === "exports";
 }
 /**
@@ -1959,8 +2045,9 @@ function hasTreeShakingSharedProvider(pkg, shareItem) {
 * perform its normal usedExports compatibility check and safely choose the full
 * provider when the optimized one is insufficient.
 */
-function writeTreeShakingSharedProvider(pkg, shareItem) {
-	const usage = getConcreteTreeShakingExportUsage(pkg, shareItem);
+function writeTreeShakingSharedProvider(pkg, shareItem, options) {
+	const { materializedTreeShakingProviders, treeShakingProviderCacheMap } = getSharedVirtualModuleState(options);
+	const usage = getConcreteTreeShakingExportUsage(pkg, shareItem, options);
 	if (usage?.kind !== "exports" || !usage.usedExports.length || shareItem?.shareConfig.import === false) {
 		materializedTreeShakingProviders.delete(pkg);
 		return;
@@ -1972,7 +2059,7 @@ function writeTreeShakingSharedProvider(pkg, shareItem) {
 		mfWarn(`Tree-shaking shared dependency "${pkg}" was disabled because export "${unsupportedExport}" cannot be represented by the generated ESM provider.`);
 		return;
 	}
-	const provider = treeShakingProviderCacheMap[pkg] || (treeShakingProviderCacheMap[pkg] = new VirtualModule(pkg, "__treeShakingProvider__", ".js"));
+	const provider = treeShakingProviderCacheMap[pkg] || (treeShakingProviderCacheMap[pkg] = createScopedSharedVirtualModule(pkg, "__treeShakingProvider__", options));
 	const optimizedImportSource = addTreeShakingGraphQuery(getConcreteSharedImportSource(pkg, shareItem) || pkg, pkg);
 	const namedExports = usedExports.filter((name) => name !== "default");
 	const namedImports = namedExports.map((name, index) => `${name} as __mfTreeShaken_${index}`).join(", ");
@@ -1994,11 +2081,12 @@ export default { get, init };
 `, true);
 	materializedTreeShakingProviders.add(pkg);
 }
-function writePreBuildLibPath(pkg, shareItem) {
-	if (!preBuildCacheMap[pkg]) preBuildCacheMap[pkg] = new VirtualModule(pkg, PREBUILD_TAG, ".js");
+function writePreBuildLibPath(pkg, shareItem, options) {
+	const { preBuildCacheMap, preBuildShareItemMap } = getSharedVirtualModuleState(options);
+	if (!preBuildCacheMap[pkg]) preBuildCacheMap[pkg] = createScopedSharedVirtualModule(pkg, PREBUILD_TAG, options);
 	preBuildShareItemMap[pkg] = shareItem;
 	const importSource = getConcreteSharedImportSource(pkg, shareItem) || pkg;
-	writeTreeShakingSharedProvider(pkg, shareItem);
+	writeTreeShakingSharedProvider(pkg, shareItem, options);
 	if (pkg === "react/compiler-runtime") {
 		const reactCacheDescriptor = getSharedCacheDescriptorLiteral("react", shareItem ?? {
 			name: "react",
@@ -2067,36 +2155,36 @@ function writePreBuildLibPath(pkg, shareItem) {
   `, true);
 }
 /** Re-render already materialized wrappers after import analysis discovers exports. */
-function refreshTreeShakingModules() {
+function refreshTreeShakingModules(options) {
+	const { preBuildShareItemMap } = getSharedVirtualModuleState(options);
 	for (const [pkg, shareItem] of Object.entries(preBuildShareItemMap)) {
 		if (!shareItem?.shareConfig.treeShaking) continue;
-		writePreBuildLibPath(pkg, shareItem);
-		writeLoadShareModule(pkg, shareItem, "build", false);
+		writePreBuildLibPath(pkg, shareItem, options);
+		writeLoadShareModule(pkg, shareItem, "build", false, options);
 	}
 }
-function getPreBuildLibImportId(pkg) {
-	if (!preBuildCacheMap[pkg]) preBuildCacheMap[pkg] = new VirtualModule(pkg, PREBUILD_TAG, ".js");
+function getPreBuildLibImportId(pkg, options) {
+	const { preBuildCacheMap } = getSharedVirtualModuleState(options);
+	if (!preBuildCacheMap[pkg]) preBuildCacheMap[pkg] = createScopedSharedVirtualModule(pkg, PREBUILD_TAG, options);
 	return preBuildCacheMap[pkg].getImportId();
 }
-function getPreBuildShareItem(pkg) {
-	return preBuildShareItemMap[pkg];
+function getPreBuildShareItem(pkg, options) {
+	return getSharedVirtualModuleState(options).preBuildShareItemMap[pkg];
 }
-function getSharedImportSource(pkg, shareItem) {
-	return getConcreteSharedImportSource(pkg, shareItem) || getPreBuildLibImportId(pkg);
+function getSharedImportSource(pkg, shareItem, options) {
+	return getConcreteSharedImportSource(pkg, shareItem) || getPreBuildLibImportId(pkg, options);
 }
 const LOAD_SHARE_TAG = "__loadShare__";
-const loadShareCacheMap = {};
-function getLoadShareImportId(pkg, _isRolldown) {
-	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = new VirtualModule(pkg, LOAD_SHARE_TAG, ".js");
+function getLoadShareImportId(pkg, _isRolldown, options) {
+	const { loadShareCacheMap } = getSharedVirtualModuleState(options);
+	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = createScopedSharedVirtualModule(pkg, LOAD_SHARE_TAG, options);
 	return loadShareCacheMap[pkg].getImportId();
 }
-function getLoadShareModulePath(pkg, isRolldown) {
-	if (!loadShareCacheMap[pkg]) getLoadShareImportId(pkg, isRolldown);
+function getLoadShareModulePath(pkg, isRolldown, options) {
+	const { loadShareCacheMap } = getSharedVirtualModuleState(options);
+	if (!loadShareCacheMap[pkg]) getLoadShareImportId(pkg, isRolldown, options);
 	return loadShareCacheMap[pkg].getImportId();
 }
-function toViteOptimizedDepVirtualId(id) {
-	return toViteEncodedId(id);
-}
 function getCachedLoadSharePkg(id) {
 	if (!id.includes("__loadShare__")) return;
 	const normalized = normalizeVirtualModuleId(id);
@@ -2114,8 +2202,8 @@ function materializeCachedLoadShareModule(options) {
 	const key = options.findSharedKey(pkg, options.shared);
 	if (!key) return;
 	const shareItem = options.shared[key];
-	writeLoadShareModule(pkg, shareItem, options.command, options.isRolldown);
-	if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(pkg, shareItem);
+	writeLoadShareModule(pkg, shareItem, options.command, options.isRolldown, options.federationOptions);
+	if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(pkg, shareItem, options.federationOptions);
 	options.addUsedShares(pkg);
 	options.writeLocalSharedImportMap();
 }
@@ -2242,12 +2330,15 @@ const normalizeLocalShareModuleCode = `const __mfNormalizeShareModule = (mod) =>
         ? Object.assign({}, normalized)
         : normalized;
     };`;
-function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
-	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = new VirtualModule(pkg, LOAD_SHARE_TAG, ".js");
+function writeLoadShareModule(pkg, shareItem, command, _isRolldown, options) {
+	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
+	const { loadShareCacheMap } = getSharedVirtualModuleState(options);
+	if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = createScopedSharedVirtualModule(pkg, LOAD_SHARE_TAG, options);
 	let importLine = getRuntimeModuleCacheBootstrapCode();
 	const cacheDescriptor = getSharedCacheDescriptorLiteral(pkg, shareItem);
-	const cacheOwner = JSON.stringify(getNormalizeModuleFederationOptions().name);
-	const treeShakingConsumer = command === "build" && shareItem.shareConfig.treeShaking ? getNormalizeModuleFederationOptions().name : void 0;
+	const cacheOwner = JSON.stringify(resolvedOptions.name);
+	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 namedExports = detectedNamedExports ?? [];
@@ -2258,7 +2349,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
 			exportLine = generateDeferredHostProvidedExports([], pkg, cacheDescriptor, treeShakingConsumer);
 		}
 		loadShareCacheMap[pkg].writeSync(`
-    ${getRuntimeInitPromiseBootstrapCode()}
+    ${getRuntimeInitPromiseBootstrapCode(false, runtimeInitOwnerImportId)}
     ${importLine}
     ${sharedCacheHelperCode}
     ${exportLine}
@@ -2266,7 +2357,7 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
 		return;
 	}
 	const concreteSharedImportSource = getConcreteSharedImportSource(pkg, shareItem);
-	const sharedImportSource = concreteSharedImportSource || getPreBuildLibImportId(pkg);
+	const sharedImportSource = concreteSharedImportSource || getPreBuildLibImportId(pkg, options);
 	const devImportSource = concreteSharedImportSource || pkg;
 	const localProviderPath = getLocalProviderImportPath(pkg);
 	const coherentLocalSource = concreteSharedImportSource || localProviderPath || devImportSource;
@@ -2278,20 +2369,20 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
 	const hasCompleteExportCoverage = detectedNamedExports !== void 0;
 	const isWorkspaceSingleton = isWorkspacePackage && shareItem.shareConfig.singleton === true;
 	const isDefaultShareScope = shareItem.scope === void 0 || shareItem.scope === "default" || Array.isArray(shareItem.scope) && shareItem.scope[0] === "default";
-	const usesDeferredSingletonFallback = hasCompleteExportCoverage && (isWorkspaceSingleton || command !== "build" && isRemoteOnlyContainer() && shareItem.shareConfig.singleton === true || command === "build" && isRemoteOnlyContainer() && shareItem.shareConfig.singleton === true && !isDefaultShareScope);
-	const servesRemoteSingletonFallback = command !== "build" && isRemoteOnlyContainer() && shareItem.shareConfig.singleton === true;
-	const isConsumedByPeerSingleton = isSharedSingletonConsumedByPeer(pkg);
-	const usesEntryInjectedRemoteFallback = hasCompleteExportCoverage && command !== "build" && !isWorkspaceSingleton && isRemoteOnlyContainer() && shareItem.shareConfig.singleton === true && getNormalizeModuleFederationOptions().hostInitInjectLocation === "entry" && isConsumedByPeerSingleton;
+	const usesDeferredSingletonFallback = hasCompleteExportCoverage && (isWorkspaceSingleton || command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true || command === "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true && !isDefaultShareScope);
+	const servesRemoteSingletonFallback = command !== "build" && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true;
+	const isConsumedByPeerSingleton = isSharedSingletonConsumedByPeer(pkg, resolvedOptions);
+	const usesEntryInjectedRemoteFallback = hasCompleteExportCoverage && command !== "build" && !isWorkspaceSingleton && isRemoteOnlyContainer(resolvedOptions) && shareItem.shareConfig.singleton === true && resolvedOptions.hostInitInjectLocation === "entry" && isConsumedByPeerSingleton;
 	const usesEagerWorkspaceFallback = hasCompleteExportCoverage && isWorkspaceSingleton && isConsumedByPeerSingleton;
 	const usesDeferredTreeShakingFallback = hasCompleteExportCoverage && Boolean(treeShakingConsumer);
 	let exportLine;
 	let initBlock = "";
 	if (usesDeferredTreeShakingFallback) {
-		importLine = `${getRuntimeInitPromiseBootstrapCode()}\n    ${importLine}`;
+		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);
 	else if (usesDeferredSingletonFallback) {
-		importLine = `${getRuntimeInitPromiseBootstrapCode()}\n    ${importLine}`;
+		importLine = `${getRuntimeInitPromiseBootstrapCode(false, runtimeInitOwnerImportId)}\n    ${importLine}`;
 		exportLine = generateLazyWorkspaceSingletonExports(namedExports, lazyLocalFallbackSource, cacheDescriptor, cacheOwner, treeShakingConsumer, command !== "build" && (isWorkspaceSingleton || isWorkspacePackage || servesRemoteSingletonFallback));
 	} else if (detectedNamedExports === void 0) {
 		exportLine = `const __mfDefaultExport = (() => {
@@ -2380,74 +2471,98 @@ function writeLoadShareModule(pkg, shareItem, command, _isRolldown) {
 //#endregion
 //#region src/virtualModules/virtualRemoteEntry.ts
 let usedShares = /* @__PURE__ */ new Set();
-function getUsedShares() {
+const usedSharesByOptions = /* @__PURE__ */ new WeakMap();
+function getScopedUsedShares(options) {
+	let scoped = usedSharesByOptions.get(options);
+	if (!scoped) {
+		scoped = /* @__PURE__ */ new Set();
+		usedSharesByOptions.set(options, scoped);
+	}
+	return scoped;
+}
+function getUsedShares(options) {
+	if (options) return getScopedUsedShares(options);
 	return usedShares;
 }
-function addUsedShares(pkg) {
+function addUsedShares(pkg, options) {
 	usedShares.add(pkg);
+	if (options) getScopedUsedShares(options).add(pkg);
 }
 const LOCAL_SHARED_IMPORT_MAP_ID = "virtual:mf-localSharedImportMap";
-function getLocalSharedImportMapPath() {
-	const { internalName, name } = getNormalizeModuleFederationOptions();
-	return `${LOCAL_SHARED_IMPORT_MAP_ID}:${packageNameEncode(internalName || name)}`;
+const localOwnerIds = /* @__PURE__ */ new WeakMap();
+let nextLocalOwnerId = 1;
+function getLocalOwnerKey(options) {
+	let ownerId = localOwnerIds.get(options);
+	if (!ownerId) {
+		ownerId = nextLocalOwnerId++;
+		localOwnerIds.set(options, ownerId);
+	}
+	return `${options.internalName}__mf_owner__${ownerId}`;
 }
-function getResolvedLocalSharedImportMapId() {
-	return `\0${getLocalSharedImportMapPath()}`;
+function getLocalSharedImportMapPath(options) {
+	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
+	return `${LOCAL_SHARED_IMPORT_MAP_ID}:${packageNameEncode(options ? getLocalOwnerKey(resolvedOptions) : resolvedOptions.internalName || resolvedOptions.name)}`;
+}
+function getResolvedLocalSharedImportMapId(options) {
+	return `\0${getLocalSharedImportMapPath(options)}`;
 }
 let invalidateLocalSharedImportMap;
-function setLocalSharedImportMapInvalidator(invalidator) {
-	invalidateLocalSharedImportMap = invalidator;
+const localSharedImportMapInvalidators = /* @__PURE__ */ new WeakMap();
+function setLocalSharedImportMapInvalidator(invalidator, options) {
+	if (!options) invalidateLocalSharedImportMap = invalidator;
+	else if (invalidator) localSharedImportMapInvalidators.set(options, invalidator);
+	else localSharedImportMapInvalidators.delete(options);
 }
-function writeLocalSharedImportMap() {
-	invalidateLocalSharedImportMap?.();
+function writeLocalSharedImportMap(options) {
+	(options ? localSharedImportMapInvalidators.get(options) : invalidateLocalSharedImportMap)?.();
 }
 function shouldUseDirectReactImport() {
 	const isVinext = hasPackageDependency("vinext");
 	const isAstro = hasPackageDependency("astro");
 	return isVinext || isAstro;
 }
-function getLocalSharedPackagePath(pkg, shareItem) {
+function getLocalSharedPackagePath(pkg, shareItem, options) {
 	if (shouldUseDirectReactImport() && pkg === "react") return "react";
-	return getConcreteSharedImportSource(pkg, shareItem) || getLocalProviderImportPath(pkg) || getSharedImportSource(pkg, shareItem);
+	return getConcreteSharedImportSource(pkg, shareItem) || getLocalProviderImportPath(pkg) || getSharedImportSource(pkg, shareItem, options);
 }
 function getDirectSharedCacheSeedImportPath(pkg, shareItem) {
 	return getConcreteSharedImportSource(pkg, shareItem) || getProjectResolvedImportPath(pkg) || getLocalProviderImportPath(pkg) || pkg;
 }
-function generateLocalSharedImportMap() {
+function generateLocalSharedImportMap(options) {
+	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
 	const useDirectReactImport = shouldUseDirectReactImport();
-	const options = getNormalizeModuleFederationOptions();
-	const orderedShares = getOrderedUsedShares();
+	const orderedShares = getOrderedUsedShares(options);
 	return `
     import {loadShare} from "@module-federation/runtime";
     ${orderedShares.map((pkg, index) => {
-		const shareItem = getNormalizeShareItem(pkg);
+		const shareItem = getNormalizeShareItem(pkg, resolvedOptions);
 		if (!shareItem?.shareConfig.eager || shareItem.shareConfig.import === false) return "";
-		return `import * as __mfEagerShare_${index} from ${JSON.stringify(getLocalSharedPackagePath(pkg, shareItem))};`;
+		return `import * as __mfEagerShare_${index} from ${JSON.stringify(getLocalSharedPackagePath(pkg, shareItem, options))};`;
 	}).filter(Boolean).join("\n")}
     const importMap = {
       ${orderedShares.map((pkg, index) => {
-		const shareItem = getNormalizeShareItem(pkg);
+		const shareItem = getNormalizeShareItem(pkg, resolvedOptions);
 		return `
         ${JSON.stringify(pkg)}: async () => {
           ${shareItem?.shareConfig.import === false ? `throw new Error(\`[Module Federation] Shared module '\${${JSON.stringify(pkg)}}' must be provided by host\`);` : shareItem?.shareConfig.eager ? `let pkg = __mfEagerShare_${index};
-            return pkg;` : `let pkg = await import(${JSON.stringify(getLocalSharedPackagePath(pkg, shareItem))});
+            return pkg;` : `let pkg = await import(${JSON.stringify(getLocalSharedPackagePath(pkg, shareItem, options))});
             return pkg;`}
         }
       `;
 	}).join(",")}
     }
       const usedShared = {
-      ${getOrderedUsedShares().map((key) => {
-		const shareItem = getNormalizeShareItem(key);
+      ${getOrderedUsedShares(options).map((key) => {
+		const shareItem = getNormalizeShareItem(key, resolvedOptions);
 		if (!shareItem) return null;
 		const detectedNamedExports = getSharedNamedExports(key, shareItem);
 		const canLiveRebind = shareItem.shareConfig.import === false || detectedNamedExports !== void 0;
 		const treeShakingConfig = canLiveRebind ? shareItem.shareConfig.treeShaking : void 0;
-		const treeShakingUsage = treeShakingConfig ? getTreeShakingExportUsage(key, shareItem, shareItem.name) : void 0;
+		const treeShakingUsage = treeShakingConfig ? getTreeShakingExportUsage(key, shareItem, shareItem.name, options) : void 0;
 		const treeShakingProviderExports = treeShakingUsage?.kind === "exports" ? treeShakingUsage.usedExports : [];
-		const treeShakingUsedExports = options.injectTreeShakingUsedExports === false ? treeShakingConfig?.usedExports || [] : treeShakingProviderExports;
-		const disableRuntimeInference = treeShakingConfig?.mode === "runtime-infer" && options.injectTreeShakingUsedExports === false;
-		const treeShakingProviderImportId = treeShakingConfig && !disableRuntimeInference && hasTreeShakingSharedProvider(key, shareItem) ? getTreeShakingSharedProviderImportId(key) : void 0;
+		const treeShakingUsedExports = resolvedOptions.injectTreeShakingUsedExports === false ? treeShakingConfig?.usedExports || [] : treeShakingProviderExports;
+		const disableRuntimeInference = treeShakingConfig?.mode === "runtime-infer" && resolvedOptions.injectTreeShakingUsedExports === false;
+		const treeShakingProviderImportId = treeShakingConfig && !disableRuntimeInference && hasTreeShakingSharedProvider(key, shareItem, options) ? getTreeShakingSharedProviderImportId(key, options) : void 0;
 		const treeShakingStatus = treeShakingUsage?.kind === "full" || disableRuntimeInference || treeShakingConfig?.mode === "runtime-infer" && !treeShakingProviderImportId && shareItem.shareConfig.import !== false ? 0 : 1;
 		return `
           ${JSON.stringify(key)}: {
@@ -2456,7 +2571,7 @@ function generateLocalSharedImportMap() {
             scope: [${JSON.stringify(shareItem.scope)}],
             loaded: false,
             eager: ${Boolean(shareItem.shareConfig.eager)},
-            from: ${JSON.stringify(options.name)},
+            from: ${JSON.stringify(resolvedOptions.name)},
             canLiveRebind: ${canLiveRebind},
             async get () {
               if (${shareItem.shareConfig.import === false}) {
@@ -2501,14 +2616,14 @@ function generateLocalSharedImportMap() {
         `;
 	}).filter((x) => x !== null).join(",")}
     }
-      const usedRemotes = [${Object.keys(getUsedRemotesMap()).map((key) => {
-		const remote = options.remotes[key];
+      const usedRemotes = [${Object.keys(getUsedRemotesMap(options)).map((key) => {
+		const remote = resolvedOptions.remotes[key];
 		if (!remote) return null;
 		return `
                 {
-                  alias: ${JSON.stringify(key)},
+                  alias: ${JSON.stringify(getRuntimeRemoteAlias(key, options))},
                   entryGlobalName: ${JSON.stringify(remote.entryGlobalName)},
-                  name: ${JSON.stringify(remote.name)},
+                  name: ${JSON.stringify(options ? getRuntimeRemoteAlias(key, options) : remote.name)},
                   type: ${JSON.stringify(remote.type)},
                   entry: ${JSON.stringify(remote.entry)},
                   shareScope: ${JSON.stringify(remote.shareScope ?? "default")},
@@ -2522,16 +2637,12 @@ function generateLocalSharedImportMap() {
       }
       `;
 }
-function getOrderedUsedShares() {
-	const shares = new Set(getUsedShares());
-	try {
-		Object.keys(getNormalizeModuleFederationOptions().shared).forEach((pkg) => {
-			if (!pkg.endsWith("/")) {
-				shares.add(pkg);
-				return;
-			}
-		});
-	} catch {}
+function getOrderedUsedShares(options) {
+	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
+	const shares = new Set(getUsedShares(options));
+	Object.keys(resolvedOptions.shared).forEach((pkg) => {
+		if (!pkg.endsWith("/")) shares.add(pkg);
+	});
 	return orderSharedDependenciesFirst(Array.from(shares).sort((a, b) => {
 		const priority = (pkg) => pkg === "react" ? 0 : pkg === "react-dom" ? 1 : pkg.startsWith("react/") ? 2 : 3;
 		return priority(a) - priority(b) || a.localeCompare(b);
@@ -2585,15 +2696,15 @@ function orderSharedDependenciesFirst(sharedPackages) {
 	sharedPackages.forEach(visit);
 	return ordered;
 }
-function getShareItemForPreload(pkg) {
-	const shared = getNormalizeModuleFederationOptions().shared;
+function getShareItemForPreload(pkg, options = getNormalizeModuleFederationOptions()) {
+	const shared = options.shared;
 	const wildcardKey = `${pkg.startsWith("@") ? pkg.split("/").slice(0, 2).join("/") : pkg.split("/")[0]}/`;
-	if (isExplicitSharedKey(pkg)) return shared[pkg];
-	if (isExplicitSharedKey(wildcardKey)) return shared[wildcardKey];
+	if (isExplicitSharedKey(pkg, options)) return shared[pkg];
+	if (isExplicitSharedKey(wildcardKey, options)) return shared[wildcardKey];
 }
-function generateSharedCacheSeedItem(pkg, shareItem, importPath) {
+function generateSharedCacheSeedItem(pkg, shareItem, importPath, options = getNormalizeModuleFederationOptions()) {
 	const cacheDescriptor = getSharedCacheDescriptor(pkg, shareItem);
-	const cacheOwner = getNormalizeModuleFederationOptions().name;
+	const cacheOwner = options.name;
 	return `if (__mfReadSharedCache(__mfModuleCache.share, ${JSON.stringify(cacheDescriptor)}) === undefined) {
         const mod = await import(${JSON.stringify(importPath)});
         ${normalizeRuntimeShareCode}
@@ -2886,10 +2997,11 @@ function getBrowserImportPath(importPath) {
 	if (/^(?:[a-zA-Z]:[\\/]|\/)/.test(importPath) && !importPath.startsWith("/@")) return `/@fs/${importPath}`;
 	return importPath;
 }
-function getHostAutoInitSharedSeedItems() {
-	return getOrderedUsedShares().map((pkg) => ({
+function getHostAutoInitSharedSeedItems(options) {
+	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
+	return getOrderedUsedShares(options).map((pkg) => ({
 		pkg,
-		shareItem: getShareItemForPreload(pkg)
+		shareItem: getShareItemForPreload(pkg, resolvedOptions)
 	})).filter(({ shareItem }) => shareItem?.shareConfig?.import === false).sort((a, b) => {
 		const priority = (pkg) => pkg === "vue" ? 0 : pkg === "pinia" ? 1 : 2;
 		const aIsLocal = !!getLocalProviderImportPath(a.pkg);
@@ -2897,11 +3009,12 @@ function getHostAutoInitSharedSeedItems() {
 		return priority(a.pkg) - priority(b.pkg) || Number(aIsLocal) - Number(bIsLocal) || a.pkg.localeCompare(b.pkg);
 	});
 }
-function generateHostAutoInitSharedCacheSeedCode(command = "build") {
+function generateHostAutoInitSharedCacheSeedCode(command = "build", options) {
 	if (command === "build") return "";
-	return getHostAutoInitSharedSeedItems().map(({ pkg, shareItem }) => {
+	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
+	return getHostAutoInitSharedSeedItems(options).map(({ pkg, shareItem }) => {
 		if (!shareItem) return null;
-		return generateSharedCacheSeedItem(pkg, shareItem, getBrowserImportPath(getDirectSharedCacheSeedImportPath(pkg, shareItem)));
+		return generateSharedCacheSeedItem(pkg, shareItem, getBrowserImportPath(getDirectSharedCacheSeedImportPath(pkg, shareItem)), resolvedOptions);
 	}).filter((item) => item !== null).join("\n");
 }
 const REMOTE_ENTRY_ID = "virtual:mf-REMOTE_ENTRY_ID";
@@ -3126,10 +3239,10 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
     globalThis.__VUE_HMR_RUNTIME__ = { createRecord() {}, rerender() {}, reload() {} };
   }
   import {${runtimeImports}} from "@module-federation/runtime";
-  ${hasEagerShared ? `import * as __mfLocalSharedImportMap from "${getLocalSharedImportMapPath()}";` : ""}
+  ${hasEagerShared ? `import * as __mfLocalSharedImportMap from "${getLocalSharedImportMapPath(options)}";` : ""}
   ${runtimeHelperImports.length ? `import {${runtimeHelperImports.join(", ")}} from "@module-federation/runtime/helpers";` : ""}
   ${pluginImportNames.filter((item) => !isSsrOnlyPlugin(item[1])).map((item) => item[1]).join("\n")}
-  ${command === "build" ? getRuntimeInitResolveBootstrapCode() : getRuntimeInitBootstrapCode() + "\n  const { initResolve } = globalThis[globalKey];"}
+  ${command === "build" ? getRuntimeInitResolveBootstrapCode(false, options ? getRuntimeInitStatusImportId(options) : void 0) : getRuntimeInitBootstrapCode(false, options ? getRuntimeInitStatusImportId(options) : void 0) + "\n  const { initResolve } = globalThis[globalKey];"}
   ${getRuntimeModuleCacheBootstrapCode()}
   const initTokens = {}
   const shareScopeNames = Array.isArray(${JSON.stringify(options.shareScope)}) ? ${JSON.stringify(options.shareScope)} : [${JSON.stringify(options.shareScope)}]
@@ -3163,7 +3276,7 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   async function getLocalSharedImportMap() {
     ${hasEagerShared ? "return __mfLocalSharedImportMap;" : ""}
     ${hasEagerShared ? "" : `if (!localSharedImportMapPromise) {
-      localSharedImportMapPromise = retrySharedInit(() => import("${getLocalSharedImportMapPath()}"))
+      localSharedImportMapPromise = retrySharedInit(() => import("${getLocalSharedImportMapPath(options)}"))
         .catch((e) => { localSharedImportMapPromise = undefined; throw e; });
     }
     return localSharedImportMapPromise`}
@@ -3859,13 +3972,35 @@ function generateRemoteEntry(options, virtualExposesId = getVirtualExposesId(opt
   }
   `;
 }
-const hostAutoInitModule = new VirtualModule("hostAutoInit", "__H_A_I__");
-let currentHostAutoInitRemoteEntryId = REMOTE_ENTRY_ID;
-let currentHostAutoInitCommand = "build";
-function generateHostAutoInitCode(remoteEntryImport, _command = "build") {
-	const shouldPreloadShares = getNormalizeModuleFederationOptions().shareStrategy !== "loaded-first";
-	const hostInitShareOrder = JSON.stringify(getOrderedUsedShares());
-	const cacheOwner = JSON.stringify(getNormalizeModuleFederationOptions().name);
+/**
+* Inject entry file, automatically init when used as host,
+* and will not inject remoteEntry
+*/
+const HOST_AUTO_INIT_TAG = "__H_A_I__";
+const hostAutoInitStates = /* @__PURE__ */ new WeakMap();
+const legacyHostAutoInitState = {
+	module: new VirtualModule("hostAutoInit", HOST_AUTO_INIT_TAG),
+	remoteEntryId: REMOTE_ENTRY_ID,
+	command: "build"
+};
+function getHostAutoInitState(options) {
+	if (!options) return legacyHostAutoInitState;
+	let state = hostAutoInitStates.get(options);
+	if (!state) {
+		state = {
+			module: new VirtualModule("hostAutoInit", HOST_AUTO_INIT_TAG, "", getLocalOwnerKey(options)),
+			remoteEntryId: REMOTE_ENTRY_ID,
+			command: "build"
+		};
+		hostAutoInitStates.set(options, state);
+	}
+	return state;
+}
+function generateHostAutoInitCode(remoteEntryImport, _command = "build", options) {
+	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
+	const shouldPreloadShares = resolvedOptions.shareStrategy !== "loaded-first";
+	const hostInitShareOrder = JSON.stringify(getOrderedUsedShares(options));
+	const cacheOwner = JSON.stringify(resolvedOptions.name);
 	return `
     ${getRuntimeModuleCacheBootstrapCode()}
     let hostInitPromise;
@@ -3873,10 +4008,10 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build") {
       if (!hostInitPromise) {
         hostInitPromise = (async () => {
           ${sharedCacheHelperCode}
-          ${generateHostAutoInitSharedCacheSeedCode(_command)}
+          ${generateHostAutoInitSharedCacheSeedCode(_command, options)}
           const remoteEntry = await import(${remoteEntryImport});
           const runtime = await remoteEntry.init();
-          const {usedShared} = await import("${getLocalSharedImportMapPath()}");
+          const {usedShared} = await import("${getLocalSharedImportMapPath(options)}");
           ${normalizeRuntimeShareCode}
           ${shouldPreloadShares ? `
           const __mfHostInitShareOrder = ${hostInitShareOrder}
@@ -3918,46 +4053,82 @@ function generateHostAutoInitCode(remoteEntryImport, _command = "build") {
     export { initHost, hostInitPromise };
     `;
 }
-function writeHostAutoInit(remoteEntryId = REMOTE_ENTRY_ID, command = "build") {
-	currentHostAutoInitRemoteEntryId = remoteEntryId;
-	currentHostAutoInitCommand = command;
-	hostAutoInitModule.writeSync(generateHostAutoInitCode(JSON.stringify(remoteEntryId), command), true);
+function writeHostAutoInit(remoteEntryId = REMOTE_ENTRY_ID, command = "build", options) {
+	const state = getHostAutoInitState(options);
+	state.remoteEntryId = remoteEntryId;
+	state.command = command;
+	state.module.writeSync(generateHostAutoInitCode(JSON.stringify(remoteEntryId), command, options), true);
 }
-function refreshHostAutoInit() {
+function refreshHostAutoInit(options) {
 	try {
-		writeHostAutoInit(currentHostAutoInitRemoteEntryId, currentHostAutoInitCommand);
+		const state = getHostAutoInitState(options);
+		writeHostAutoInit(state.remoteEntryId, state.command, options);
 	} catch {}
 }
-function getHostAutoInitImportId() {
-	return hostAutoInitModule.getImportId();
+function getHostAutoInitImportId(options) {
+	return getHostAutoInitState(options).module.getImportId();
 }
-function getHostAutoInitPath() {
-	return hostAutoInitModule.getImportId();
+function getHostAutoInitPath(options) {
+	return getHostAutoInitState(options).module.getImportId();
 }
 //#endregion
 //#region src/virtualModules/virtualRemotes.ts
-const cacheRemoteMap = {};
+const cacheRemoteMap = /* @__PURE__ */ new WeakMap();
+const remoteOptionsIds = /* @__PURE__ */ new WeakMap();
+let nextRemoteOptionsId = 1;
+function getRemoteOptionsId(options) {
+	let id = remoteOptionsIds.get(options);
+	if (id === void 0) {
+		id = nextRemoteOptionsId++;
+		remoteOptionsIds.set(options, id);
+	}
+	return id;
+}
 const LOAD_REMOTE_TAG = "__loadRemote__";
-function getRemoteVirtualModule(remote, command, enableSsrInit = false, consumer = "unified") {
-	const { shareStrategy } = getNormalizeModuleFederationOptions();
-	const cacheKey = `${remote}__${command}__${shareStrategy}__${consumer}__${enableSsrInit ? "ssr-init" : "no-ssr-init"}`;
-	if (!cacheRemoteMap[cacheKey]) {
-		cacheRemoteMap[cacheKey] = new VirtualModule(consumer === "unified" ? remote : `${remote}__mf_consumer__${consumer}`, LOAD_REMOTE_TAG, ".js");
-		cacheRemoteMap[cacheKey].writeSync(generateRemotes(remote, command, enableSsrInit, consumer));
+function getRemoteVirtualModule(remote, command, enableSsrInit = false, consumer = "unified", options = getNormalizeModuleFederationOptions()) {
+	let instanceCache = cacheRemoteMap.get(options);
+	if (!instanceCache) {
+		instanceCache = /* @__PURE__ */ new Map();
+		cacheRemoteMap.set(options, instanceCache);
+	}
+	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);
+		virtual.writeSync(generateRemotes(remote, command, enableSsrInit, consumer, options));
+		instanceCache.set(cacheKey, virtual);
 	}
-	return cacheRemoteMap[cacheKey];
+	return instanceCache.get(cacheKey);
 }
 const usedRemotesMap = {};
-function addUsedRemote(remoteKey, remoteModule) {
-	if (!usedRemotesMap[remoteKey]) usedRemotesMap[remoteKey] = /* @__PURE__ */ new Set();
-	usedRemotesMap[remoteKey].add(remoteModule);
+const usedRemotesByOptions = /* @__PURE__ */ new WeakMap();
+function getScopedUsedRemotesMap(options) {
+	let scoped = usedRemotesByOptions.get(options);
+	if (!scoped) {
+		scoped = {};
+		usedRemotesByOptions.set(options, scoped);
+	}
+	return scoped;
+}
+function recordUsedRemote(map, remoteKey, remoteModule) {
+	if (!map[remoteKey]) map[remoteKey] = /* @__PURE__ */ new Set();
+	map[remoteKey].add(remoteModule);
+}
+function addUsedRemote(remoteKey, remoteModule, options) {
+	recordUsedRemote(usedRemotesMap, remoteKey, remoteModule);
+	if (options) recordUsedRemote(getScopedUsedRemotesMap(options), remoteKey, remoteModule);
 }
-function getUsedRemotesMap() {
+function getUsedRemotesMap(options) {
+	if (options) return getScopedUsedRemotesMap(options);
 	return usedRemotesMap;
 }
 function getRemoteAliasFromId(id, remotes) {
 	return Object.keys(remotes).filter((name) => id === name || id.startsWith(name + "/")).sort((a, b) => b.length - a.length)[0];
 }
+function getRuntimeRemoteId(id, remotes, options) {
+	const alias = getRemoteAliasFromId(id, remotes);
+	if (!alias) return id;
+	return `${getRuntimeRemoteAlias(alias, options)}${id.slice(alias.length)}`;
+}
 function resolveRemoteInitMode(shareStrategy, consumer) {
 	if (shareStrategy !== "loaded-first") return "eager";
 	if (consumer === "server") return "loaded-first-ssr";
@@ -4016,7 +4187,7 @@ function getRemoteModuleRuntimeHelpers() {
       return exportModule;
     }`;
 }
-function getDeferredProxyHelper(remoteId) {
+function getDeferredProxyHelper(remoteCacheKey) {
 	return `
     function __mfCreateDeferredRemoteProxy() {
       let pendingPromise;
@@ -4024,7 +4195,7 @@ function getDeferredProxyHelper(remoteId) {
         pendingPromise ||= __mfStartRemoteLoad();
         return pendingPromise;
       };
-      const getModule = () => __mfModuleCache.remote[${JSON.stringify(remoteId)}];
+      const getModule = () => __mfModuleCache.remote[${JSON.stringify(remoteCacheKey)}];
       const proxyTarget = function (...args) {
         pendingPromise ||= __mfStartRemoteLoad();
         const mod = getModule();
@@ -4122,30 +4293,39 @@ ${deferRemoteLoad ? getLazyRemotePendingExport() : getEagerRemotePendingExport()
 ${command === "serve" && consumer === "server" ? getServerThenExport() : ""}
 export { __mfDefaultExport as default };`;
 }
-function generateRemotes(id, command, enableSsrInit = false, consumer = "unified") {
-	const options = getNormalizeModuleFederationOptions();
-	const isLoadedFirst = options.shareStrategy === "loaded-first";
-	const initMode = resolveRemoteInitMode(options.shareStrategy, consumer);
+function generateRemotes(id, command, enableSsrInit = false, consumer = "unified", options) {
+	const resolvedOptions = options ?? getNormalizeModuleFederationOptions();
+	const isLoadedFirst = resolvedOptions.shareStrategy === "loaded-first";
+	const initMode = resolveRemoteInitMode(resolvedOptions.shareStrategy, consumer);
 	const deferRemoteLoad = shouldDeferRemoteLoad(initMode);
-	const remoteAlias = getRemoteAliasFromId(id, options.remotes);
-	const remote = remoteAlias ? options.remotes[remoteAlias] : void 0;
+	const remoteAlias = getRemoteAliasFromId(id, resolvedOptions.remotes);
+	const remote = remoteAlias ? resolvedOptions.remotes[remoteAlias] : void 0;
+	const runtimeRemoteAlias = remoteAlias ? getRuntimeRemoteAlias(remoteAlias, options) : void 0;
+	const runtimeRemoteId = getRuntimeRemoteId(id, resolvedOptions.remotes, options);
 	const registerRemoteCode = isLoadedFirst && remote ? `runtime.registerRemotes([${JSON.stringify({
 		entryGlobalName: remote.entryGlobalName,
-		name: remote.name,
-		alias: remoteAlias,
+		name: options ? runtimeRemoteAlias : remote.name,
+		alias: runtimeRemoteAlias,
 		type: remote.type,
 		entry: remote.entry,
 		shareScope: remote.shareScope ?? "default"
 	})}]);` : "";
-	const browserHostInitCode = `import(${JSON.stringify(getHostAutoInitPath())})
+	const hostAutoInitPath = getHostAutoInitPath(options);
+	const ssrRemotes = Object.entries(resolvedOptions.remotes).map(([name, item]) => ({
+		name: getRuntimeRemoteAlias(name, options),
+		entry: item.entry,
+		type: item.type ?? "module"
+	}));
+	const browserHostInitCode = `import(${JSON.stringify(hostAutoInitPath)})
         .then((mod) => mod.hostInitPromise)
         .then(initResolve, initReject);`;
-	const devRuntimeBootstrap = `${getRuntimeInitBootstrapCode(enableSsrInit, getHostAutoInitPath())}
+	const devRuntimeBootstrap = `${getRuntimeInitBootstrapCode(enableSsrInit, getRuntimeInitStatusImportId(options), ssrRemotes, hostAutoInitPath)}
     const { initPromise, initResolve, initReject, moduleCache: __mfModuleCache } = globalThis[globalKey];`;
 	const importLine = command === "build" ? `${getRuntimeModuleCacheBootstrapCode()}
-    import { hostInitPromise as __mfHostInitPromise } from ${JSON.stringify(getHostAutoInitPath())};` : `${devRuntimeBootstrap}
+    import { hostInitPromise as __mfHostInitPromise } from ${JSON.stringify(hostAutoInitPath)};` : `${devRuntimeBootstrap}
     ${command === "serve" && consumer !== "server" ? browserHostInitCode : ""}`;
 	const remoteLoadRuntimePromise = command === "build" ? "__mfHostInitPromise" : "initPromise";
+	const remoteCacheKey = `${getRuntimeRemoteCachePrefix(options)}${id}`;
 	const remoteLoadFailureHandler = command === "build" ? `.catch((error) => {
             delete __mfModuleCache.remote[pendingKey];
             throw error;
@@ -4156,16 +4336,17 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
 	const remoteLoadCode = `
     function __mfStartRemoteLoad() {
       ${`
-      const pendingKey = ${JSON.stringify(`__mf_pending__${id}`)};
+      const remoteCacheKey = ${JSON.stringify(remoteCacheKey)};
+      const pendingKey = "__mf_pending__" + remoteCacheKey;
       if (!__mfModuleCache.remote[pendingKey]) {
         __mfModuleCache.remote[pendingKey] = ${remoteLoadRuntimePromise}
           .then((runtime) => {
             ${registerRemoteCode}
-            return runtime.loadRemote(${JSON.stringify(id)});
+            return runtime.loadRemote(${JSON.stringify(runtimeRemoteId)});
           })
           .then((mod) => Promise.resolve(mod?.__mf_remote_dependency_pending).then(() => mod))
           .then((mod) => {
-            __mfModuleCache.remote[${JSON.stringify(id)}] = mod;
+            __mfModuleCache.remote[remoteCacheKey] = mod;
             delete __mfModuleCache.remote[pendingKey];
             return mod;
           })
@@ -4185,14 +4366,14 @@ function generateRemotes(id, command, enableSsrInit = false, consumer = "unified
     }`;
 	const initExportModule = initMode === "eager" ? environmentSplitInit(eagerClientInit, realRemoteInit) : environmentSplitInit(loadedFirstClientInit, realRemoteInit);
 	const includeProxyHelper = shouldIncludeDeferredProxy(initMode, consumer, eagerLoadClientRemote, deferRemoteLoad);
-	const deferredProxyCode = getDeferredProxyHelper(id);
+	const deferredProxyCode = getDeferredProxyHelper(remoteCacheKey);
 	return `
     ${importLine}
     ${remoteLoadCode}
     ${includeProxyHelper ? deferredProxyCode : ""}
     ${getRemoteModuleRuntimeHelpers()}
     let __mfRemotePending;
-    let exportModule = __mfModuleCache.remote[${JSON.stringify(id)}]
+    let exportModule = __mfModuleCache.remote[${JSON.stringify(remoteCacheKey)}]
     if (exportModule === undefined) {
       ${initExportModule}
     }
@@ -4271,7 +4452,7 @@ function patchHashEntryFileNames(config, entryName, fileName) {
 	patchBundlerOutput(config.build.rollupOptions);
 	patchBundlerOutput(config.build.rolldownOptions);
 }
-const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClientInjected, skipTransformFor = [] }) => {
+const addEntry = ({ entryName, entryPath, fileName, inject = "entry", forceClientInjected, skipTransformFor = [], federationOptions }) => {
 	const DEV_HTML_PROXY_PREFIX = "virtual:mf-html-entry-proxy?";
 	const ENTRY_BOOTSTRAP_PARAM = "mf-entry-bootstrap";
 	const ENTRY_BOOTSTRAP_QUERY = `?${ENTRY_BOOTSTRAP_PARAM}`;
@@ -4355,15 +4536,17 @@ const __mfCurrentScript = document.currentScript;
     : import(src);
 ` : "";
 		const importExpression = (src) => useSystemImportFallback ? `__mfImport(${JSON.stringify(src)})` : `import(${JSON.stringify(src)})`;
-		const remotePreloads = !options?.skipRemotePreload && getNormalizeModuleFederationOptions()?.shareStrategy !== "loaded-first" ? Object.entries(getUsedRemotesMap()).flatMap(([remoteKey, remotes]) => Array.from(remotes).filter((remote) => remote !== remoteKey)).sort().map((remote) => `__mfPreloadRemote(${JSON.stringify(remote)})`).join(",") : "";
+		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 remoteCachePrefix = getRuntimeRemoteCachePrefix(federationOptions);
 		const preloadBlock = remotePreloads ? `
   const runtime = await initHost();
-  const __mfPreloadRemote = (remote) => {
-    const pendingKey = "__mf_pending__" + remote;
+  const __mfPreloadRemote = (runtimeRemote, remote) => {
+    const remoteCacheKey = ${JSON.stringify(remoteCachePrefix)} + remote;
+    const pendingKey = "__mf_pending__" + remoteCacheKey;
     if (!__mfModuleCache.remote[pendingKey]) {
-      __mfModuleCache.remote[pendingKey] = runtime.loadRemote(remote)
+      __mfModuleCache.remote[pendingKey] = runtime.loadRemote(runtimeRemote)
         .then((mod) => {
-          __mfModuleCache.remote[remote] = mod;
+          __mfModuleCache.remote[remoteCacheKey] = mod;
           delete __mfModuleCache.remote[pendingKey];
           return mod;
         })
@@ -4610,7 +4793,7 @@ const __mfCurrentScript = document.currentScript;
 						htmlContent = htmlContent.replace("<head>", `<head>${scriptContent}`);
 					}
 				}
-				if (waitsForInit) htmlContent = injectHostInitPreloads(htmlContent, bundle, (builtFileName) => resolvePath(builtFileName, fileName));
+				if (waitsForInit && viteConfig.build.modulePreload !== false) htmlContent = injectHostInitPreloads(htmlContent, bundle, (builtFileName) => resolvePath(builtFileName, fileName));
 				htmlAsset.source = htmlContent;
 			}
 		},
@@ -4739,8 +4922,8 @@ function resolveReactRefreshRuntime(root) {
 * falls back to this remote's local runtime when the remote is opened directly.
 */
 const REACT_REFRESH_PROXY_MODULE = [
-	`const __remoteOrigin = new URL(import.meta.url).origin;`,
-	`const __target = window.location.origin === __remoteOrigin ? '${LOCAL_REACT_REFRESH_PATH}' : window.location.origin + '${REACT_REFRESH_PATH}';`,
+	`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 __rt = await import(__target);`,
 	`export const injectIntoGlobalHook = __rt.injectIntoGlobalHook;`,
 	`export const register = __rt.register;`,
@@ -4757,14 +4940,14 @@ const reactAdapter = {
 		let reactRefreshRuntime;
 		server.middlewares.use((req, res, next) => {
 			const url = stripQuery(req.url);
-			if (url === LOCAL_REACT_REFRESH_PATH) {
+			if (url?.endsWith(LOCAL_REACT_REFRESH_PATH)) {
 				reactRefreshRuntime ??= resolveReactRefreshRuntime(server.config.root);
 				res.setHeader("Content-Type", "application/javascript; charset=utf-8");
 				res.setHeader("Access-Control-Allow-Origin", "*");
 				res.end(reactRefreshRuntime);
 				return;
 			}
-			if (url !== REACT_REFRESH_PATH) return next();
+			if (!url?.endsWith(REACT_REFRESH_PATH)) return next();
 			res.setHeader("Content-Type", "application/javascript; charset=utf-8");
 			res.setHeader("Access-Control-Allow-Origin", "*");
 			res.end(REACT_REFRESH_PROXY_MODULE);
@@ -5186,10 +5369,14 @@ function pluginDevRemoteHmr(options) {
 }
 //#endregion
 //#region src/virtualModules/index.ts
-function initVirtualModules(command, remoteEntryId, enableSsrInit = false) {
-	writeLocalSharedImportMap();
-	writeHostAutoInit(remoteEntryId, command);
-	writeRuntimeInitStatus(command, enableSsrInit, getHostAutoInitPath());
+function initVirtualModules(command, remoteEntryId, enableSsrInit = false, options) {
+	writeLocalSharedImportMap(options);
+	writeHostAutoInit(remoteEntryId, command, options);
+	writeRuntimeInitStatus(command, enableSsrInit, getHostAutoInitPath(options), options, options ? Object.entries(options.remotes).map(([name, item]) => ({
+		name,
+		entry: item.entry,
+		type: item.type ?? "module"
+	})) : void 0);
 }
 //#endregion
 //#region src/utils/bundleHelpers.ts
@@ -5450,6 +5637,35 @@ const chunkContainsCssModules = (modules) => {
 	return false;
 };
 /**
+* Analyzes assets associated with a chunk without mutating the output map.
+* The static-import traversal is cycle-safe and ignores missing bundle entries.
+*/
+const analyzeChunkAssets = (bundle, fileName, chunk) => {
+	const dynamicAssets = [];
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [fileName];
+	for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
+		const currentFileName = queue[queueIndex];
+		if (visited.has(currentFileName)) continue;
+		visited.add(currentFileName);
+		const currentChunk = bundle[currentFileName];
+		if (!currentChunk || currentChunk.type !== "chunk") continue;
+		for (const dynamicImport of currentChunk.dynamicImports ?? []) {
+			if (!bundle[dynamicImport]) continue;
+			dynamicAssets.push({
+				fileName: dynamicImport,
+				type: isCSSFile(dynamicImport) ? "css" : "js"
+			});
+		}
+		for (const staticImport of currentChunk.imports ?? []) queue.push(staticImport);
+	}
+	return {
+		importedCss: Array.from(chunk.viteMetadata?.importedCss ?? []),
+		containsCssModules: chunkContainsCssModules(chunk.modules),
+		dynamicAssets
+	};
+};
+/**
 * Processes module assets and tracks them in the files map
 * @param bundle - The Rollup output bundle
 * @param filesMap - The preload map to populate
@@ -5457,6 +5673,7 @@ const chunkContainsCssModules = (modules) => {
 */
 const processModuleAssets = (bundle, filesMap, moduleMatcher, options = {}) => {
 	const bundleCssAssets = collectCssAssets(bundle);
+	const chunkAnalysisCache = /* @__PURE__ */ new Map();
 	for (const [fileName, fileData] of Object.entries(bundle)) {
 		if (fileData.type !== "chunk") continue;
 		if (!fileData.modules) continue;
@@ -5469,27 +5686,19 @@ const processModuleAssets = (bundle, filesMap, moduleMatcher, options = {}) => {
 			}
 			const matchKey = comparableModulePaths.map(moduleMatcher).find(Boolean);
 			if (!matchKey) continue;
+			let analysis = chunkAnalysisCache.get(fileName);
+			if (!analysis) {
+				analysis = analyzeChunkAssets(bundle, fileName, fileData);
+				chunkAnalysisCache.set(fileName, analysis);
+			}
 			trackAsset(filesMap, matchKey, fileName, false, "js");
 			let foundCssViaMetadata = false;
-			if (fileData.viteMetadata?.importedCss?.size) for (const cssFile of Array.from(fileData.viteMetadata.importedCss)) {
+			for (const cssFile of analysis.importedCss) {
 				trackAsset(filesMap, matchKey, cssFile, false, "css");
 				foundCssViaMetadata = true;
 			}
-			if (!foundCssViaMetadata && chunkContainsCssModules(fileData.modules)) for (const cssAsset of Array.from(bundleCssAssets)) trackAsset(filesMap, matchKey, cssAsset, false, "css");
-			const visited = /* @__PURE__ */ new Set();
-			const queue = [fileName];
-			for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
-				const cur = queue[queueIndex];
-				if (visited.has(cur)) continue;
-				visited.add(cur);
-				const chunk = bundle[cur];
-				if (!chunk || chunk.type !== "chunk") continue;
-				if (chunk.dynamicImports) for (const dynamicImport of chunk.dynamicImports) {
-					if (!bundle[dynamicImport]) continue;
-					trackAsset(filesMap, matchKey, dynamicImport, true, isCSSFile(dynamicImport) ? "css" : "js");
-				}
-				if (chunk.imports) for (const imp of chunk.imports) queue.push(imp);
-			}
+			if (!foundCssViaMetadata && analysis.containsCssModules) for (const cssAsset of Array.from(bundleCssAssets)) trackAsset(filesMap, matchKey, cssAsset, false, "css");
+			for (const asset of analysis.dynamicAssets) trackAsset(filesMap, matchKey, asset.fileName, true, asset.type);
 		}
 	}
 };
@@ -5524,9 +5733,9 @@ const deduplicateAssets = (filesMap) => {
 * @param resolveFn - Function to resolve module paths
 * @returns Map of file paths to their corresponding share keys
 */
-const buildFileToShareKeyMap = async (shareKeys, resolveFn) => {
+const buildFileToShareKeyMap = async (shareKeys, resolveFn, options) => {
 	const fileToShareKey = /* @__PURE__ */ new Map();
-	const resolutions = await Promise.all(Array.from(shareKeys).map((shareKey) => resolveFn(getPreBuildLibImportId(shareKey)).then((resolution) => ({
+	const resolutions = await Promise.all(Array.from(shareKeys).map((shareKey) => resolveFn(getPreBuildLibImportId(shareKey, options)).then((resolution) => ({
 		shareKey,
 		file: resolution?.id?.split("?")[0]
 	})).catch(() => null)));
@@ -5732,8 +5941,8 @@ function getRemoteContainerName(remoteKey, remote) {
 	if (entryGlobalName && entryGlobalName !== remoteKey && entryGlobalName !== remote.entry) return entryGlobalName;
 	return remote.name;
 }
-const Manifest = () => {
-	const mfOptions = getNormalizeModuleFederationOptions();
+const Manifest = (providedOptions) => {
+	const mfOptions = providedOptions ?? getNormalizeModuleFederationOptions();
 	const { name, filename, getPublicPath, manifest: manifestOptions, varFilename } = mfOptions;
 	let mfManifestName = manifestOptions === true ? "mf-manifest.json" : typeof manifestOptions === "object" ? normalizePathForImport(path$1.join(manifestOptions?.filePath || "", manifestOptions?.fileName || "mf-manifest.json")) : void 0;
 	let mfManifestStatsName = mfManifestName ? getStatsFileName(mfManifestName) : void 0;
@@ -5860,7 +6069,7 @@ const Manifest = () => {
 					root,
 					stripKnownJsExtensions: true
 				});
-				const fileToShareKey = await buildFileToShareKeyMap(getUsedShares(), this.resolve.bind(this));
+				const fileToShareKey = await buildFileToShareKeyMap(getUsedShares(mfOptions), this.resolve.bind(this), mfOptions);
 				processModuleAssets(Object.fromEntries(Object.entries(bundle).filter(([, file]) => !isTreeShakingProviderChunk(file))), filesMap, (modulePath) => fileToShareKey.get(modulePath));
 				if (mfOptions.bundleAllCSS) addCssAssetsToAllExports(filesMap, allCssAssets);
 				filesMap = deduplicateAssets(filesMap);
@@ -5887,7 +6096,7 @@ const Manifest = () => {
 	* @returns Complete manifest object
 	*/
 	function generateMFManifest(preloadMap, disableAssetsAnalyze = false) {
-		const options = getNormalizeModuleFederationOptions();
+		const options = mfOptions;
 		const { name, varFilename } = options;
 		const resolvedRemoteEntryFile = _command === "serve" ? remoteEntryFile || resolveDevRemoteEntryFileName(filename) : remoteEntryFile;
 		const remoteEntry = {
@@ -5905,7 +6114,7 @@ const Manifest = () => {
 			path: "",
 			type: "var"
 		} : void 0;
-		const remotes = Array.from(Object.entries(getUsedRemotesMap())).flatMap(([remoteKey, modules]) => {
+		const remotes = Array.from(Object.entries(getUsedRemotesMap(options))).flatMap(([remoteKey, modules]) => {
 			const remote = options.remotes[remoteKey];
 			return Array.from(modules).map((moduleKey) => ({
 				federationContainerName: getRemoteContainerName(remoteKey, remote),
@@ -5914,11 +6123,11 @@ const Manifest = () => {
 				entry: "*"
 			}));
 		});
-		const shared = Array.from(getUsedShares()).flatMap((shareKey) => {
-			const shareItem = getNormalizeShareItem(shareKey);
+		const shared = Array.from(getUsedShares(options)).flatMap((shareKey) => {
+			const shareItem = getNormalizeShareItem(shareKey, options);
 			if (!shareItem) return [];
 			const assets = preloadMap[shareKey] || (_command === "serve" && resolvedRemoteEntryFile ? createRemoteEntryAssetMap(resolvedRemoteEntryFile) : createEmptyAssetMap());
-			const treeShakingUsage = getTreeShakingExportUsage(shareKey, shareItem, shareItem.name);
+			const treeShakingUsage = getTreeShakingExportUsage(shareKey, shareItem, shareItem.name, options);
 			const treeShakingUsedExports = treeShakingUsage?.kind === "exports" ? treeShakingUsage.usedExports : [];
 			const treeShakingStatus = treeShakingUsage?.kind === "full" ? 0 : 1;
 			return [{
@@ -6150,6 +6359,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 	let exposeRemoteDependenciesDirty = true;
 	let refreshPromise;
 	let dependencyInvalidationVersion = 0;
+	const isHostAutoInitId = (id) => id.includes(getHostAutoInitPath(options)) || id.includes(getHostAutoInitPath());
 	function isRemoteImport(source) {
 		return Object.keys(options.remotes).some((name) => source === name || source.startsWith(name + "/"));
 	}
@@ -6239,7 +6449,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 		async resolveId(id, importer) {
 			if (id === remoteEntryId) return remoteEntryId;
 			if (id === virtualExposesId) return virtualExposesId;
-			if (_command === "serve" && id.includes(getHostAutoInitPath())) return id;
+			if (_command === "serve" && isHostAutoInitId(id)) return id;
 			if (importer === remoteEntryId && !id.startsWith(".") && !id.startsWith("/") && !id.startsWith("\0") && !id.startsWith("virtual:")) {
 				const importPath = typeof __filename === "string" ? __filename : fileURLToPath(import.meta.url);
 				const resolved = await this.resolve(id, importPath, { skipSelf: true });
@@ -6252,7 +6462,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 				await refreshExposeRemoteDependencies(this);
 				return generateExposes(options, exposeRemoteDependencies, _command);
 			}
-			if (_command === "serve" && id.includes(getHostAutoInitPath())) return id;
+			if (_command === "serve" && isHostAutoInitId(id)) return id;
 		},
 		async transform(code, id) {
 			return mapCodeToCodeWithSourcemap(await (async () => {
@@ -6262,7 +6472,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 					await refreshExposeRemoteDependencies(this);
 					return generateExposes(options, exposeRemoteDependencies, _command);
 				}
-				if (id.includes(getHostAutoInitPath())) {
+				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);
@@ -6272,7 +6482,7 @@ function pluginProxyRemoteEntry_default({ options, remoteEntryId, virtualExposes
 						return `
           const origin = typeof window !== 'undefined' && (${!options.ignoreOrigin}) ? window.origin : ${JSON.stringify(fallbackOrigin)};
           const remoteEntryImport = typeof window !== 'undefined' ? origin + ${publicPath} : ${JSON.stringify(ssrRemoteEntry)};
-          ${generateHostAutoInitCode("remoteEntryImport", "serve")}
+          ${generateHostAutoInitCode("remoteEntryImport", "serve", options)}
         `;
 					}
 					return code;
@@ -6367,9 +6577,9 @@ function pluginProxyRemotes_default(options) {
 			if (installedPackageEntry && (importer === void 0 || isNodeModulesImporter(importer))) return installedPackageEntry;
 		}
 		const consumer = resolveRemoteConsumer(pluginContext, hasMultiEnvironment);
-		const remoteModule = getRemoteVirtualModule(source, command, enableSsrInit, consumer);
-		addUsedRemote(remoteName, source);
-		refreshHostAutoInit();
+		const remoteModule = getRemoteVirtualModule(source, command, enableSsrInit, consumer, options);
+		addUsedRemote(remoteName, source, options);
+		refreshHostAutoInit(options);
 		return remoteModule.getImportId();
 	}
 	return {
@@ -6546,7 +6756,7 @@ function excludeSharedSubDependencies(shared) {
 	}
 }
 function proxySharedModule(options) {
-	const { shared = {} } = options;
+	const { shared = {}, federationOptions } = options;
 	let _config;
 	let _command = "serve";
 	let useDirectReactImport = false;
@@ -6566,20 +6776,20 @@ function proxySharedModule(options) {
 	};
 	const getTreeShakingProviderFileName = (pkg, shareItem) => {
 		if (!shareItem.shareConfig.treeShaking) return void 0;
-		const normalizedOptions = getNormalizeModuleFederationOptions();
+		const normalizedOptions = federationOptions ?? getNormalizeModuleFederationOptions();
 		const outputDir = normalizedOptions.treeShakingDir ? normalizeTreeShakingOutputPath(normalizedOptions.treeShakingDir) : void 0;
-		const fileName = outputDir ? path$1.posix.join(outputDir, `${getTreeShakingSharedProviderName(pkg)}.js`) : void 0;
+		const fileName = outputDir ? path$1.posix.join(outputDir, `${getTreeShakingSharedProviderName(pkg, federationOptions)}.js`) : void 0;
 		if (!fileName) return void 0;
 		return fileName;
 	};
 	const emitTreeShakingProvider = (context, pkg, shareItem) => {
 		if (_command !== "build" || emittedTreeShakingProviders.has(pkg)) return;
-		if (!hasTreeShakingSharedProvider(pkg, shareItem)) return;
+		if (!hasTreeShakingSharedProvider(pkg, shareItem, federationOptions)) return;
 		const fileName = getTreeShakingProviderFileName(pkg, shareItem);
 		context.emitFile({
 			type: "chunk",
-			id: getTreeShakingSharedProviderImportId(pkg),
-			name: getTreeShakingSharedProviderName(pkg),
+			id: getTreeShakingSharedProviderImportId(pkg, federationOptions),
+			name: getTreeShakingSharedProviderName(pkg, federationOptions),
 			...fileName ? { fileName } : {}
 		});
 		emittedTreeShakingProviders.add(pkg);
@@ -6591,28 +6801,28 @@ function proxySharedModule(options) {
 			configureServer(server) {
 				devServer = server;
 				setLocalSharedImportMapInvalidator(() => {
-					const module = server.moduleGraph.getModuleById(getResolvedLocalSharedImportMapId());
+					const module = server.moduleGraph.getModuleById(getResolvedLocalSharedImportMapId(federationOptions));
 					if (module) server.moduleGraph.invalidateModule(module);
-				});
+				}, federationOptions);
 			},
 			resolveId(source) {
-				if (source === getLocalSharedImportMapPath()) return getResolvedLocalSharedImportMapId();
+				if (source === getLocalSharedImportMapPath(federationOptions)) return getResolvedLocalSharedImportMapId(federationOptions);
 			},
 			load(id) {
-				if (id === getResolvedLocalSharedImportMapId()) return parsePromise.then((_) => {
-					refreshTreeShakingModules();
-					const providerPackages = new Set([...Object.keys(shared).filter((pkg) => !pkg.endsWith("/")), ...getUsedShares()]);
+				if (id === getResolvedLocalSharedImportMapId(federationOptions)) return parsePromise.then((_) => {
+					refreshTreeShakingModules(federationOptions);
+					const providerPackages = 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);
 						if (shareItem) emitTreeShakingProvider(this, pkg, shareItem);
 					}
-					return generateLocalSharedImportMap();
+					return generateLocalSharedImportMap(federationOptions);
 				});
 			},
 			closeBundle() {
 				if (devServer) return;
-				setLocalSharedImportMapInvalidator(void 0);
+				setLocalSharedImportMapInvalidator(void 0, federationOptions);
 			}
 		},
 		{
@@ -6620,8 +6830,8 @@ function proxySharedModule(options) {
 			enforce: "post",
 			config(config, { command }) {
 				setPackageDetectionCwd(config.root || process.cwd());
-				setTreeShakingBuildMode(command === "build");
-				resetTreeShakingExports();
+				setTreeShakingBuildMode(command === "build", federationOptions);
+				resetTreeShakingExports(federationOptions);
 				emittedTreeShakingProviders.clear();
 				const isVinext = hasPackageDependency("vinext");
 				const isAstro = hasPackageDependency("astro");
@@ -6637,29 +6847,29 @@ function proxySharedModule(options) {
 				Object.keys(shared).forEach((key) => {
 					if (key.endsWith("/")) return;
 					if (useDirectReactImport && key === "react") {
-						addUsedShares(key);
+						addUsedShares(key, federationOptions);
 						return;
 					}
-					writeLoadShareModule(key, shared[key], _command, isRolldown);
-					if (shared[key].shareConfig.import !== false) writePreBuildLibPath(key, shared[key]);
-					addUsedShares(key);
+					writeLoadShareModule(key, shared[key], _command, isRolldown, federationOptions);
+					if (shared[key].shareConfig.import !== false) writePreBuildLibPath(key, shared[key], federationOptions);
+					addUsedShares(key, federationOptions);
 				});
-				writeLocalSharedImportMap();
-				refreshHostAutoInit();
+				writeLocalSharedImportMap(federationOptions);
+				refreshHostAutoInit(federationOptions);
 			},
 			buildStart() {
 				if (_command !== "build") return;
-				resetTreeShakingExports();
+				resetTreeShakingExports(federationOptions);
 				emittedTreeShakingProviders.clear();
-				refreshTreeShakingModules();
+				refreshTreeShakingModules(federationOptions);
 			},
 			shouldTransformCachedModule() {
 				return _command === "build" && Object.values(shared).some((share) => !!share.shareConfig.treeShaking);
 			},
 			transform(code, id) {
 				if (_command !== "build" || !Object.keys(shared).some((key) => shared[key].shareConfig.treeShaking)) return;
-				collectTreeShakingImports(code, id, shared, findSharedKeyForSource, recordTreeShakingExports, markTreeShakingPackageUnsafe);
-				refreshTreeShakingModules();
+				collectTreeShakingImports(code, id, shared, findSharedKeyForSource, (sharedKey, exports, request) => recordTreeShakingExports(sharedKey, exports, request, federationOptions), (sharedKey, request) => markTreeShakingPackageUnsafe(sharedKey, request, federationOptions));
+				refreshTreeShakingModules(federationOptions);
 			}
 		},
 		{
@@ -6719,14 +6929,14 @@ function proxySharedModule(options) {
 				if (shouldSkipTaggedImporterProxy(key, "__loadShare__")) return;
 				if (shouldSkipTaggedImporterProxy(key, "__prebuild__")) return;
 				const shareSource = key === "vue" && source.startsWith("vue/dist/") ? key : isNodeModulePath(source) ? getCommonSharedSubpathFromNodeModulePath(source, key) || key : source;
-				const loadSharePath = getLoadShareModulePath(shareSource, useRolldown);
+				const loadSharePath = getLoadShareModulePath(shareSource, useRolldown, federationOptions);
 				if (!materializedLoadShareSources.has(shareSource)) {
 					materializedLoadShareSources.add(shareSource);
-					writeLoadShareModule(shareSource, shared[key], _command, useRolldown);
-					if (shared[key].shareConfig.import !== false) writePreBuildLibPath(shareSource, shared[key]);
-					addUsedShares(shareSource);
-					writeLocalSharedImportMap();
-					refreshHostAutoInit();
+					writeLoadShareModule(shareSource, shared[key], _command, useRolldown, federationOptions);
+					if (shared[key].shareConfig.import !== false) writePreBuildLibPath(shareSource, shared[key], federationOptions);
+					addUsedShares(shareSource, federationOptions);
+					writeLocalSharedImportMap(federationOptions);
+					refreshHostAutoInit(federationOptions);
 				}
 				return this.resolve(loadSharePath, importer, { skipSelf: true });
 			}
@@ -6738,7 +6948,7 @@ function proxySharedModule(options) {
 				if (!source.includes("__prebuild__")) return;
 				if (source.startsWith(".")) return;
 				const pkgName = assertModuleFound(PREBUILD_TAG, source).name;
-				const importSource = getPrebuildResolutionSource(pkgName, getPreBuildShareItem(pkgName));
+				const importSource = getPrebuildResolutionSource(pkgName, getPreBuildShareItem(pkgName, federationOptions));
 				if (_command === "build") return this.resolve(importSource, importer, { skipSelf: true });
 				const direct = tryResolveFromProjectRoot(importSource);
 				const directSource = direct && !isNodeModulePath(direct) ? direct : void 0;
@@ -7395,8 +7605,8 @@ function isWithinDirectory(filePath, directory) {
 }
 //#endregion
 //#region src/plugins/pluginVarRemoteEntry.ts
-const VarRemoteEntry = () => {
-	const mfOptions = getNormalizeModuleFederationOptions();
+const VarRemoteEntry = (providedOptions) => {
+	const mfOptions = providedOptions ?? getNormalizeModuleFederationOptions();
 	const { name, varFilename, filename } = mfOptions;
 	let viteConfig;
 	return [{
@@ -7448,7 +7658,7 @@ const VarRemoteEntry = () => {
 	* @returns Complete "var" remoteEntry.js file source
 	*/
 	function generateVarRemoteEntry(remoteEntryFile) {
-		const { name, varFilename } = getNormalizeModuleFederationOptions();
+		const { name, varFilename } = mfOptions;
 		const isValidName = isValidVarName(name);
 		return `
   ${isValidName ? `var ${name};` : ""}
@@ -7578,6 +7788,44 @@ var normalizeOptimizeDeps_default = {
 	}
 };
 //#endregion
+//#region src/utils/runtimeCapabilityOptimization.ts
+const RUNTIME_CAPABILITIES = [
+	{
+		option: "disableRemote",
+		define: "FEDERATION_OPTIMIZE_NO_REMOTE"
+	},
+	{
+		option: "disableShared",
+		define: "FEDERATION_OPTIMIZE_NO_SHARED"
+	},
+	{
+		option: "disableSnapshot",
+		define: "FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN"
+	}
+];
+function isEquivalentBooleanDefine(value, expected) {
+	return String(value) === JSON.stringify(expected);
+}
+function applyRuntimeCapabilityDefines(define, options, { defaultDisableSnapshot, onConflict } = {}) {
+	for (const capability of RUNTIME_CAPABILITIES) {
+		const explicitValue = options[capability.option];
+		const desiredValue = capability.option === "disableSnapshot" ? explicitValue ?? defaultDisableSnapshot : explicitValue;
+		if (desiredValue === void 0) continue;
+		if (!(capability.define in define)) {
+			define[capability.define] = JSON.stringify(desiredValue);
+			continue;
+		}
+		if (explicitValue !== void 0 && !isEquivalentBooleanDefine(define[capability.define], explicitValue)) onConflict?.(`${capability.define} define (${define[capability.define]}) differs from ${capability.option} option (${explicitValue}). The existing define will not be overridden.`);
+	}
+	if (!("FEDERATION_HAS_EXPOSES" in define)) define["FEDERATION_HAS_EXPOSES"] = JSON.stringify(Object.keys(options.exposes).length > 0);
+}
+function getRuntimeCapabilityConfigurationWarnings(options) {
+	const warnings = [];
+	if (options.disableRemote && Object.keys(options.remotes).length > 0) warnings.push("disableRemote is true, but remotes are configured. Remote loading will be unavailable at runtime.");
+	if (options.disableShared && Object.keys(options.shared).length > 0) warnings.push("disableShared is true, but shared dependencies are configured. Shared dependency loading will be unavailable at runtime.");
+	return warnings;
+}
+//#endregion
 //#region src/index.ts
 const patchedManualChunks = /* @__PURE__ */ new WeakSet();
 const PRELOAD_HELPER_CHUNK = "vite-preload-helper";
@@ -7662,8 +7910,7 @@ function isFederationHtmlPreloadDependency(dep, includeSharedRuntime = false) {
 }
 function canResolveSharedSubpath(subpath, projectRoot) {
 	try {
-		createRequire$1(pathToFileURL(path$1.join(projectRoot, "package.json"))).resolve(subpath);
-		return true;
+		return isViteOptimizableEntry(createRequire$1(pathToFileURL(path$1.join(projectRoot, "package.json"))).resolve(subpath));
 	} catch {
 		return false;
 	}
@@ -7721,15 +7968,10 @@ function createEarlyVirtualModulesPlugin(options) {
 			const root = config.root || process.cwd();
 			setPackageDetectionCwd(root);
 			const isVinext = hasPackageDependency("vinext");
-			setSsrRemotes(Object.entries(options.remotes).map(([key, r]) => ({
-				name: key,
-				entry: r.entry,
-				type: r.type ?? "module"
-			})));
-			initVirtualModules(_command, getRemoteEntryId(options));
+			initVirtualModules(_command, getRemoteEntryId(options), false, options);
 			const isRolldown = getIsRolldown(this);
 			if (remotes && Object.keys(remotes).length > 0) {
-				for (const key of Object.keys(remotes)) addUsedRemote(key, key);
+				for (const key of Object.keys(remotes)) addUsedRemote(key, key, options);
 				if (_command === "serve") {
 					config.optimizeDeps = config.optimizeDeps || {};
 					config.optimizeDeps.exclude = config.optimizeDeps.exclude || [];
@@ -7749,11 +7991,11 @@ function createEarlyVirtualModulesPlugin(options) {
 							name: "module-federation:optimize-shared-resolver",
 							load(id) {
 								if (id !== "module-federation:optimized-require-react") return;
-								const loadSharePath = getLoadShareModulePath("react", isRolldown);
+								const loadSharePath = getLoadShareModulePath("react", isRolldown, options);
 								const source = JSON.stringify(loadSharePath);
 								return "import * as __mfShared from " + source + ";\nexport * from " + source + ";\nexport default __mfShared.default ?? __mfShared;";
 							},
-							resolveId(source, importer, options) {
+							resolveId(source, importer, resolveOptions) {
 								if (createViteEncodedIdPrefixRegExp("virtual:mf:").test(source)) return {
 									id: source,
 									external: true
@@ -7764,19 +8006,19 @@ function createEarlyVirtualModulesPlugin(options) {
 								if (isAssetLikeImport(source)) return;
 								const shareItem = shared[key];
 								const isReactSingleton = source === "react" && key === "react" && shareItem.shareConfig?.singleton === true;
-								const isReactRequire = options?.kind?.startsWith("require") && isReactSingleton;
-								if (options?.kind?.startsWith("require") && !isReactSingleton) return;
+								const isReactRequire = resolveOptions?.kind?.startsWith("require") && isReactSingleton;
+								if (resolveOptions?.kind?.startsWith("require") && !isReactSingleton) return;
 								if (isCommonJsImporter(importer) && !isReactSingleton) return;
 								if (isReactRequire) {
-									writeLoadShareModule(source, shareItem, _command, isRolldown);
-									if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(source, shareItem);
-									addUsedShares(source);
+									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" };
 								}
-								const loadSharePath = getLoadShareModulePath(source, isRolldown);
-								writeLoadShareModule(source, shareItem, _command, isRolldown);
-								if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(source, shareItem);
-								addUsedShares(source);
+								const loadSharePath = getLoadShareModulePath(source, isRolldown, options);
+								writeLoadShareModule(source, shareItem, _command, isRolldown, options);
+								if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(source, shareItem, options);
+								addUsedShares(source, options);
 								return {
 									id: loadSharePath,
 									external: true
@@ -7810,15 +8052,15 @@ function createEarlyVirtualModulesPlugin(options) {
 									const key = findSharedKey(args.path, shared);
 									if (!key) return;
 									const shareItem = shared[key];
-									const optimizedLoadSharePath = toViteOptimizedDepVirtualId(getLoadShareModulePath(args.path, isRolldown));
-									writeLoadShareModule(args.path, shareItem, _command, isRolldown);
-									if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(args.path, shareItem);
-									addUsedShares(args.path);
+									const loadSharePath = getLoadShareModulePath(args.path, isRolldown, options);
+									writeLoadShareModule(args.path, shareItem, _command, isRolldown, options);
+									if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(args.path, shareItem, options);
+									addUsedShares(args.path, options);
 									return {
 										loader: "js",
 										resolveDir: root,
-										contents: `import * as __mfShared from ${JSON.stringify(optimizedLoadSharePath)};
-export * from ${JSON.stringify(optimizedLoadSharePath)};
+										contents: `import * as __mfShared from ${JSON.stringify(loadSharePath)};
+export * from ${JSON.stringify(loadSharePath)};
 export default __mfShared.default ?? __mfShared;`
 									};
 								});
@@ -7834,7 +8076,7 @@ export default __mfShared.default ?? __mfShared;`
 							optimizeDeps.include ??= [];
 							optimizeDeps.exclude ??= [];
 							for (const subpath of getCommonSharedSubpaths(key)) {
-								writePreBuildLibPath(subpath, shareItem);
+								writePreBuildLibPath(subpath, shareItem, options);
 								if (canResolveSharedSubpath(subpath, root)) optimizeDeps.include.push(subpath);
 								else optimizeDeps.exclude.push(subpath);
 							}
@@ -7842,32 +8084,37 @@ export default __mfShared.default ?? __mfShared;`
 						continue;
 					}
 					if (isVinext && key === "react") {
-						addUsedShares(key);
+						addUsedShares(key, options);
 						continue;
 					}
-					getLoadShareModulePath(key, isRolldown);
-					writeLoadShareModule(key, shareItem, _command, isRolldown);
-					if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(key, shareItem);
-					addUsedShares(key);
+					getLoadShareModulePath(key, isRolldown, options);
+					writeLoadShareModule(key, shareItem, _command, isRolldown, options);
+					if (shareItem.shareConfig?.import !== false) writePreBuildLibPath(key, shareItem, options);
+					addUsedShares(key, options);
 					if (_command === "serve" && shareItem.shareConfig?.import !== false) {
 						const optimizeDeps = config.optimizeDeps ??= {};
 						optimizeDeps.include ??= [];
 						optimizeDeps.exclude ??= [];
-						const shouldBypassOptimizeDep = isLitShare(key);
+						const shouldBypassOptimizeDep = isLitShare(key) || !canResolveSharedSubpath(key, root);
 						if (optimizeDeps.include.includes(key)) optimizeDeps.exclude = optimizeDeps.exclude.filter((dep) => dep !== key);
 						else if (shouldBypassOptimizeDep) optimizeDeps.exclude.push(key);
 						else optimizeDeps.include.push(key);
 						for (const subpath of getCommonSharedSubpaths(key)) {
-							getLoadShareModulePath(subpath, isRolldown);
-							writeLoadShareModule(subpath, shareItem, _command, isRolldown);
-							writePreBuildLibPath(subpath, shareItem);
-							addUsedShares(subpath);
-							if (canResolveSharedSubpath(subpath, root)) optimizeDeps.include.push(subpath);
+							const canResolveSubpath = canResolveSharedSubpath(subpath, root);
+							if (subpath === "react/compiler-runtime" && !canResolveSubpath) {
+								optimizeDeps.exclude.push(subpath);
+								continue;
+							}
+							getLoadShareModulePath(subpath, isRolldown, options);
+							writeLoadShareModule(subpath, shareItem, _command, isRolldown, options);
+							writePreBuildLibPath(subpath, shareItem, options);
+							addUsedShares(subpath, options);
+							if (canResolveSubpath) optimizeDeps.include.push(subpath);
 							else optimizeDeps.exclude.push(subpath);
 						}
 					}
 				}
-				writeLocalSharedImportMap();
+				writeLocalSharedImportMap(options);
 			}
 			if (_command === "serve") {
 				config.optimizeDeps ??= {};
@@ -7910,9 +8157,18 @@ export default __mfShared.default ?? __mfShared;`
 	};
 }
 const SSR_ONLY_PLUGINS = 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;
+	applyRuntimeCapabilityDefines(define, options, {
+		defaultDisableSnapshot,
+		onConflict: mfWarn
+	});
+	if (options.target && define.ENV_TARGET !== JSON.stringify(options.target)) mfWarn(`ENV_TARGET define (${define.ENV_TARGET}) differs from target option ("${options.target}"). ENV_TARGET will not be overridden.`);
+}
 function loadPluginDts(options) {
 	if (options.dts === false) return [];
-	return [import("./pluginDts-CGDIZCsD.js").then((n) => n.n).then(({ default: pluginDts }) => pluginDts(options))];
+	return [import("./pluginDts-Cd2opGcZ.js").then((n) => n.n).then(({ default: pluginDts }) => pluginDts(options))];
 }
 function federation(mfUserOptions) {
 	if (isTestEnv()) return [];
@@ -7926,6 +8182,7 @@ function federation(mfUserOptions) {
 	let command;
 	let desiredRolldownOutput;
 	let isSsrBuild = false;
+	const emittedRuntimeCapabilityWarnings = /* @__PURE__ */ new Set();
 	return [
 		{
 			name: "vite:module-federation-virtual-modules",
@@ -7939,8 +8196,9 @@ function federation(mfUserOptions) {
 						command,
 						isRolldown: getIsRolldown(this),
 						findSharedKey,
-						addUsedShares,
-						writeLocalSharedImportMap
+						addUsedShares: (pkg) => addUsedShares(pkg, options),
+						writeLocalSharedImportMap: () => writeLocalSharedImportMap(options),
+						federationOptions: options
 					});
 					virtualModule = VirtualModule.findById(id);
 				}
@@ -7981,7 +8239,7 @@ function federation(mfUserOptions) {
 			},
 			configResolved() {
 				const ssrCapabilities = getSsrCapabilities(parseInt(version, 10), command, Object.keys(options.remotes).length > 0);
-				initVirtualModules(command, remoteEntryId, ssrCapabilities.enableSsrInitBootstrap);
+				initVirtualModules(command, remoteEntryId, ssrCapabilities.enableSsrInitBootstrap, options);
 			}
 		},
 		aliasToArrayPlugin_default,
@@ -8004,18 +8262,21 @@ function federation(mfUserOptions) {
 		...addEntry({
 			entryName: "remoteEntry",
 			entryPath: remoteEntryId,
-			fileName: filename
+			fileName: filename,
+			federationOptions: options
 		}),
 		...addEntry({
 			entryName: "hostInit",
-			entryPath: () => getHostAutoInitPath(),
+			entryPath: () => getHostAutoInitPath(options),
 			inject: hostInitInjectLocation,
 			forceClientInjected: Object.keys(options.exposes).length > 0,
-			skipTransformFor: Object.values(options.exposes).map((expose) => expose.import)
+			skipTransformFor: Object.values(options.exposes).map((expose) => expose.import),
+			federationOptions: options
 		}),
 		...addEntry({
 			entryName: "virtualExposes",
-			entryPath: virtualExposesId
+			entryPath: virtualExposesId,
+			federationOptions: options
 		}),
 		pluginProxyRemoteEntry_default({
 			options,
@@ -8025,20 +8286,23 @@ function federation(mfUserOptions) {
 		pluginProxyRemotes_default(options),
 		pluginRemoteNamedExports(options),
 		...pluginModuleParseEnd_default((id) => {
-			return id.includes(getHostAutoInitImportId()) || id.includes(remoteEntryId) || id.includes(virtualExposesId) || id.includes(getLocalSharedImportMapPath()) || id.includes("__loadShare__") || id.includes("__prebuild__") || id.includes("__treeShakingProvider__") || id.includes("__mf_tree_shaking_graph__");
+			return id.includes(getHostAutoInitImportId(options)) || id.includes(remoteEntryId) || id.includes(virtualExposesId) || id.includes(getLocalSharedImportMapPath(options)) || id.includes("__loadShare__") || id.includes("__prebuild__") || id.includes("__treeShakingProvider__") || id.includes("__mf_tree_shaking_graph__");
 		}, {
 			moduleParseTimeout: options.moduleParseTimeout,
 			moduleParseIdleTimeout: options.moduleParseIdleTimeout,
 			exposedModuleImports: Object.values(options.exposes).map((expose) => expose.import)
 		}),
-		...proxySharedModule({ shared }),
+		...proxySharedModule({
+			shared,
+			federationOptions: options
+		}),
 		{
 			name: "module-federation-esm-shims",
 			enforce: "pre",
 			apply: "build",
 			config(config) {
 				isSsrBuild = config.build?.ssr === true;
-				const runtimeInitId = virtualRuntimeInitStatus.getImportId();
+				const runtimeInitId = getRuntimeInitStatusImportId(options);
 				config.build = config.build || {};
 				if (config.build.modulePreload !== false) {
 					const currentModulePreload = config.build.modulePreload && typeof config.build.modulePreload === "object" ? config.build.modulePreload : {};
@@ -8085,7 +8349,7 @@ function federation(mfUserOptions) {
 						mfWarn("Ignoring `output.manualChunks` because it conflicts with module federation. Module federation transforms shared dependency imports with async init wrappers, and grouping these transformed modules into a single chunk creates circular async dependencies that cause the application to silently hang.");
 					}
 					const mfChunkName = function(id) {
-						if (id.includes(runtimeInitId)) return "runtimeInit";
+						if (id.includes(runtimeInitId) || id.includes("__mf_v__runtimeInit__mf_v__")) return "runtimeInit";
 						if (id.includes("__loadShare__")) {
 							const match = id.match(/([^/\\]+__loadShare__[^/\\]+)/);
 							return match ? match[1] : "loadShare";
@@ -8261,11 +8525,17 @@ function federation(mfUserOptions) {
 				}
 				const isAstro = hasPackageDependency("astro");
 				const resolvedTarget = options.target ?? (config.build?.ssr ? "node" : "web");
-				const envTargetDefineValue = !options.target && isAstro ? "undefined" : JSON.stringify(resolvedTarget);
 				if (!config.define) config.define = {};
-				if (!("ENV_TARGET" in config.define)) config.define["ENV_TARGET"] = envTargetDefineValue;
-				if (resolvedTarget === "node" && !("FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN" in config.define)) config.define["FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN"] = "true";
-				if (options.target && "ENV_TARGET" in config.define && config.define["ENV_TARGET"] !== JSON.stringify(options.target)) mfWarn(`ENV_TARGET define (${config.define["ENV_TARGET"]}) differs from target option ("${options.target}"). ENV_TARGET will not be overridden.`);
+				applyBuildTimeRuntimeDefines(config.define, options, {
+					target: resolvedTarget,
+					isAstro,
+					defaultDisableSnapshot: resolvedTarget === "node" ? true : void 0
+				});
+				for (const warning of getRuntimeCapabilityConfigurationWarnings(options)) {
+					if (emittedRuntimeCapabilityWarnings.has(warning)) continue;
+					emittedRuntimeCapabilityWarnings.add(warning);
+					mfWarn(warning);
+				}
 			},
 			configResolved(config) {
 				if (!hasPackageDependency("nitro")) return;
@@ -8275,16 +8545,17 @@ function federation(mfUserOptions) {
 			configEnvironment(name, config) {
 				if (!(config.consumer === "server" || name === "ssr" || name === "server" || config.build?.ssr === true)) return;
 				const isAstro = hasPackageDependency("astro");
-				const envTargetDefineValue = !options.target && isAstro ? "undefined" : JSON.stringify(options.target ?? "node");
 				config.define = { ...config.define ?? {} };
-				if (!("ENV_TARGET" in config.define)) config.define["ENV_TARGET"] = envTargetDefineValue;
-				if (!("FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN" in config.define)) config.define["FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN"] = "true";
-				if (options.target && config.define["ENV_TARGET"] !== JSON.stringify(options.target)) mfWarn(`ENV_TARGET define (${config.define["ENV_TARGET"]}) differs from target option ("${options.target}"). ENV_TARGET will not be overridden.`);
+				applyBuildTimeRuntimeDefines(config.define, options, {
+					target: options.target ?? "node",
+					isAstro,
+					defaultDisableSnapshot: true
+				});
 			}
 		},
-		...Manifest(),
+		...Manifest(options),
 		...pluginSSRRemoteEntry(options),
-		...VarRemoteEntry(),
+		...VarRemoteEntry(options),
 		{
 			name: "module-federation-vinext-fix-rsc-preload-as",
 			enforce: "post",