remote-reload-utils 0.0.12 → 0.0.14

package/dist/main.cjs

@@ -1,5 +1,16 @@
-"use strict";
-var __webpack_require__ = {};
+var __webpack_modules__ = {
+    "./src/styles/index.css": function() {}
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
 (()=>{
     __webpack_require__.n = (module)=>{
         var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
@@ -31,1036 +42,1037 @@ var __webpack_require__ = {};
     };
 })();
 var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    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,
-    RemoteModuleRenderer: ()=>RemoteModuleRenderer,
-    clearPreloadCache: ()=>clearPreloadCache,
-    loadRemoteMultiVersion: ()=>loadRemoteMultiVersion,
-    getRemoteHealthReport: ()=>getRemoteHealthReport,
-    checkModuleLoadable: ()=>checkModuleLoadable,
-    getStableVersions: ()=>getStableVersions,
-    extractMajorVersion: ()=>extractMajorVersion,
-    buildCdnUrls: ()=>buildCdnUrls,
-    loadReactVersion: ()=>loadReactVersion,
-    preloadRemoteList: ()=>preloadRemoteList,
-    SuspenseRemoteLoader: ()=>SuspenseRemoteLoader,
-    registerLoadedModule: ()=>registerLoadedModule,
-    getCompatibleReactVersions: ()=>getCompatibleReactVersions,
-    SuspenseRemote: ()=>SuspenseRemote,
-    unloadRemote: ()=>unloadRemote,
-    useRemoteModule: ()=>useRemoteModule,
-    RemoteModuleProvider: ()=>RemoteModuleProvider,
-    cancelPreload: ()=>cancelPreload,
-    findCompatibleVersion: ()=>findCompatibleVersion,
-    getLoadedRemotes: ()=>getLoadedRemotes,
-    getLatestVersion: ()=>getLatestVersion,
-    preloadRemote: ()=>preloadRemote,
-    satisfiesVersion: ()=>satisfiesVersion,
-    formatHealthStatus: ()=>formatHealthStatus,
-    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'
-            }
-        ]
+(()=>{
+    "use strict";
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        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,
+        RemoteModuleRenderer: ()=>RemoteModuleRenderer,
+        clearPreloadCache: ()=>clearPreloadCache,
+        loadRemoteMultiVersion: ()=>loadRemoteMultiVersion,
+        getRemoteHealthReport: ()=>getRemoteHealthReport,
+        checkModuleLoadable: ()=>checkModuleLoadable,
+        getStableVersions: ()=>getStableVersions,
+        extractMajorVersion: ()=>extractMajorVersion,
+        buildCdnUrls: ()=>buildCdnUrls,
+        loadReactVersion: ()=>loadReactVersion,
+        preloadRemoteList: ()=>preloadRemoteList,
+        SuspenseRemoteLoader: ()=>SuspenseRemoteLoader,
+        registerLoadedModule: ()=>registerLoadedModule,
+        getCompatibleReactVersions: ()=>getCompatibleReactVersions,
+        SuspenseRemote: ()=>SuspenseRemote,
+        unloadRemote: ()=>unloadRemote,
+        useRemoteModule: ()=>useRemoteModule,
+        RemoteModuleProvider: ()=>RemoteModuleProvider,
+        cancelPreload: ()=>cancelPreload,
+        findCompatibleVersion: ()=>findCompatibleVersion,
+        getLoadedRemotes: ()=>getLoadedRemotes,
+        getLatestVersion: ()=>getLatestVersion,
+        preloadRemote: ()=>preloadRemote,
+        satisfiesVersion: ()=>satisfiesVersion,
+        formatHealthStatus: ()=>formatHealthStatus,
+        unloadAll: ()=>unloadAll,
+        setVersionCache: ()=>setVersionCache,
+        lazyRemote: ()=>lazyRemote,
+        checkRemoteHealth: ()=>checkRemoteHealth,
+        isPrerelease: ()=>isPrerelease,
+        checkVersionCompatibility: ()=>checkVersionCompatibility
     });
