remote-reload-utils 0.0.8 → 0.0.11

package/dist/main.cjs

@@ -1,5 +1,14 @@
 "use strict";
 var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
 (()=>{
     __webpack_require__.d = (exports1, definition)=>{
         for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
@@ -24,9 +33,219 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    loadRemoteMultiVersion: ()=>loadRemoteMultiVersion
+    compareVersions: ()=>compareVersions,
+    fetchAvailableVersions: ()=>fetchAvailableVersions,
+    sortVersions: ()=>sortVersions,
+    useRemoteModuleHook: ()=>useRemoteModuleHook,
+    registerRemoteInstance: ()=>registerRemoteInstance,
+    fallbackPlugin: ()=>fallbackPlugin,
+    createEventBus: ()=>createEventBus,
+    withRemote: ()=>withRemote,
+    getPreloadStatus: ()=>getPreloadStatus,
+    parseVersion: ()=>parseVersion,
+    resolveFinalVersion: ()=>resolveFinalVersion,
+    buildFinalUrls: ()=>buildFinalUrls,
+    fetchLatestVersion: ()=>fetchLatestVersion,
+    ErrorBoundary: ()=>ErrorBoundary,
+    getFinalSharedConfig: ()=>getFinalSharedConfig,
+    isRemoteLoaded: ()=>isRemoteLoaded,
+    tryLoadRemote: ()=>tryLoadRemote,
+    getVersionCache: ()=>getVersionCache,
+    eventBus: ()=>eventBus,
+    loadRemoteMultiVersion: ()=>loadRemoteMultiVersion,
+    clearPreloadCache: ()=>clearPreloadCache,
+    getRemoteHealthReport: ()=>getRemoteHealthReport,
+    checkModuleLoadable: ()=>checkModuleLoadable,
+    getStableVersions: ()=>getStableVersions,
+    extractMajorVersion: ()=>extractMajorVersion,
+    buildCdnUrls: ()=>buildCdnUrls,
+    loadReactVersion: ()=>loadReactVersion,
+    preloadRemoteList: ()=>preloadRemoteList,
+    SuspenseRemoteLoader: ()=>SuspenseRemoteLoader,
+    registerLoadedModule: ()=>registerLoadedModule,
+    getCompatibleReactVersions: ()=>getCompatibleReactVersions,
+    SuspenseRemote: ()=>SuspenseRemote,
+    unloadRemote: ()=>unloadRemote,
+    cancelPreload: ()=>cancelPreload,
+    findCompatibleVersion: ()=>findCompatibleVersion,
+    getLoadedRemotes: ()=>getLoadedRemotes,
+    getLatestVersion: ()=>getLatestVersion,
+    preloadRemote: ()=>preloadRemote,
+    satisfiesVersion: ()=>satisfiesVersion,
+    formatHealthStatus: ()=>formatHealthStatus,
+    RemoteModuleCard: ()=>RemoteModuleCard,
+    unloadAll: ()=>unloadAll,
+    setVersionCache: ()=>setVersionCache,
+    lazyRemote: ()=>lazyRemote,
+    checkRemoteHealth: ()=>checkRemoteHealth,
+    isPrerelease: ()=>isPrerelease,
+    checkVersionCompatibility: ()=>checkVersionCompatibility
 });
 const runtime_namespaceObject = require("@module-federation/enhanced/runtime");
+async function loadReactVersion(version) {
+    const runtime = await (0, runtime_namespaceObject.createInstance)({
+        name: `react_${version}_runtime`,
+        remotes: [
+            {
+                name: `react@${version}`,
+                entry: `https://cdn.jsdelivr.net/npm/react@${version}/umd/react.production.min.js`,
+                type: 'var',
+                entryGlobalName: 'React'
+            },
+            {
+                name: `react-dom@${version}`,
+                entry: `https://cdn.jsdelivr.net/npm/react-dom@${version}/umd/react-dom.production.min.js`,
+                type: 'var',
+                entryGlobalName: 'ReactDOM'
+            }
+        ]
+    });
+    const React = await runtime.loadRemote(`react@${version}`);
+    const ReactDOM = await runtime.loadRemote(`react-dom@${version}`);
+    return {
+        React,
+        ReactDOM
+    };
+}
+function parseVersion(version) {
+    const cleaned = version.replace(/^v/i, '');
+    const parts = cleaned.split(/[-+]/);
+    const [major, minor, patch] = parts[0].split('.').map(Number);
+    return {
+        major: isNaN(major) ? 0 : major,
+        minor: isNaN(minor) ? 0 : minor,
+        patch: isNaN(patch) ? 0 : patch,
+        prerelease: parts[1],
+        build: parts[2],
+        raw: cleaned
+    };
+}
+function compareVersions(v1, v2) {
+    const p1 = parseVersion(v1);
+    const p2 = parseVersion(v2);
+    if (p1.major !== p2.major) return p1.major - p2.major;
+    if (p1.minor !== p2.minor) return p1.minor - p2.minor;
+    if (p1.patch !== p2.patch) return p1.patch - p2.patch;
+    if (p1.prerelease && !p2.prerelease) return -1;
+    if (!p1.prerelease && p2.prerelease) return 1;
+    if (p1.prerelease && p2.prerelease) return p1.prerelease.localeCompare(p2.prerelease);
+    return 0;
+}
+function satisfiesVersion(current, required) {
+    const opMatch = required.match(/^(>=|<=|>|<|=|~|\^)?/);
+    const operator = opMatch?.[1] || '=';
+    const version = required.replace(/^(>=|<=|>|<|=|~|\^)/, '');
+    const cmp = compareVersions(current, version);
+    switch(operator){
+        case '>':
+            return cmp > 0;
+        case '>=':
+            return cmp >= 0;
+        case '<':
+            return cmp < 0;
+        case '<=':
+            return cmp <= 0;
+        case '=':
+        case '':
+            return 0 === cmp;
+        case '^':
+            return parseVersion(current).major === parseVersion(version).major && (parseVersion(current).major > 0 || parseVersion(current).minor === parseVersion(version).minor);
+        case '~':
+            return parseVersion(current).major === parseVersion(version).major && parseVersion(current).minor === parseVersion(version).minor;
+        default:
+            return 0 === cmp;
+    }
+}
+function checkVersionCompatibility(currentVersion, requiredVersion, packageName) {
+    const isCompatible = satisfiesVersion(currentVersion, requiredVersion);
+    const current = parseVersion(currentVersion);
+    const required = parseVersion(requiredVersion);
+    let message;
+    let suggestion;
+    let severity;
+    if (isCompatible) {
+        message = `${packageName}@${currentVersion} 满足要求 ${requiredVersion}`;
+        severity = 'info';
+    } else {
+        const cmp = compareVersions(currentVersion, requiredVersion);
+        if (cmp < 0) {
+            message = `${packageName}@${currentVersion} 版本过低，需要 ${requiredVersion}`;
+            severity = 'error';
+            current.patch;
+            current.major, current.minor;
+            suggestion = `建议升级到 ${current.major}.${current.minor}.x 或更高版本`;
+        } else {
+            message = `${packageName}@${currentVersion} 版本过高，需要 ${requiredVersion}`;
+            severity = 'warning';
+            suggestion = `建议降级到 ${required.major}.${required.minor}.x 或匹配主版本的兼容版本`;
+        }
+    }
+    return {
+        compatible: isCompatible,
+        currentVersion,
+        requiredVersion,
+        suggestion,
+        severity,
+        message
+    };
+}
+function findCompatibleVersion(availableVersions, range) {
+    let candidates = availableVersions;
+    if (range.exact) candidates = candidates.filter((v)=>v === range.exact);
+    else {
+        if (range.min) candidates = candidates.filter((v)=>compareVersions(v, range.min) >= 0);
+        if (range.max) candidates = candidates.filter((v)=>compareVersions(v, range.max) <= 0);
+    }
+    if (0 === candidates.length) return null;
+    return candidates.sort((a, b)=>compareVersions(b, a))[0];
+}
+function getCompatibleReactVersions(hostVersion) {
+    const host = parseVersion(hostVersion);
+    const versions = [];
+    for(let i = host.major; i >= 15; i--)for(let j = 0; j <= 5; j++){
+        const version = `${i}.${j}.0`;
+        if (checkVersionCompatibility(version, `^${host.major}.0.0`, 'react').compatible) versions.push(version);
+    }
+    const uniqueVersions = [];
+    const seen = new Set();
+    for (const v of versions)if (!seen.has(v)) {
+        seen.add(v);
+        uniqueVersions.push(v);
+    }
+    return uniqueVersions;
+}
+async function fetchAvailableVersions(pkg) {
+    try {
+        const res = await fetch(`https://registry.npmjs.org/${pkg}`);
+        if (!res.ok) return [];
+        const data = await res.json();
+        return Object.keys(data.versions || {});
+    } catch  {
+        return [];
+    }
+}
+function sortVersions(versions, order = 'desc') {
+    return [
+        ...versions
+    ].sort((a, b)=>{
+        const cmp = compareVersions(a, b);
+        return 'desc' === order ? -cmp : cmp;
+    });
+}
+function getLatestVersion(versions) {
+    if (0 === versions.length) return null;
+    return sortVersions(versions, 'desc')[0];
+}
+function getStableVersions(versions) {
+    return versions.filter((v)=>!v.includes('alpha') && !v.includes('beta') && !v.includes('rc'));
+}
+function extractMajorVersion(version) {
+    return parseVersion(version).major;
+}
+function isPrerelease(version) {
+    const v = parseVersion(version);
+    return !!v.prerelease;
+}
 const fallbackPlugin = ()=>({
         name: 'fallback-plugin',
         errorLoadRemote (args) {
@@ -35,29 +254,95 @@ const fallbackPlugin = ()=>({
             return fallback;
         }
     });
+const DEFAULT_CDN_TEMPLATES = [
+    'https://cdn.jsdelivr.net/npm/{pkg}@{version}/dist/remoteEntry.js',
+    'https://unpkg.com/{pkg}@{version}/dist/remoteEntry.js'
+];
+const DEFAULT_SHARED_CONFIG = {
+    react: {
+        shareConfig: {
+            singleton: true,
+            eager: true,
+            requiredVersion: false
+        }
+    },
+    'react-dom': {
+        shareConfig: {
+            singleton: true,
+            eager: true,
+            requiredVersion: false
+        }
+    }
+};
 async function fetchLatestVersion(pkg) {
     const res = await fetch(`https://registry.npmjs.org/${pkg}`);
-    if (!res.ok) throw new Error(`无法获取 ${pkg} 的版本信息`);
+    if (!res.ok) throw new Error(`[MF] 无法获取 ${pkg} 的版本信息，状态码：${res.status}`);
     const data = await res.json();
-    return data['dist-tags']?.latest;
+    const latest = data['dist-tags']?.latest;
+    if (!latest) throw new Error(`[MF] 无法从 NPM 获取 ${pkg} 的 latest tag`);
+    return latest;
 }
 function getVersionCache() {
     try {
-        return JSON.parse(localStorage.getItem('mf-multi-version') || '{}');
-    } catch  {
+        const cacheStr = localStorage.getItem('mf-multi-version');
+        return cacheStr ? JSON.parse(cacheStr) : {};
+    } catch (e) {
+        console.error('[MF Cache] 读取缓存失败:', e);
         return {};
     }
 }
 function setVersionCache(pkg, version) {
-    const cache = getVersionCache();
-    cache[pkg] = cache[pkg] || {};
-    cache[pkg][version] = {
-        timestamp: Date.now()
+    try {
+        const cache = getVersionCache();
+        cache[pkg] = cache[pkg] || {};
+        cache[pkg][version] = {
+            timestamp: Date.now()
+        };
+        localStorage.setItem('mf-multi-version', JSON.stringify(cache));
+    } catch (e) {
+        console.error('[MF Cache] 写入缓存失败:', e);
+    }
+}
+function buildCdnUrls(pkg, version) {
+    return DEFAULT_CDN_TEMPLATES.map((template)=>template.replace('{pkg}', pkg).replace('{version}', version));
+}
+async function tryLoadRemote(scopeName, url, retries, delay, sharedConfig, plugins) {
+    let lastError;
+    for(let i = 0; i < retries; i++)try {
+        const mf = (0, runtime_namespaceObject.createInstance)({
+            name: 'host',
+            remotes: [
+                {
+                    name: scopeName,
+                    entry: url
+                }
+            ],
+            shared: sharedConfig,
+            plugins: [
+                ...plugins,
+                fallbackPlugin()
+            ]
+        });
+        return {
+            scopeName,
+            mf
+        };
+    } catch (e) {
+        lastError = e;
+        console.warn(`[MF] URL ${url} 加载失败，第 ${i + 1} 次重试...`);
+        if (i < retries - 1) await new Promise((res)=>setTimeout(res, delay));
+    }
+    throw new Error(`[MF] URL ${url} 经过 ${retries} 次重试仍加载失败。`, {
+        cause: lastError
+    });
+}
+function getFinalSharedConfig(customShared) {
+    return {
+        ...DEFAULT_SHARED_CONFIG,
+        ...customShared || {}
     };
-    localStorage.setItem('mf-multi-version', JSON.stringify(cache));
 }
-async function loadRemoteMultiVersion(options, plugins) {
-    const { name, pkg, version = 'latest', retries = 3, delay = 1000, localFallback, cacheTTL = 86400000, revalidate = true } = options;
+async function resolveFinalVersion(pkg, version, cacheTTL, revalidate) {
     let finalVersion = version;
     if ('latest' === version) {
         const cache = getVersionCache();
@@ -66,61 +351,808 @@ async function loadRemoteMultiVersion(options, plugins) {
         if (latestCached && Date.now() - versions[latestCached].timestamp < cacheTTL) {
             finalVersion = latestCached;
             if (revalidate) fetchLatestVersion(pkg).then((latest)=>{
-                if (latest !== latestCached) setVersionCache(pkg, latest);
-            }).catch(()=>{});
+                if (latest !== latestCached) {
+                    console.log(`[MF] 发现 ${pkg} 新版本 ${latest}，已更新缓存。`);
+                    setVersionCache(pkg, latest);
+                }
+            }).catch((e)=>console.error(`[MF] 异步检查最新版本失败:`, e));
         } else {
             finalVersion = await fetchLatestVersion(pkg);
             setVersionCache(pkg, finalVersion);
         }
     }
-    const scopeName = `${name}`;
-    const urls = [
-        `https://cdn.jsdelivr.net/npm/${pkg}@${finalVersion}/dist/remoteEntry.js`,
-        `https://unpkg.com/${pkg}@${finalVersion}/dist/remoteEntry.js`
-    ];
+    return finalVersion;
+}
+function buildFinalUrls(pkg, version, localFallback) {
+    const urls = buildCdnUrls(pkg, version);
     if (localFallback) urls.push(localFallback);
-    for (const url of urls)for(let i = 0; i < retries; i++)try {
-        const mf = (0, runtime_namespaceObject.createInstance)({
-            name: 'host',
-            remotes: [
-                {
-                    name: scopeName,
-                    entry: url
-                }
-            ],
-            shared: {
-                react: {
-                    shareConfig: {
-                        singleton: true,
-                        eager: true,
-                        requiredVersion: false
-                    }
-                },
-                'react-dom': {
-                    shareConfig: {
-                        singleton: true,
-                        eager: true,
-                        requiredVersion: false
-                    }
+    return urls;
+}
+async function loadRemoteMultiVersion(options, plugins) {
+    const { name, pkg, version = 'latest', retries = 3, delay = 1000, localFallback, cacheTTL = 86400000, revalidate = true, shared: customShared } = options;
+    const finalVersion = await resolveFinalVersion(pkg, version, cacheTTL, revalidate);
+    const scopeName = `${name}`;
+    const urls = buildFinalUrls(pkg, finalVersion, localFallback);
+    const finalSharedConfig = getFinalSharedConfig(customShared);
+    for (const url of urls)try {
+        return await tryLoadRemote(scopeName, url, retries, delay, finalSharedConfig, plugins);
+    } catch (e) {
+        console.warn(`[MF] 切换 CDN 路径：${url} 失败，尝试下一个...`, e);
+    }
+    throw new Error(`[MF] 所有加载源 (${urls.length} 个) 均加载失败。`);
+}
+const preloadCache = {};
+const PRELOAD_CACHE_TTL = 300000;
+function getCachedPreload(pkg, version) {
+    const cached = preloadCache[pkg];
+    if (!cached) return null;
+    if (cached.version !== version) return null;
+    if (Date.now() - cached.timestamp > PRELOAD_CACHE_TTL) {
+        delete preloadCache[pkg];
+        return null;
+    }
+    return {
+        scopeName: cached.scopeName,
+        mf: cached.mf
+    };
+}
+function setCachedPreload(pkg, version, scopeName, mf) {
+    preloadCache[pkg] = {
+        version,
+        scopeName,
+        mf,
+        timestamp: Date.now()
+    };
+}
+function executeWhenIdle(callback) {
+    if ('undefined' != typeof requestIdleCallback) requestIdleCallback(()=>callback());
+    else setTimeout(callback, 1);
+}
+async function preloadRemote(options) {
+    const { pkg, version = 'latest', priority = 'idle', force = false } = options;
+    if (!force) {
+        const cached = getCachedPreload(pkg, version);
+        if (cached) return cached;
+    }
+    const preloadTask = async ()=>{
+        try {
+            const { scopeName, mf } = await loadRemoteMultiVersion(options, []);
+            setCachedPreload(pkg, version, scopeName, mf);
+            return {
+                scopeName,
+                mf
+            };
+        } catch (e) {
+            console.warn(`[MF Preload] 预加载失败 ${pkg}@${version}:`, e);
+            return null;
+        }
+    };
+    if ('high' === priority) return preloadTask();
+    return new Promise((resolve)=>{
+        executeWhenIdle(async ()=>{
+            const result = await preloadTask();
+            resolve(result);
+        });
+    });
+}
+function preloadRemoteList(optionsList, onProgress) {
+    let loaded = 0;
+    const total = optionsList.length;
+    const promises = optionsList.map((options)=>preloadRemote(options).then((result)=>{
+            loaded++;
+            onProgress?.(loaded, total);
+            return result;
+        }));
+    return Promise.all(promises);
+}
+function cancelPreload(pkg) {
+    const cached = preloadCache[pkg];
+    if (cached) delete preloadCache[pkg];
+}
+function clearPreloadCache() {
+    Object.keys(preloadCache).forEach((pkg)=>delete preloadCache[pkg]);
+}
+function getPreloadStatus(pkg) {
+    const cached = preloadCache[pkg];
+    if (!cached) return null;
+    return {
+        loaded: true,
+        timestamp: cached.timestamp
+    };
+}
+const remoteInstances = new Map();
+function generateInstanceKey(name, pkg, version) {
+    return `${name}::${pkg}@${version}`;
+}
+async function unloadRemote(options) {
+    const { name, pkg, version = '*', clearCache = false } = options;
+    const keysToDelete = [];
+    remoteInstances.forEach((instance, key)=>{
+        const versionMatch = '*' === version || instance.version === version;
+        const pkgMatch = instance.pkg === pkg;
+        const nameMatch = instance.name === name;
+        if (nameMatch && pkgMatch && versionMatch) keysToDelete.push(key);
+    });
+    for (const key of keysToDelete){
+        const instance = remoteInstances.get(key);
+        if (instance) {
+            await cleanupInstance(instance);
+            remoteInstances.delete(key);
+        }
+    }
+    if (clearCache) clearVersionCache(pkg, version);
+    return keysToDelete.length > 0;
+}
+async function cleanupInstance(instance) {
+    try {
+        instance.loadedModules.clear();
+        if (instance.mf && 'function' == typeof instance.mf.cleanup) await instance.mf.cleanup();
+        console.log(`[MF Unload] 已卸载 ${instance.pkg}@${instance.version}`);
+    } catch (e) {
+        console.warn(`[MF Unload] 卸载时出错 ${instance.pkg}:`, e);
+    }
+}
+function clearVersionCache(pkg, version) {
+    try {
+        const cacheKey = 'mf-multi-version';
+        const cacheStr = localStorage.getItem(cacheKey);
+        if (!cacheStr) return;
+        const cache = JSON.parse(cacheStr);
+        if (!cache[pkg]) return;
+        if ('*' === version) delete cache[pkg];
+        else delete cache[pkg][version];
+        localStorage.setItem(cacheKey, JSON.stringify(cache));
+        console.log(`[MF Unload] 已清除版本缓存 ${pkg}@${version}`);
+    } catch (e) {
+        console.warn('[MF Unload] 清除缓存失败:', e);
+    }
+}
+function registerRemoteInstance(name, scopeName, pkg, version, mf) {
+    const key = generateInstanceKey(name, pkg, version);
+    const instance = {
+        name,
+        scopeName,
+        pkg,
+        version,
+        mf,
+        loadedModules: new Set(),
+        timestamp: Date.now()
+    };
+    remoteInstances.set(key, instance);
+    return key;
+}
+function registerLoadedModule(key, moduleId) {
+    const instance = remoteInstances.get(key);
+    if (instance) instance.loadedModules.add(moduleId);
+}
+function unloadAll(clearAllCache = false) {
+    return new Promise((resolve)=>{
+        const keys = Array.from(remoteInstances.keys());
+        if (0 === keys.length) return void resolve();
+        let completed = 0;
+        keys.forEach(async (key)=>{
+            const instance = remoteInstances.get(key);
+            if (instance) {
+                await cleanupInstance(instance);
+                remoteInstances.delete(key);
+            }
+            completed++;
+            if (completed >= keys.length) {
+                if (clearAllCache) try {
+                    localStorage.removeItem('mf-multi-version');
+                } catch (e) {
+                    console.warn('[MF Unload] 清除所有缓存失败:', e);
                 }
-            },
-            plugins: [
-                ...plugins,
-                fallbackPlugin()
-            ]
+                resolve();
+            }
         });
+    });
+}
+function getLoadedRemotes() {
+    const result = [];
+    remoteInstances.forEach((instance)=>{
+        result.push({
+            name: instance.name,
+            pkg: instance.pkg,
+            version: instance.version,
+            loadedModules: instance.loadedModules.size,
+            timestamp: instance.timestamp
+        });
+    });
+    return result;
+}
+function isRemoteLoaded(name, pkg, version) {
+    const key = generateInstanceKey(name, pkg, version || '*');
+    return remoteInstances.has(key);
+}
+const CDN_URLS = [
+    'https://cdn.jsdelivr.net/npm/{pkg}@{version}/dist/remoteEntry.js',
+    'https://unpkg.com/{pkg}@{version}/dist/remoteEntry.js'
+];
+async function checkCdnAccess(cdnUrl) {
+    const start = performance.now();
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(()=>controller.abort(), 5000);
+        const res = await fetch(cdnUrl, {
+            method: 'HEAD',
+            signal: controller.signal
+        });
+        clearTimeout(timeout);
+        const latency = Math.round(performance.now() - start);
         return {
-            scopeName,
-            mf
+            reachable: res.ok,
+            latency
+        };
+    } catch (e) {
+        const latency = Math.round(performance.now() - start);
+        return {
+            reachable: false,
+            latency
         };
+    }
+}
+async function health_fetchLatestVersion(pkg) {
+    try {
+        const res = await fetch(`https://registry.npmjs.org/${pkg}`);
+        if (!res.ok) return null;
+        const data = await res.json();
+        return data['dist-tags']?.latest || null;
     } catch  {
-        await new Promise((res)=>setTimeout(res, delay));
+        return null;
+    }
+}
+async function checkRemoteHealth(options) {
+    const { pkg, version = 'latest' } = options;
+    const actualVersion = 'latest' === version ? await health_fetchLatestVersion(pkg) || version : version;
+    const results = [];
+    for (const template of CDN_URLS){
+        const url = template.replace('{pkg}', pkg).replace('{version}', actualVersion);
+        const result = await checkCdnAccess(url);
+        results.push({
+            cdn: url,
+            ...result
+        });
+    }
+    const workingCdn = results.find((r)=>r.reachable);
+    const bestCdn = results.sort((a, b)=>a.latency - b.latency)[0];
+    let status = 'unhealthy';
+    if (workingCdn) status = bestCdn.latency < 1000 ? 'healthy' : 'degraded';
+    return {
+        pkg,
+        version: actualVersion,
+        status,
+        latency: bestCdn?.latency || 0,
+        cdn: bestCdn?.cdn || '',
+        details: {
+            cdnReachable: !!workingCdn,
+            remoteEntryValid: false,
+            modulesLoadable: false
+        }
+    };
+}
+async function checkModuleLoadable(scopeName, modulePath, mf) {
+    try {
+        if (!mf || 'function' != typeof mf.loadRemote) return false;
+        const mod = await mf.loadRemote(`${scopeName}/${modulePath}`);
+        return null != mod;
+    } catch  {
+        return false;
+    }
+}
+async function getRemoteHealthReport(remotes) {
+    const results = await Promise.all(remotes.map((r)=>checkRemoteHealth(r)));
+    let overall = 'healthy';
+    if (results.some((r)=>'unhealthy' === r.status)) overall = 'unhealthy';
+    else if (results.some((r)=>'degraded' === r.status)) overall = 'degraded';
+    return {
+        timestamp: Date.now(),
+        overall,
+        remotes: results
+    };
+}
+function formatHealthStatus(status) {
+    const icons = {
+        healthy: '🟢',
+        degraded: '🟡',
+        unhealthy: '🔴'
+    };
+    return `${icons[status]} ${status}`;
+}
+class EventBusClass {
+    listeners = new Map();
+    eventHistory = new Map();
+    maxHistorySize = 100;
+    generateId() {
+        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
     }
-    throw new Error(`[MF] 所有 CDN 加载失败: ${urls.join(', ')}`);
+    on(event, callback, options) {
+        const onceValue = options?.once ?? false;
+        if (!this.listeners.has(event)) this.listeners.set(event, new Set());
+        const subscription = {
+            callback,
+            once: onceValue,
+            filter: options?.filter
+        };
+        this.listeners.get(event).add(subscription);
+        return ()=>{
+            this.off(event, callback);
+        };
+    }
+    once(event, callback) {
+        return this.on(event, callback, {
+            once: true
+        });
+    }
+    off(event, callback) {
+        if (!this.listeners.has(event)) return;
+        if (callback) {
+            const subscriptions = this.listeners.get(event);
+            subscriptions.forEach((sub)=>{
+                if (sub.callback === callback) subscriptions.delete(sub);
+            });
+        } else this.listeners.delete(event);
+    }
+    emit(event, data, meta) {
+        const eventMeta = {
+            timestamp: Date.now(),
+            source: meta?.source,
+            id: meta?.id || this.generateId()
+        };
+        this.addToHistory(event, data, eventMeta);
+        const subscriptions = this.listeners.get(event);
+        if (!subscriptions) return;
+        const toRemove = [];
+        subscriptions.forEach((sub)=>{
+            if (sub.filter && !sub.filter(data, eventMeta)) return;
+            try {
+                sub.callback(data, eventMeta);
+            } catch (e) {
+                console.error(`[MF EventBus] 事件 ${event} 处理出错:`, e);
+            }
+            if (sub.once) toRemove.push(sub);
+        });
+        toRemove.forEach((sub)=>subscriptions.delete(sub));
+    }
+    addToHistory(event, data, meta) {
+        if (!this.eventHistory.has(event)) this.eventHistory.set(event, []);
+        const history = this.eventHistory.get(event);
+        history.push({
+            data,
+            meta
+        });
+        if (history.length > this.maxHistorySize) history.shift();
+    }
+    getHistory(event) {
+        return this.eventHistory.get(event) || [];
+    }
+    getEvents() {
+        return Array.from(this.listeners.keys());
+    }
+    getListenerCount(event) {
+        return this.listeners.get(event)?.size || 0;
+    }
+    hasListeners(event) {
+        return this.listeners.has(event) && this.listeners.get(event).size > 0;
+    }
+    clear(event) {
+        if (event) {
+            this.listeners.delete(event);
+            this.eventHistory.delete(event);
+        } else {
+            this.listeners.clear();
+            this.eventHistory.clear();
+        }
+    }
+    listenerExists(event, callback) {
+        const subscriptions = this.listeners.get(event);
+        if (!subscriptions) return false;
+        let exists = false;
+        subscriptions.forEach((sub)=>{
+            if (sub.callback === callback) exists = true;
+        });
+        return exists;
+    }
+    emitAsync(event, data, meta) {
+        return new Promise((resolve)=>{
+            this.emit(event, data, meta);
+            resolve();
+        });
+    }
+    static create() {
+        return new EventBusClass();
+    }
+}
+const eventBus = EventBusClass.create();
+function createEventBus() {
+    return EventBusClass.create();
+}
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
+class ErrorBoundary extends external_react_default().Component {
+    constructor(props){
+        super(props);
+        this.state = {
+            hasError: false,
+            error: null,
+            errorInfo: null
+        };
+    }
+    static getDerivedStateFromError(error) {
+        return {
+            hasError: true,
+            error,
+            errorInfo: null
+        };
+    }
+    componentDidCatch(error, errorInfo) {
+        this.setState({
+            errorInfo
+        });
+        this.props.onError?.(error, errorInfo);
+        console.error('[RemoteReloadUtils] ErrorBoundary caught error:', error, errorInfo);
+    }
+    handleReset = ()=>{
+        this.setState({
+            hasError: false,
+            error: null,
+            errorInfo: null
+        });
+        this.props.onReset?.();
+    };
+    render() {
+        if (this.state.hasError && this.state.error) {
+            if ('function' == typeof this.props.fallback) return this.props.fallback(this.state.error, this.handleReset);
+            if (void 0 !== this.props.fallback) return this.props.fallback;
+            return /*#__PURE__*/ external_react_default().createElement("div", {
+                role: "alert",
+                style: {
+                    padding: '16px',
+                    border: '1px solid #ffcccc',
+                    backgroundColor: '#fff5f5',
+                    borderRadius: '4px'
+                }
+            }, /*#__PURE__*/ external_react_default().createElement("h3", null, "Something went wrong"), /*#__PURE__*/ external_react_default().createElement("p", null, this.state.error.message), /*#__PURE__*/ external_react_default().createElement("button", {
+                onClick: this.handleReset,
+                style: {
+                    marginTop: '8px',
+                    padding: '8px 16px',
+                    cursor: 'pointer'
+                }
+            }, "Try again"));
+        }
+        return this.props.children;
+    }
+}
+function useRemoteModule({ pkg, version, moduleName, scopeName, onError, onLoad }) {
+    const [moduleState, setModuleState] = (0, external_react_namespaceObject.useState)({
+        loading: true,
+        error: null,
+        component: null
+    });
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        let mounted = true;
+        async function loadModule() {
+            try {
+                setModuleState((prev)=>({
+                        ...prev,
+                        loading: true,
+                        error: null
+                    }));
+                const { mf } = await loadRemoteMultiVersion({
+                    name: scopeName,
+                    pkg,
+                    version
+                }, []);
+                if (!mf || !mounted) return;
+                const mod = await mf.loadRemote(`${scopeName}/${moduleName}`);
+                if (!mounted) return;
+                if (mod && 'object' == typeof mod && 'default' in mod) {
+                    const Component = mod.default;
+                    setModuleState({
+                        loading: false,
+                        error: null,
+                        component: Component
+                    });
+                    onLoad?.(Component);
+                } else throw new Error(`Module "${scopeName}/${moduleName}" does not export a default component`);
+            } catch (err) {
+                if (mounted) {
+                    const error = err instanceof Error ? err : new Error(String(err));
+                    setModuleState({
+                        loading: false,
+                        error,
+                        component: null
+                    });
+                    onError?.(error);
+                }
+            }
+        }
+        loadModule();
+        return ()=>{
+            mounted = false;
+        };
+    }, [
+        pkg,
+        version,
+        moduleName,
+        scopeName,
+        onError,
+        onLoad
+    ]);
+    return moduleState;
+}
+function RemoteModuleCardContent({ pkg, version, moduleName, scopeName, loadingFallback, errorFallback, componentProps, className, style, onError, onLoad }) {
+    const moduleState = useRemoteModule({
+        pkg,
+        version,
+        moduleName,
+        scopeName,
+        onError,
+        onLoad
+    });
+    const [retryCount, setRetryCount] = (0, external_react_namespaceObject.useState)(0);
+    const handleRetry = (0, external_react_namespaceObject.useCallback)(()=>{
+        setRetryCount((prev)=>prev + 1);
+    }, []);
+    (0, external_react_namespaceObject.useEffect)(()=>{}, [
+        retryCount
+    ]);
+    if (moduleState.loading) return /*#__PURE__*/ external_react_default().createElement("div", {
+        className: className,
+        style: style,
+        role: "status",
+        "aria-live": "polite"
+    }, loadingFallback || /*#__PURE__*/ external_react_default().createElement("div", {
+        className: "module-card module-card--loading"
+    }, /*#__PURE__*/ external_react_default().createElement("div", {
+        className: "loading-spinner",
+        "aria-hidden": "true"
+    }), /*#__PURE__*/ external_react_default().createElement("span", null, "Loading ", moduleName, "...")));
+    if (moduleState.error) {
+        if ('function' == typeof errorFallback) return /*#__PURE__*/ external_react_default().createElement(external_react_default().Fragment, null, errorFallback(moduleState.error, handleRetry));
+        if (void 0 !== errorFallback) return /*#__PURE__*/ external_react_default().createElement(external_react_default().Fragment, null, errorFallback);
+        return /*#__PURE__*/ external_react_default().createElement("div", {
+            className: className,
+            style: style,
+            role: "alert"
+        }, /*#__PURE__*/ external_react_default().createElement("div", {
+            className: "module-card module-card--error"
+        }, /*#__PURE__*/ external_react_default().createElement("span", {
+            className: "error-icon",
+            "aria-hidden": "true"
+        }, "!"), /*#__PURE__*/ external_react_default().createElement("span", null, "Failed to load ", moduleName), /*#__PURE__*/ external_react_default().createElement("p", {
+            className: "error-message"
+        }, moduleState.error.message), /*#__PURE__*/ external_react_default().createElement("button", {
+            onClick: handleRetry,
+            className: "retry-button",
+            type: "button"
+        }, "Retry")));
+    }
+    if (!moduleState.component) return null;
+    const Component = moduleState.component;
+    return /*#__PURE__*/ external_react_default().createElement("div", {
+        className: className,
+        style: style
+    }, /*#__PURE__*/ external_react_default().createElement(Component, componentProps));
+}
+function RemoteModuleCard(props) {
+    const { disableErrorBoundary, errorFallback, loadingFallback, errorBoundaryOptions } = props;
+    if (disableErrorBoundary) return /*#__PURE__*/ external_react_default().createElement(external_react_namespaceObject.Suspense, {
+        fallback: loadingFallback || /*#__PURE__*/ external_react_default().createElement("div", null, "Loading...")
+    }, /*#__PURE__*/ external_react_default().createElement(RemoteModuleCardContent, props));
+    return /*#__PURE__*/ external_react_default().createElement(ErrorBoundary, {
+        fallback: errorFallback,
+        onError: errorBoundaryOptions?.onError,
+        onReset: errorBoundaryOptions?.onReset
+    }, /*#__PURE__*/ external_react_default().createElement(external_react_namespaceObject.Suspense, {
+        fallback: loadingFallback || /*#__PURE__*/ external_react_default().createElement("div", null, "Loading...")
+    }, /*#__PURE__*/ external_react_default().createElement(RemoteModuleCardContent, props)));
+}
+function lazyRemote(options) {
+    const { pkg, version = 'latest', moduleName, scopeName, maxRetries = 3, retryDelay = 1000 } = options;
+    let retryCount = 0;
+    const loadComponent = async ()=>{
+        try {
+            const { mf } = await loadRemoteMultiVersion({
+                name: scopeName,
+                pkg,
+                version
+            }, []);
+            if (!mf) throw new Error(`[RemoteReloadUtils] Failed to get Module Federation instance for ${scopeName}`);
+            const mod = await mf.loadRemote(`${scopeName}/${moduleName}`);
+            if (!mod || 'object' != typeof mod || !('default' in mod)) throw new Error(`[RemoteReloadUtils] Module "${scopeName}/${moduleName}" does not export a default component`);
+            return {
+                default: mod.default
+            };
+        } catch (error) {
+            if (retryCount < maxRetries) {
+                retryCount++;
+                await new Promise((resolve)=>setTimeout(resolve, retryDelay * retryCount));
+                return loadComponent();
+            }
+            throw error;
+        }
+    };
+    return /*#__PURE__*/ (0, external_react_namespaceObject.lazy)(loadComponent);
+}
+function SuspenseRemote({ fallback, children }) {
+    return /*#__PURE__*/ external_react_default().createElement(external_react_namespaceObject.Suspense, {
+        fallback: fallback || /*#__PURE__*/ external_react_default().createElement("div", null, "Loading...")
+    }, children);
+}
+function SuspenseRemoteLoader({ pkg, version = 'latest', moduleName, scopeName, fallback, errorFallback, componentProps }) {
+    const RemoteComponent = lazyRemote({
+        pkg,
+        version,
+        moduleName,
+        scopeName
+    });
+    if (errorFallback) return /*#__PURE__*/ external_react_default().createElement(ErrorBoundary, {
+        fallback: errorFallback
+    }, /*#__PURE__*/ external_react_default().createElement(external_react_namespaceObject.Suspense, {
+        fallback: fallback || /*#__PURE__*/ external_react_default().createElement("div", null, "Loading...")
+    }, /*#__PURE__*/ external_react_default().createElement(RemoteComponent, componentProps)));
+    return /*#__PURE__*/ external_react_default().createElement(external_react_namespaceObject.Suspense, {
+        fallback: fallback || /*#__PURE__*/ external_react_default().createElement("div", null, "Loading...")
+    }, /*#__PURE__*/ external_react_default().createElement(RemoteComponent, componentProps));
+}
+function withRemote(WrappedComponent, options) {
+    const RemoteComponent = lazyRemote(options);
+    return function(props) {
+        return /*#__PURE__*/ external_react_default().createElement(external_react_namespaceObject.Suspense, {
+            fallback: /*#__PURE__*/ external_react_default().createElement("div", null, "Loading...")
+        }, /*#__PURE__*/ external_react_default().createElement(RemoteComponent, props));
+    };
+}
+function useRemoteModuleHook(options) {
+    const { pkg, version = 'latest', moduleName, scopeName } = options;
+    const [state, setState] = (0, external_react_namespaceObject.useState)({
+        component: null,
+        loading: true,
+        error: null
+    });
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        let mounted = true;
+        async function load() {
+            try {
+                setState((prev)=>({
+                        ...prev,
+                        loading: true,
+                        error: null
+                    }));
+                const { mf } = await loadRemoteMultiVersion({
+                    name: scopeName,
+                    pkg,
+                    version
+                }, []);
+                if (!mf) throw new Error(`[RemoteReloadUtils] Failed to get Module Federation instance for ${scopeName}`);
+                const mod = await mf.loadRemote(`${scopeName}/${moduleName}`);
+                if (mounted) if (mod && 'object' == typeof mod && 'default' in mod) setState({
+                    component: mod.default,
+                    loading: false,
+                    error: null
+                });
+                else throw new Error(`[RemoteReloadUtils] Module "${scopeName}/${moduleName}" does not export a default component`);
+            } catch (err) {
+                if (mounted) setState({
+                    component: null,
+                    loading: false,
+                    error: err instanceof Error ? err : new Error(String(err))
+                });
+            }
+        }
+        load();
+        return ()=>{
+            mounted = false;
+        };
+    }, [
+        pkg,
+        version,
+        moduleName,
+        scopeName
+    ]);
+    return {
+        component: state.component,
+        loading: state.loading,
+        error: state.error
+    };
 }
+exports.ErrorBoundary = __webpack_exports__.ErrorBoundary;
+exports.RemoteModuleCard = __webpack_exports__.RemoteModuleCard;
+exports.SuspenseRemote = __webpack_exports__.SuspenseRemote;
+exports.SuspenseRemoteLoader = __webpack_exports__.SuspenseRemoteLoader;
+exports.buildCdnUrls = __webpack_exports__.buildCdnUrls;
+exports.buildFinalUrls = __webpack_exports__.buildFinalUrls;
+exports.cancelPreload = __webpack_exports__.cancelPreload;
+exports.checkModuleLoadable = __webpack_exports__.checkModuleLoadable;
+exports.checkRemoteHealth = __webpack_exports__.checkRemoteHealth;
+exports.checkVersionCompatibility = __webpack_exports__.checkVersionCompatibility;
+exports.clearPreloadCache = __webpack_exports__.clearPreloadCache;
+exports.compareVersions = __webpack_exports__.compareVersions;
+exports.createEventBus = __webpack_exports__.createEventBus;
+exports.eventBus = __webpack_exports__.eventBus;
+exports.extractMajorVersion = __webpack_exports__.extractMajorVersion;
+exports.fallbackPlugin = __webpack_exports__.fallbackPlugin;
+exports.fetchAvailableVersions = __webpack_exports__.fetchAvailableVersions;
+exports.fetchLatestVersion = __webpack_exports__.fetchLatestVersion;
+exports.findCompatibleVersion = __webpack_exports__.findCompatibleVersion;
+exports.formatHealthStatus = __webpack_exports__.formatHealthStatus;
+exports.getCompatibleReactVersions = __webpack_exports__.getCompatibleReactVersions;
+exports.getFinalSharedConfig = __webpack_exports__.getFinalSharedConfig;
+exports.getLatestVersion = __webpack_exports__.getLatestVersion;
+exports.getLoadedRemotes = __webpack_exports__.getLoadedRemotes;
+exports.getPreloadStatus = __webpack_exports__.getPreloadStatus;
+exports.getRemoteHealthReport = __webpack_exports__.getRemoteHealthReport;
+exports.getStableVersions = __webpack_exports__.getStableVersions;
+exports.getVersionCache = __webpack_exports__.getVersionCache;
+exports.isPrerelease = __webpack_exports__.isPrerelease;
+exports.isRemoteLoaded = __webpack_exports__.isRemoteLoaded;
+exports.lazyRemote = __webpack_exports__.lazyRemote;
+exports.loadReactVersion = __webpack_exports__.loadReactVersion;
 exports.loadRemoteMultiVersion = __webpack_exports__.loadRemoteMultiVersion;
+exports.parseVersion = __webpack_exports__.parseVersion;
+exports.preloadRemote = __webpack_exports__.preloadRemote;
+exports.preloadRemoteList = __webpack_exports__.preloadRemoteList;
+exports.registerLoadedModule = __webpack_exports__.registerLoadedModule;
+exports.registerRemoteInstance = __webpack_exports__.registerRemoteInstance;
+exports.resolveFinalVersion = __webpack_exports__.resolveFinalVersion;
+exports.satisfiesVersion = __webpack_exports__.satisfiesVersion;
+exports.setVersionCache = __webpack_exports__.setVersionCache;
+exports.sortVersions = __webpack_exports__.sortVersions;
+exports.tryLoadRemote = __webpack_exports__.tryLoadRemote;
+exports.unloadAll = __webpack_exports__.unloadAll;
+exports.unloadRemote = __webpack_exports__.unloadRemote;
+exports.useRemoteModuleHook = __webpack_exports__.useRemoteModuleHook;
+exports.withRemote = __webpack_exports__.withRemote;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "loadRemoteMultiVersion"
+    "ErrorBoundary",
+    "RemoteModuleCard",
+    "SuspenseRemote",
+    "SuspenseRemoteLoader",
+    "buildCdnUrls",
+    "buildFinalUrls",
+    "cancelPreload",
+    "checkModuleLoadable",
+    "checkRemoteHealth",
+    "checkVersionCompatibility",
+    "clearPreloadCache",
+    "compareVersions",
+    "createEventBus",
+    "eventBus",
+    "extractMajorVersion",
+    "fallbackPlugin",
+    "fetchAvailableVersions",
+    "fetchLatestVersion",
+    "findCompatibleVersion",
+    "formatHealthStatus",
+    "getCompatibleReactVersions",
+    "getFinalSharedConfig",
+    "getLatestVersion",
+    "getLoadedRemotes",
+    "getPreloadStatus",
+    "getRemoteHealthReport",
+    "getStableVersions",
+    "getVersionCache",
+    "isPrerelease",
+    "isRemoteLoaded",
+    "lazyRemote",
+    "loadReactVersion",
+    "loadRemoteMultiVersion",
+    "parseVersion",
+    "preloadRemote",
+    "preloadRemoteList",
+    "registerLoadedModule",
+    "registerRemoteInstance",
+    "resolveFinalVersion",
+    "satisfiesVersion",
+    "setVersionCache",
+    "sortVersions",
+    "tryLoadRemote",
+    "unloadAll",
+    "unloadRemote",
+    "useRemoteModuleHook",
+    "withRemote"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true