remote-reload-utils 0.0.14 → 0.0.17

package/dist/main.cjs

@@ -1,25 +1,5 @@
-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;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
+"use strict";
+var __webpack_require__ = {};
 (()=>{
     __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, {
@@ -42,1042 +22,916 @@ function __webpack_require__(moduleId) {
     };
 })();
 var __webpack_exports__ = {};
-(()=>{
-    "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
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    compareVersions: ()=>compareVersions,
+    fetchAvailableVersions: ()=>fetchAvailableVersions,
+    sortVersions: ()=>sortVersions,
+    registerRemoteInstance: ()=>registerRemoteInstance,
+    fallbackPlugin: ()=>fallbackPlugin,
+    createEventBus: ()=>createEventBus,
+    getPreloadStatus: ()=>getPreloadStatus,
+    parseVersion: ()=>parseVersion,
+    resolveFinalVersion: ()=>resolveFinalVersion,
+    buildFinalUrls: ()=>buildFinalUrls,
+    fetchLatestVersion: ()=>fetchLatestVersion,
+    isRemoteLoaded: ()=>isRemoteLoaded,
+    getFinalSharedConfig: ()=>getFinalSharedConfig,
+    tryLoadRemote: ()=>tryLoadRemote,
+    getVersionCache: ()=>getVersionCache,
+    eventBus: ()=>eventBus,
+    loadRemoteMultiVersion: ()=>loadRemoteMultiVersion,
+    clearPreloadCache: ()=>clearPreloadCache,
+    loadReactVersion: ()=>loadReactVersion,
+    getRemoteHealthReport: ()=>getRemoteHealthReport,
+    getStableVersions: ()=>getStableVersions,
+    checkModuleLoadable: ()=>checkModuleLoadable,
+    buildCdnUrls: ()=>buildCdnUrls,
+    extractMajorVersion: ()=>extractMajorVersion,
+    preloadRemoteList: ()=>preloadRemoteList,
+    registerLoadedModule: ()=>registerLoadedModule,
+    unloadRemote: ()=>unloadRemote,
+    getCompatibleReactVersions: ()=>getCompatibleReactVersions,
+    cancelPreload: ()=>cancelPreload,
+    findCompatibleVersion: ()=>findCompatibleVersion,
+    getLoadedRemotes: ()=>getLoadedRemotes,
+    getLatestVersion: ()=>getLatestVersion,
+    preloadRemote: ()=>preloadRemote,
+    satisfiesVersion: ()=>satisfiesVersion,
+    formatHealthStatus: ()=>formatHealthStatus,
+    unloadAll: ()=>unloadAll,
+    createRemoteSourcePlugin: ()=>createRemoteSourcePlugin,
+    setVersionCache: ()=>setVersionCache,
+    isPrerelease: ()=>isPrerelease,
+    checkRemoteHealth: ()=>checkRemoteHealth,
+    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'
+            }
+        ]
     });
-    __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
-        };
-    }
-    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;
-        }
+    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';
+}
+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 {
-            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
-        };
+            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 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 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;
         }
-        if (0 === candidates.length) return null;
-        return candidates.sort((a, b)=>compareVersions(b, a))[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,
+            strictVersion: false
+        },
+        strategy: 'loaded-first'
+    },
+    'react-dom': {
+        shareConfig: {
+            singleton: true,
+            eager: true,
+            requiredVersion: false,
+            strictVersion: false
+        },
+        strategy: 'loaded-first'
+    },
+    'react-dom/client': {
+        shareConfig: {
+            singleton: true,
+            eager: true,
+            requiredVersion: false,
+            strictVersion: false
+        },
+        strategy: 'loaded-first'
+    },
+    'react/jsx-runtime': {
+        shareConfig: {
+            singleton: true,
+            eager: true,
+            requiredVersion: false,
+            strictVersion: false
+        },
+        strategy: 'loaded-first'
+    },
+    'react/jsx-dev-runtime': {
+        shareConfig: {
+            singleton: true,
+            eager: true,
+            requiredVersion: false,
+            strictVersion: false
+        },
+        strategy: 'loaded-first'
     }