-    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 或匹配主版本的兼容版本`;
-        }
+    __webpack_require__("./src/styles/index.css");
+    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
+        };
     }
-    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);
+    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
+        };
     }
-    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);
+    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;
     }
-    const uniqueVersions = [];
-    const seen = new Set();
-    for (const v of versions)if (!seen.has(v)) {
-        seen.add(v);
-        uniqueVersions.push(v);
+    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;
+        }
     }
-    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 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 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) {
-            const fallback = 'fallback';
-            console.log(args, 'args');
-            return fallback;
+    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);
         }
-    });
-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
+        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);
         }
-    },
-    'react-dom': {
-        shareConfig: {
-            singleton: true,
-            eager: true,
-            requiredVersion: false
+        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 fetchLatestVersion(pkg) {
-    const res = await fetch(`https://registry.npmjs.org/${pkg}`);
-    if (!res.ok) throw new Error(`[MF] 无法获取 ${pkg} 的版本信息，状态码：${res.status}`);
-    const data = await res.json();
-    const latest = data['dist-tags']?.latest;
-    if (!latest) throw new Error(`[MF] 无法从 NPM 获取 ${pkg} 的 latest tag`);
-    return latest;
-}
-function getVersionCache() {
-    try {
-        const cacheStr = localStorage.getItem('mf-multi-version');
-        return cacheStr ? JSON.parse(cacheStr) : {};
-    } catch (e) {
-        console.error('[MF Cache] 读取缓存失败:', e);
-        return {};
-    }
-}
-function setVersionCache(pkg, version) {
-    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);
+    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 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()
-            ]
+    function sortVersions(versions, order = 'desc') {
+        return [
+            ...versions
+        ].sort((a, b)=>{
+            const cmp = compareVersions(a, b);
+            return 'desc' === order ? -cmp : cmp;
         });
-        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 || {}
-    };
-}
-async function resolveFinalVersion(pkg, version, cacheTTL, revalidate) {
-    let finalVersion = version;
-    if ('latest' === version) {
-        const cache = getVersionCache();
-        const versions = cache[pkg] || {};
-        const latestCached = Object.keys(versions).sort((a, b)=>versions[b].timestamp - versions[a].timestamp)[0];
-        if (latestCached && Date.now() - versions[latestCached].timestamp < cacheTTL) {
-            finalVersion = latestCached;
-            if (revalidate) fetchLatestVersion(pkg).then((latest)=>{
-                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);
-        }
+    function getLatestVersion(versions) {
+        if (0 === versions.length) return null;
+        return sortVersions(versions, 'desc')[0];
     }
-    return finalVersion;
-}
-function buildFinalUrls(pkg, version, localFallback) {
-    const urls = buildCdnUrls(pkg, version);
-    if (localFallback) urls.push(localFallback);
-    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);
+    function getStableVersions(versions) {
+        return versions.filter((v)=>!v.includes('alpha') && !v.includes('beta') && !v.includes('rc'));
     }
-    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;
+    function extractMajorVersion(version) {
+        return parseVersion(version).major;
     }
-    return {
-        scopeName: cached.scopeName,
-        mf: cached.mf
-    };
-}
-function setCachedPreload(pkg, version, scopeName, mf) {
-    preloadCache[pkg] = {
-        version,
-        scopeName,
-        mf,
-        timestamp: Date.now()
+    function isPrerelease(version) {
+        const v = parseVersion(version);
+        return !!v.prerelease;
+    }
+    const fallbackPlugin = ()=>({
+            name: 'fallback-plugin',
+            errorLoadRemote (args) {
+                const fallback = 'fallback';
+                console.log(args, 'args');
+                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
+            }
+        }
     };
-}
-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;
+    async function fetchLatestVersion(pkg) {
+        const res = await fetch(`https://registry.npmjs.org/${pkg}`);
+        if (!res.ok) throw new Error(`[MF] 无法获取 ${pkg} 的版本信息，状态码：${res.status}`);
+        const data = await res.json();
+        const latest = data['dist-tags']?.latest;
+        if (!latest) throw new Error(`[MF] 无法从 NPM 获取 ${pkg} 的 latest tag`);
+        return latest;
     }
-    const preloadTask = async ()=>{
+    function getVersionCache() {
         try {
-            const { scopeName, mf } = await loadRemoteMultiVersion(options, []);
-            setCachedPreload(pkg, version, scopeName, mf);
+            const cacheStr = localStorage.getItem('mf-multi-version');
+            return cacheStr ? JSON.parse(cacheStr) : {};
+        } catch (e) {
+            console.error('[MF Cache] 读取缓存失败:', e);
+            return {};
+        }
+    }
+    function setVersionCache(pkg, version) {
+        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) {
-            console.warn(`[MF Preload] 预加载失败 ${pkg}@${version}:`, e);
-            return null;
+            lastError = e;
+            console.warn(`[MF] URL ${url} 加载失败，第 ${i + 1} 次重试...`);
+            if (i < retries - 1) await new Promise((res)=>setTimeout(res, delay));
         }
-    };
-    if ('high' === priority) return preloadTask();
-    return new Promise((resolve)=>{
-        executeWhenIdle(async ()=>{
-            const result = await preloadTask();
-            resolve(result);
+        throw new Error(`[MF] URL ${url} 经过 ${retries} 次重试仍加载失败。`, {
+            cause: lastError
         });
-    });
-}
-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);
+    }
+    function getFinalSharedConfig(customShared) {
+        return {
+            ...DEFAULT_SHARED_CONFIG,
+            ...customShared || {}
+        };
+    }
+    async function resolveFinalVersion(pkg, version, cacheTTL, revalidate) {
+        let finalVersion = version;
+        if ('latest' === version) {
+            const cache = getVersionCache();
+            const versions = cache[pkg] || {};
+            const latestCached = Object.keys(versions).sort((a, b)=>versions[b].timestamp - versions[a].timestamp)[0];
+            if (latestCached && Date.now() - versions[latestCached].timestamp < cacheTTL) {
+                finalVersion = latestCached;
+                if (revalidate) fetchLatestVersion(pkg).then((latest)=>{
+                    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);
+            }
         }
+        return finalVersion;
     }
-    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 buildFinalUrls(pkg, version, localFallback) {
+        const urls = buildCdnUrls(pkg, version);
+        if (localFallback) urls.push(localFallback);
+        return urls;
     }
-}
-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);
+    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} 个) 均加载失败。`);
     }
-}
-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);
-                }
-                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);
+    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 {
-            reachable: res.ok,
-            latency
+            scopeName: cached.scopeName,
+            mf: cached.mf
         };
-    } catch (e) {
-        const latency = Math.round(performance.now() - start);
-        return {
-            reachable: false,
-            latency
+    }
+    function setCachedPreload(pkg, version, scopeName, mf) {
+        preloadCache[pkg] = {
+            version,
+            scopeName,
+            mf,
+            timestamp: Date.now()
         };
     }
-}
-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  {
-        return null;
+    function executeWhenIdle(callback) {
+        if ('undefined' != typeof requestIdleCallback) requestIdleCallback(()=>callback());
+        else setTimeout(callback, 1);
     }
-}
-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
+    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);
+            });
         });
     }
-    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;
+    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);
     }
-}
-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)}`;
+    function cancelPreload(pkg) {
+        const cached = preloadCache[pkg];
+        if (cached) delete preloadCache[pkg];
     }