-    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 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 {};
     }
-    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 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 sortVersions(versions, order = 'desc') {
-        return [
-            ...versions
-        ].sort((a, b)=>{
-            const cmp = compareVersions(a, b);
-            return 'desc' === order ? -cmp : cmp;
+}
+function buildCdnUrls(pkg, version) {
+    return DEFAULT_CDN_TEMPLATES.map((template)=>template.replace('{pkg}', pkg).replace('{version}', version));
+}
+const mfInstanceCache = new Map();
+const mfInstanceLoadingCache = new Map();
+function buildRemotesIdentity(remotes) {
+    if (0 === remotes.length) return '';
+    return remotes.map((remote)=>JSON.stringify({
+            name: remote.name,
+            entry: 'entry' in remote ? remote.entry : '',
+            version: 'version' in remote ? remote.version : '',
+            alias: remote.alias || '',
+            type: remote.type || '',
+            entryGlobalName: remote.entryGlobalName || ''
+        })).sort().join('|');
+}
+async function tryLoadRemote(scopeName, url, _retries, _delay, sharedConfig, plugins, extraRemotes = [], registerOptions = {}) {
+    const remotesIdentity = buildRemotesIdentity(extraRemotes);
+    const cacheKey = `${scopeName}::${url}::${remotesIdentity}::${registerOptions.force ? 'force' : 'normal'}`;
+    const cachedMfs = mfInstanceCache.get(cacheKey);
+    if (cachedMfs) return {
+        scopeName,
+        mf: cachedMfs
+    };
+    const loadingMfs = mfInstanceLoadingCache.get(cacheKey);
+    if (loadingMfs) return loadingMfs;
+    const loadPromise = Promise.resolve().then(()=>{
+        const mf = (0, runtime_namespaceObject.createInstance)({
+            name: 'host',
+            remotes: [
+                {
+                    name: scopeName,
+                    entry: url
+                }
+            ],
+            shared: sharedConfig,
+            plugins: [
+                ...plugins,
+                fallbackPlugin()
+            ]
         });
+        if (extraRemotes.length > 0) mf.registerRemotes(extraRemotes, registerOptions);
+        const result = {
+            scopeName,
+            mf
+        };
+        mfInstanceCache.set(cacheKey, mf);
+        return result;
+    });
+    mfInstanceLoadingCache.set(cacheKey, loadPromise);
+    try {
+        return await loadPromise;
+    } finally{
+        mfInstanceLoadingCache.delete(cacheKey);
     }
-    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 getFinalSharedConfig(customShared) {
+    const globalReact = window.React;
+    const globalReactDOM = window.ReactDOM;
+    const globalShared = {};
+    if (globalReact && globalReactDOM) {
+        const isValidReact = 'object' == typeof globalReact && 'function' == typeof globalReact.useCallback;
+        if (isValidReact) {
+            globalShared.react = {
+                version: globalReact.version || '18.0.0',
+                lib: ()=>globalReact,
+                shareConfig: {
+                    singleton: true,
+                    eager: true,
+                    requiredVersion: false,
+                    strictVersion: false
+                },
+                strategy: 'loaded-first'
+            };
+            globalShared['react-dom'] = {
+                version: globalReactDOM.version || '18.0.0',
+                lib: ()=>globalReactDOM,
+                shareConfig: {
+                    singleton: true,
+                    eager: true,
+                    requiredVersion: false,
+                    strictVersion: false
+                },
+                strategy: 'loaded-first'
+            };
+            globalShared['react-dom/client'] = {
+                version: globalReactDOM.version || '18.0.0',
+                lib: ()=>globalReactDOM,
+                shareConfig: {
+                    singleton: true,
+                    eager: true,
+                    requiredVersion: false,
+                    strictVersion: false
+                },
+                strategy: 'loaded-first'
+            };
+            console.log('[getFinalSharedConfig] Using global React instance', {
+                version: globalReact.version
+            });
+        } else console.warn('[getFinalSharedConfig] Global React found but is invalid', {
+            type: typeof globalReact,
+            useCallback: typeof globalReact?.useCallback
         });
-    const DEFAULT_CDN_TEMPLATES = [
-        'https://cdn.jsdelivr.net/npm/{pkg}@{version}/dist/remoteEntry.js',
-        'https://unpkg.com/{pkg}@{version}/dist/remoteEntry.js'
+    } else console.log('[getFinalSharedConfig] No global React found, using default shared config');
+    const mergedShared = {
+        ...DEFAULT_SHARED_CONFIG,
+        ...globalShared,
+        ...customShared || {}
+    };
+    const keepSingletonPackages = [
+        'react',
+        'react-dom',
+        'react-dom/client',
+        'react/jsx-runtime',
+        'react/jsx-dev-runtime'
     ];
-    const DEFAULT_SHARED_CONFIG = {
-        react: {
+    for (const pkgName of keepSingletonPackages){
+        const base = mergedShared[pkgName] || {};
+        mergedShared[pkgName] = {
+            ...base,
+            strategy: 'loaded-first',
             shareConfig: {
                 singleton: true,
                 eager: true,
-                requiredVersion: false
+                requiredVersion: false,
+                strictVersion: false,
+                ...base.shareConfig || {}
             }
-        },
-        '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(`[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 {};
+    if ('function' == typeof globalShared.react?.lib) mergedShared.react = {
+        ...mergedShared.react || {},
+        lib: globalShared.react.lib,
+        version: globalShared.react.version
+    };
+    if ('function' == typeof globalShared['react-dom']?.lib) mergedShared['react-dom'] = {
+        ...mergedShared['react-dom'] || {},
+        lib: globalShared['react-dom'].lib,
+        version: globalShared['react-dom'].version
+    };
+    if ('function' == typeof globalShared['react-dom/client']?.lib) mergedShared['react-dom/client'] = {
+        ...mergedShared['react-dom/client'] || {},
+        lib: globalShared['react-dom/client'].lib,
+        version: globalShared['react-dom/client'].version
+    };
+    return mergedShared;
+}
+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 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);
-        }
+    return finalVersion;
+}
+function buildFinalUrls(pkg, version, localFallback) {
+    const urls = buildCdnUrls(pkg, version);
+    if (localFallback) urls.push(localFallback);
+    return urls;
+}
+function dedupeRemotes(remotes) {
+    const map = new Map();
+    for (const remote of remotes){
+        if (!remote?.name) continue;
+        const key = [
+            remote.name,
+            'entry' in remote ? remote.entry || '' : '',
+            'version' in remote ? remote.version || '' : '',
+            remote.alias || ''
+        ].join('::');
+        if (!map.has(key)) map.set(key, remote);
+    }
+    return Array.from(map.values());
+}
+async function resolveRegisteredRemotes(context, baseRemotes, remoteSourcePlugins) {
+    const remoteList = [
+        ...baseRemotes
+    ];
+    for (const plugin of remoteSourcePlugins)if (plugin.registerRemotes) try {
+        const pluginRemotes = await plugin.registerRemotes(context);
+        if (pluginRemotes?.length) remoteList.push(...pluginRemotes);
+    } catch (error) {
+        throw new Error(`[MF] remote 来源插件 ${plugin.name} 执行失败: ${error.message}`);
     }
-    function buildCdnUrls(pkg, version) {
-        return DEFAULT_CDN_TEMPLATES.map((template)=>template.replace('{pkg}', pkg).replace('{version}', version));
+    return dedupeRemotes(remoteList).filter((remote)=>!(remote.name === context.scopeName && 'entry' in remote && remote.entry === context.currentEntry));
+}
+function createRemoteSourcePlugin(name, remotes) {
+    return {
+        name,
+        registerRemotes: ()=>remotes
+    };
+}
+async function loadRemoteMultiVersion(options, plugins = [], extraOptions = {}) {
+    const { name, pkg, version = 'latest', retries = 3, delay = 1000, localFallback, cacheTTL = 86400000, revalidate = true, shared: customShared } = options;
+    const { remoteSourcePlugins = [], baseRemotes = [], registerOptions = {} } = extraOptions;
+    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 {
+        const registeredRemotes = await resolveRegisteredRemotes({
+            options,
+            scopeName,
+            pkg,
+            finalVersion,
+            currentEntry: url,
+            allEntries: urls
+        }, baseRemotes, remoteSourcePlugins);
+        return await tryLoadRemote(scopeName, url, retries, delay, finalSharedConfig, plugins, registeredRemotes, registerOptions);
+    } 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;
     }
-    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()
-                ]
-            });
+    const preloadTask = async ()=>{
+        try {
+            const { scopeName, mf } = await loadRemoteMultiVersion(options, []);
+            setCachedPreload(pkg, version, scopeName, mf);
             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);
-            }
-        }
-        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);
-        }
-        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];
+            console.warn(`[MF Preload] 预加载失败 ${pkg}@${version}:`, e);
             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);