-    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);
+    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
         };
     }
-    once(event, callback) {
-        return this.on(event, callback, {
-            once: true
+    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;
     }
-    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);
+    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);
+        }
     }
-    emit(event, data, meta) {
-        const eventMeta = {
-            timestamp: Date.now(),
-            source: meta?.source,
-            id: meta?.id || this.generateId()
+    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()
         };
-        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);
+        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);
+                    }
+                    resolve();
+                }
+            });
         });
-        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
+    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
+            });
         });
-        if (history.length > this.maxHistorySize) history.shift();
+        return result;
     }
-    getHistory(event) {
-        return this.eventHistory.get(event) || [];
+    function isRemoteLoaded(name, pkg, version) {
+        const key = generateInstanceKey(name, pkg, version || '*');
+        return remoteInstances.has(key);
     }
-    getEvents() {
-        return Array.from(this.listeners.keys());
+    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 {
+                reachable: res.ok,
+                latency
+            };
+        } catch (e) {
+            const latency = Math.round(performance.now() - start);
+            return {
+                reachable: false,
+                latency
+            };
+        }
     }
-    getListenerCount(event) {
-        return this.listeners.get(event)?.size || 0;
+    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  {
+            return null;
+        }
     }
-    hasListeners(event) {
-        return this.listeners.has(event) && this.listeners.get(event).size > 0;
+    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
+            }
+        };
     }
-    clear(event) {
-        if (event) {
-            this.listeners.delete(event);
-            this.eventHistory.delete(event);
-        } else {
-            this.listeners.clear();
-            this.eventHistory.clear();
+    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;
         }
     }
-    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;
+    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
+        };
     }
-    emitAsync(event, data, meta) {
-        return new Promise((resolve)=>{
-            this.emit(event, data, meta);
-            resolve();
-        });
+    function formatHealthStatus(status) {
+        const icons = {
+            healthy: '🟢',
+            degraded: '🟡',
+            unhealthy: '🔴'
+        };
+        return `${icons[status]} ${status}`;
     }
-    static create() {
-        return new EventBusClass();
+    class EventBusClass {
+        listeners = new Map();
+        eventHistory = new Map();
+        maxHistorySize = 100;
+        generateId() {
+            return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        }
+        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
-        };
+    const eventBus = EventBusClass.create();
+    function createEventBus() {
+        return EventBusClass.create();
     }
-    static getDerivedStateFromError(error) {
-        return {
-            hasError: true,
-            error,
-            errorInfo: null
+    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",
+                    className: "p-4 border border-red-200 bg-red-50 rounded-lg"
+                }, /*#__PURE__*/ external_react_default().createElement("h3", {
+                    className: "text-lg font-semibold mb-2"
+                }, "Something went wrong"), /*#__PURE__*/ external_react_default().createElement("p", {
+                    className: "text-red-700"
+                }, this.state.error.message), /*#__PURE__*/ external_react_default().createElement("button", {
+                    onClick: this.handleReset,
+                    className: "mt-3 px-4 py-2 text-sm font-medium text-white bg-red-600 rounded hover:bg-red-700 cursor-pointer transition-colors"
+                }, "Try again"));
+            }
+            return this.props.children;
+        }
     }
-    componentDidCatch(error, errorInfo) {
-        this.setState({
-            errorInfo
+    function useRemoteModule({ pkg, version, moduleName, scopeName, onError, onLoad, retryKey = 0 }) {
+        const [moduleState, setModuleState] = (0, external_react_namespaceObject.useState)({
+            loading: true,
+            error: null,
+            component: null
         });
-        this.props.onError?.(error, errorInfo);
-        console.error('[RemoteReloadUtils] ErrorBoundary caught error:', error, errorInfo);
+        (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,
+            retryKey
+        ]);
+        return moduleState;
     }
-    handleReset = ()=>{
-        this.setState({
-            hasError: false,
-            error: null,
-            errorInfo: null
+    function RemoteModuleRenderer({ pkg, version, moduleName, scopeName, loadingFallback, errorFallback, componentProps, className, style, onError, onLoad }) {
+        const moduleState = useRemoteModule({
+            pkg,
+            version,
+            moduleName,
+            scopeName,
+            onError,
+            onLoad
         });
-        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;
+        const [retryKey, setRetryKey] = (0, external_react_namespaceObject.useState)(0);
+        const handleRetry = (0, external_react_namespaceObject.useCallback)(()=>{
+            setRetryKey((prev)=>prev + 1);
+        }, []);
+        (0, external_react_namespaceObject.useEffect)(()=>{}, [
+            retryKey
+        ]);
+        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", {
+            className: "text-gray-600"
+        }, "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", {
-                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"));
+                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")));
         }
-        return this.props.children;
+        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 useRemoteModule({ pkg, version, moduleName, scopeName, onError, onLoad, retryKey = 0 }) {
-    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() {
+    function RemoteModuleProvider(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(RemoteModuleRenderer, 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(RemoteModuleRenderer, props)));
+    }
+    function lazyRemote(options) {
+        const { pkg, version = 'latest', moduleName, scopeName, maxRetries = 3, retryDelay = 1000 } = options;
+        let retryCount = 0;
+        const loadComponent = async ()=>{
             try {
-                setModuleState((prev)=>({
-                        ...prev,
-                        loading: true,
-                        error: null
-                    }));
                 const { mf } = await loadRemoteMultiVersion({
                     name: scopeName,
                     pkg,
                     version
                 }, []);
-                if (!mf || !mounted) return;
+                if (!mf) throw new Error(`[RemoteReloadUtils] Failed to get Module Federation instance for ${scopeName}`);
                 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);
+                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;
             }
-        }
-        loadModule();
-        return ()=>{
-            mounted = false;
         };
-    }, [
-        pkg,
-        version,
-        moduleName,
-        scopeName,
-        onError,
-        onLoad,
-        retryKey
-    ]);
-    return moduleState;
-}
-function RemoteModuleRenderer({ pkg, version, moduleName, scopeName, loadingFallback, errorFallback, componentProps, className, style, onError, onLoad }) {
-    const moduleState = useRemoteModule({
-        pkg,
-        version,
-        moduleName,
-        scopeName,
-        onError,
-        onLoad
-    });
-    const [retryKey, setRetryKey] = (0, external_react_namespaceObject.useState)(0);
-    const handleRetry = (0, external_react_namespaceObject.useCallback)(()=>{
-        setRetryKey((prev)=>prev + 1);
-    }, []);
-    (0, external_react_namespaceObject.useEffect)(()=>{}, [
-        retryKey
-    ]);
-    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")));
+        return /*#__PURE__*/ (0, external_react_namespaceObject.lazy)(loadComponent);
     }
-    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 RemoteModuleProvider(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(RemoteModuleRenderer, 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(RemoteModuleRenderer, 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) {
+    function SuspenseRemote({ fallback, children }) {
         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,
+            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
-                    }));
-                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))
-                });
+                    });
+                    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;
+            load();
+            return ()=>{
+                mounted = false;
+            };
+        }, [
+            pkg,
+            version,
+            moduleName,
+            scopeName
+        ]);
+        return {
+            component: state.component,
+            loading: state.loading,
+            error: state.error
         };
-    }, [
-        pkg,
-        version,
-        moduleName,
-        scopeName
-    ]);
-    return {
-        component: state.component,
-        loading: state.loading,
-        error: state.error
-    };
-}
+    }
+})();
 exports.ErrorBoundary = __webpack_exports__.ErrorBoundary;
 exports.RemoteModuleProvider = __webpack_exports__.RemoteModuleProvider;
 exports.RemoteModuleRenderer = __webpack_exports__.RemoteModuleRenderer;