-            });
+    };
+    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);
+        }
     }
-    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
-        };
+    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);
     }
-    const remoteInstances = new Map();
-    function generateInstanceKey(name, pkg, version) {
-        return `${name}::${pkg}@${version}`;
+}
+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 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){
+}
+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);
             }
-        }
-        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);
-                    }
-                    resolve();
+            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
-            });
+    });
+}
+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;
+    });
+    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 {
+            reachable: res.ok,
+            latency
+        };
+    } catch (e) {
+        const latency = Math.round(performance.now() - start);
+        return {
+            reachable: false,
+            latency
+        };
     }
-    function isRemoteLoaded(name, pkg, version) {
-        const key = generateInstanceKey(name, pkg, version || '*');
-        return remoteInstances.has(key);
+}
+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;
     }
-    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
-            };
-        }
+}
+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 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;
+    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 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 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)}`;
+    }
+    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
         };
-    }
-    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
+        this.listeners.get(event).add(subscription);
+        return ()=>{
+            this.off(event, callback);
         };
     }
-    function formatHealthStatus(status) {
-        const icons = {
-            healthy: '🟢',
-            degraded: '🟡',
-            unhealthy: '🔴'
-        };
-        return `${icons[status]} ${status}`;
+    once(event, callback) {
+        return this.on(event, callback, {
+            once: true
+        });
     }
-    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);
+    off(event, callback) {
+        if (!this.listeners.has(event)) return;
+        if (callback) {
             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);
+                if (sub.callback === callback) subscriptions.delete(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();
+        } else this.listeners.delete(event);
     }
-    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?.();
+    emit(event, data, meta) {
+        const eventMeta = {
+            timestamp: Date.now(),
+            source: meta?.source,
+            id: meta?.id || this.generateId()
         };
-        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"));
+        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);
             }
-            return this.props.children;
-        }
-    }
-    function useRemoteModule({ pkg, version, moduleName, scopeName, onError, onLoad, retryKey = 0 }) {
-        const [moduleState, setModuleState] = (0, external_react_namespaceObject.useState)({
-            loading: true,
-            error: null,
-            component: null
+            if (sub.once) toRemove.push(sub);
         });
-        (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;
-    }
-    function RemoteModuleRenderer({ pkg, version, moduleName, scopeName, loadingFallback, errorFallback, componentProps, className, style, onError, onLoad }) {
-        const moduleState = useRemoteModule({
-            pkg,
-            version,
-            moduleName,
-            scopeName,
-            onError,
-            onLoad
+        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
         });
-        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", {
-                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));
+        if (history.length > this.maxHistorySize) history.shift();
     }
-    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)));
+    getHistory(event) {
+        return this.eventHistory.get(event) || [];
     }
-    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);
+    getEvents() {
+        return Array.from(this.listeners.keys());
     }
-    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);
+    getListenerCount(event) {
+        return this.listeners.get(event)?.size || 0;
     }
-    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));
+    hasListeners(event) {
+        return this.listeners.has(event) && this.listeners.get(event).size > 0;
     }
-    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));
-        };
+    clear(event) {
+        if (event) {
+            this.listeners.delete(event);
+            this.eventHistory.delete(event);
+        } else {
+            this.listeners.clear();
+            this.eventHistory.clear();
+        }
     }
-    function useRemoteModuleHook(options) {
-        const { pkg, version = 'latest', moduleName, scopeName } = options;
-        const [state, setState] = (0, external_react_namespaceObject.useState)({
-            component: null,
-            loading: true,
-            error: null
+    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;
         });
-        (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
-        };
+        return exists;
     }
-})();
-exports.ErrorBoundary = __webpack_exports__.ErrorBoundary;
-exports.RemoteModuleProvider = __webpack_exports__.RemoteModuleProvider;
-exports.RemoteModuleRenderer = __webpack_exports__.RemoteModuleRenderer;
-exports.SuspenseRemote = __webpack_exports__.SuspenseRemote;
-exports.SuspenseRemoteLoader = __webpack_exports__.SuspenseRemoteLoader;
+    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();
+}
 exports.buildCdnUrls = __webpack_exports__.buildCdnUrls;
 exports.buildFinalUrls = __webpack_exports__.buildFinalUrls;
 exports.cancelPreload = __webpack_exports__.cancelPreload;
@@ -1087,6 +941,7 @@ exports.checkVersionCompatibility = __webpack_exports__.checkVersionCompatibilit
 exports.clearPreloadCache = __webpack_exports__.clearPreloadCache;
 exports.compareVersions = __webpack_exports__.compareVersions;
 exports.createEventBus = __webpack_exports__.createEventBus;
+exports.createRemoteSourcePlugin = __webpack_exports__.createRemoteSourcePlugin;
 exports.eventBus = __webpack_exports__.eventBus;
 exports.extractMajorVersion = __webpack_exports__.extractMajorVersion;
 exports.fallbackPlugin = __webpack_exports__.fallbackPlugin;
@@ -1104,7 +959,6 @@ 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;
@@ -1119,15 +973,7 @@ exports.sortVersions = __webpack_exports__.sortVersions;
 exports.tryLoadRemote = __webpack_exports__.tryLoadRemote;
 exports.unloadAll = __webpack_exports__.unloadAll;
 exports.unloadRemote = __webpack_exports__.unloadRemote;
-exports.useRemoteModule = __webpack_exports__.useRemoteModule;
-exports.useRemoteModuleHook = __webpack_exports__.useRemoteModuleHook;
-exports.withRemote = __webpack_exports__.withRemote;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "ErrorBoundary",
-    "RemoteModuleProvider",
-    "RemoteModuleRenderer",
-    "SuspenseRemote",
-    "SuspenseRemoteLoader",
     "buildCdnUrls",
     "buildFinalUrls",
     "cancelPreload",
@@ -1137,6 +983,7 @@ for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "clearPreloadCache",
     "compareVersions",
     "createEventBus",
+    "createRemoteSourcePlugin",
     "eventBus",
     "extractMajorVersion",
     "fallbackPlugin",
@@ -1154,7 +1001,6 @@ for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "getVersionCache",
     "isPrerelease",
     "isRemoteLoaded",
-    "lazyRemote",
     "loadReactVersion",
     "loadRemoteMultiVersion",
     "parseVersion",
@@ -1168,10 +1014,7 @@ for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "sortVersions",
     "tryLoadRemote",
     "unloadAll",
-    "unloadRemote",
-    "useRemoteModule",
-    "useRemoteModuleHook",
-    "withRemote"
+    "unloadRemote"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true