@module-federation/runtime-core 0.0.0-next-20250707074728 → 0.0.0-next-20250708033956

package/dist/index.cjs.cjs

@@ -943,34 +943,6 @@ function getTargetSharedOptions(options) {
     return Object.assign({}, resolver(shareInfos[pkgName]), extraOptions == null ? void 0 : extraOptions.customShareInfo);
 }
 
-const ShareUtils = {
-    getRegisteredShare,
-    getGlobalShareScope
-};
-const GlobalUtils = {
-    Global,
-    nativeGlobal,
-    resetFederationGlobalInfo,
-    setGlobalFederationInstance,
-    getGlobalFederationConstructor,
-    setGlobalFederationConstructor,
-    getInfoWithoutType,
-    getGlobalSnapshot,
-    getTargetSnapshotInfoByModuleInfo,
-    getGlobalSnapshotInfoByModuleInfo,
-    setGlobalSnapshotInfoByModuleInfo,
-    addGlobalSnapshot,
-    getRemoteEntryExports,
-    registerGlobalPlugins,
-    getGlobalHostPlugins,
-    getPreloaded,
-    setPreloaded
-};
-var helpers = {
-    global: GlobalUtils,
-    share: ShareUtils
-};
-
 function getBuilderId() {
     //@ts-ignore
     return typeof FEDERATION_BUILD_IDENTIFIER !== 'undefined' ? FEDERATION_BUILD_IDENTIFIER : '';
@@ -1240,6 +1212,202 @@ function getRemoteInfo(remote) {
     });
 }
 
+function defaultPreloadArgs(preloadConfig) {
+    return polyfills._extends({
+        resourceCategory: 'sync',
+        share: true,
+        depsRemote: true,
+        prefetchInterface: false
+    }, preloadConfig);
+}
+function formatPreloadArgs(remotes, preloadArgs) {
+    return preloadArgs.map((args)=>{
+        const remoteInfo = matchRemote(remotes, args.nameOrAlias);
+        assert(remoteInfo, `Unable to preload ${args.nameOrAlias} as it is not included in ${!remoteInfo && sdk.safeToString({
+            remoteInfo,
+            remotes
+        })}`);
+        return {
+            remote: remoteInfo,
+            preloadConfig: defaultPreloadArgs(args)
+        };
+    });
+}
+function normalizePreloadExposes(exposes) {
+    if (!exposes) {
+        return [];
+    }
+    return exposes.map((expose)=>{
+        if (expose === '.') {
+            return expose;
+        }
+        if (expose.startsWith('./')) {
+            return expose.replace('./', '');
+        }
+        return expose;
+    });
+}
+function preloadAssets(remoteInfo, host, assets, // It is used to distinguish preload from load remote parallel loading
+useLinkPreload = true) {
+    const { cssAssets, jsAssetsWithoutEntry, entryAssets } = assets;
+    if (host.options.inBrowser) {
+        entryAssets.forEach((asset)=>{
+            const { moduleInfo } = asset;
+            const module = host.moduleCache.get(remoteInfo.name);
+            if (module) {
+                getRemoteEntry({
+                    origin: host,
+                    remoteInfo: moduleInfo,
+                    remoteEntryExports: module.remoteEntryExports
+                });
+            } else {
+                getRemoteEntry({
+                    origin: host,
+                    remoteInfo: moduleInfo,
+                    remoteEntryExports: undefined
+                });
+            }
+        });
+        if (useLinkPreload) {
+            const defaultAttrs = {
+                rel: 'preload',
+                as: 'style'
+            };
+            cssAssets.forEach((cssUrl)=>{
+                const { link: cssEl, needAttach } = sdk.createLink({
+                    url: cssUrl,
+                    cb: ()=>{
+                    // noop
+                    },
+                    attrs: defaultAttrs,
+                    createLinkHook: (url, attrs)=>{
+                        const res = host.loaderHook.lifecycle.createLink.emit({
+                            url,
+                            attrs
+                        });
+                        if (res instanceof HTMLLinkElement) {
+                            return res;
+                        }
+                        return;
+                    }
+                });
+                needAttach && document.head.appendChild(cssEl);
+            });
+        } else {
+            const defaultAttrs = {
+                rel: 'stylesheet',
+                type: 'text/css'
+            };
+            cssAssets.forEach((cssUrl)=>{
+                const { link: cssEl, needAttach } = sdk.createLink({
+                    url: cssUrl,
+                    cb: ()=>{
+                    // noop
+                    },
+                    attrs: defaultAttrs,
+                    createLinkHook: (url, attrs)=>{
+                        const res = host.loaderHook.lifecycle.createLink.emit({
+                            url,
+                            attrs
+                        });
+                        if (res instanceof HTMLLinkElement) {
+                            return res;
+                        }
+                        return;
+                    },
+                    needDeleteLink: false
+                });
+                needAttach && document.head.appendChild(cssEl);
+            });
+        }
+        if (useLinkPreload) {
+            const defaultAttrs = {
+                rel: 'preload',
+                as: 'script'
+            };
+            jsAssetsWithoutEntry.forEach((jsUrl)=>{
+                const { link: linkEl, needAttach } = sdk.createLink({
+                    url: jsUrl,
+                    cb: ()=>{
+                    // noop
+                    },
+                    attrs: defaultAttrs,
+                    createLinkHook: (url, attrs)=>{
+                        const res = host.loaderHook.lifecycle.createLink.emit({
+                            url,
+                            attrs
+                        });
+                        if (res instanceof HTMLLinkElement) {
+                            return res;
+                        }
+                        return;
+                    }
+                });
+                needAttach && document.head.appendChild(linkEl);
+            });
+        } else {
+            const defaultAttrs = {
+                fetchpriority: 'high',
+                type: (remoteInfo == null ? void 0 : remoteInfo.type) === 'module' ? 'module' : 'text/javascript'
+            };
+            jsAssetsWithoutEntry.forEach((jsUrl)=>{
+                const { script: scriptEl, needAttach } = sdk.createScript({
+                    url: jsUrl,
+                    cb: ()=>{
+                    // noop
+                    },
+                    attrs: defaultAttrs,
+                    createScriptHook: (url, attrs)=>{
+                        const res = host.loaderHook.lifecycle.createScript.emit({
+                            url,
+                            attrs
+                        });
+                        if (res instanceof HTMLScriptElement) {
+                            return res;
+                        }
+                        return;
+                    },
+                    needDeleteScript: true
+                });
+                needAttach && document.head.appendChild(scriptEl);
+            });
+        }
+    }
+}
+
+const ShareUtils = {
+    getRegisteredShare,
+    getGlobalShareScope
+};
+const GlobalUtils = {
+    Global,
+    nativeGlobal,
+    resetFederationGlobalInfo,
+    setGlobalFederationInstance,
+    getGlobalFederationConstructor,
+    setGlobalFederationConstructor,
+    getInfoWithoutType,
+    getGlobalSnapshot,
+    getTargetSnapshotInfoByModuleInfo,
+    getGlobalSnapshotInfoByModuleInfo,
+    setGlobalSnapshotInfoByModuleInfo,
+    addGlobalSnapshot,
+    getRemoteEntryExports,
+    registerGlobalPlugins,
+    getGlobalHostPlugins,
+    getPreloaded,
+    setPreloaded
+};
+var helpers = {
+    global: GlobalUtils,
+    share: ShareUtils,
+    utils: {
+        matchRemoteWithNameAndExpose,
+        preloadAssets,
+        getRemoteInfo
+    }
+};
+
 let Module = class Module {
     async getEntry() {
         if (this.remoteEntryExports) {
@@ -1563,169 +1731,6 @@ class PluginSystem {
     }
 }
 
-function defaultPreloadArgs(preloadConfig) {
-    return polyfills._extends({
-        resourceCategory: 'sync',
-        share: true,
-        depsRemote: true,
-        prefetchInterface: false
-    }, preloadConfig);
-}
-function formatPreloadArgs(remotes, preloadArgs) {
-    return preloadArgs.map((args)=>{
-        const remoteInfo = matchRemote(remotes, args.nameOrAlias);
-        assert(remoteInfo, `Unable to preload ${args.nameOrAlias} as it is not included in ${!remoteInfo && sdk.safeToString({
-            remoteInfo,
-            remotes
-        })}`);
-        return {
-            remote: remoteInfo,
-            preloadConfig: defaultPreloadArgs(args)
-        };
-    });
-}
-function normalizePreloadExposes(exposes) {
-    if (!exposes) {
-        return [];
-    }
-    return exposes.map((expose)=>{
-        if (expose === '.') {
-            return expose;
-        }
-        if (expose.startsWith('./')) {
-            return expose.replace('./', '');
-        }
-        return expose;
-    });
-}
-function preloadAssets(remoteInfo, host, assets, // It is used to distinguish preload from load remote parallel loading
-useLinkPreload = true) {
-    const { cssAssets, jsAssetsWithoutEntry, entryAssets } = assets;
-    if (host.options.inBrowser) {
-        entryAssets.forEach((asset)=>{
-            const { moduleInfo } = asset;
-            const module = host.moduleCache.get(remoteInfo.name);
-            if (module) {
-                getRemoteEntry({
-                    origin: host,
-                    remoteInfo: moduleInfo,
-                    remoteEntryExports: module.remoteEntryExports
-                });
-            } else {
-                getRemoteEntry({
-                    origin: host,
-                    remoteInfo: moduleInfo,
-                    remoteEntryExports: undefined
-                });
-            }
-        });
-        if (useLinkPreload) {
-            const defaultAttrs = {
-                rel: 'preload',
-                as: 'style'
-            };
-            cssAssets.forEach((cssUrl)=>{
-                const { link: cssEl, needAttach } = sdk.createLink({
-                    url: cssUrl,
-                    cb: ()=>{
-                    // noop
-                    },
-                    attrs: defaultAttrs,
-                    createLinkHook: (url, attrs)=>{
-                        const res = host.loaderHook.lifecycle.createLink.emit({
-                            url,
-                            attrs
-                        });
-                        if (res instanceof HTMLLinkElement) {
-                            return res;
-                        }
-                        return;
-                    }
-                });
-                needAttach && document.head.appendChild(cssEl);
-            });
-        } else {
-            const defaultAttrs = {
-                rel: 'stylesheet',
-                type: 'text/css'
-            };
-            cssAssets.forEach((cssUrl)=>{
-                const { link: cssEl, needAttach } = sdk.createLink({
-                    url: cssUrl,
-                    cb: ()=>{
-                    // noop
-                    },
-                    attrs: defaultAttrs,
-                    createLinkHook: (url, attrs)=>{
-                        const res = host.loaderHook.lifecycle.createLink.emit({
-                            url,
-                            attrs
-                        });
-                        if (res instanceof HTMLLinkElement) {
-                            return res;
-                        }
-                        return;
-                    },
-                    needDeleteLink: false
-                });
-                needAttach && document.head.appendChild(cssEl);
-            });
-        }
-        if (useLinkPreload) {
-            const defaultAttrs = {
-                rel: 'preload',
-                as: 'script'
-            };
-            jsAssetsWithoutEntry.forEach((jsUrl)=>{
-                const { link: linkEl, needAttach } = sdk.createLink({
-                    url: jsUrl,
-                    cb: ()=>{
-                    // noop
-                    },
-                    attrs: defaultAttrs,
-                    createLinkHook: (url, attrs)=>{
-                        const res = host.loaderHook.lifecycle.createLink.emit({
-                            url,
-                            attrs
-                        });
-                        if (res instanceof HTMLLinkElement) {
-                            return res;
-                        }
-                        return;
-                    }
-                });
-                needAttach && document.head.appendChild(linkEl);
-            });
-        } else {
-            const defaultAttrs = {
-                fetchpriority: 'high',
-                type: (remoteInfo == null ? void 0 : remoteInfo.type) === 'module' ? 'module' : 'text/javascript'
-            };
-            jsAssetsWithoutEntry.forEach((jsUrl)=>{
-                const { script: scriptEl, needAttach } = sdk.createScript({
-                    url: jsUrl,
-                    cb: ()=>{
-                    // noop
-                    },
-                    attrs: defaultAttrs,
-                    createScriptHook: (url, attrs)=>{
-                        const res = host.loaderHook.lifecycle.createScript.emit({
-                            url,
-                            attrs
-                        });
-                        if (res instanceof HTMLScriptElement) {
-                            return res;
-                        }
-                        return;
-                    },
-                    needDeleteScript: true
-                });
-                needAttach && document.head.appendChild(scriptEl);
-            });
-        }
-    }
-}
-
 function assignRemoteInfo(remoteInfo, remoteSnapshot) {
     const remoteEntryInfo = getRemoteEntryInfoFromSnapshot(remoteSnapshot);
     if (!remoteEntryInfo.url) {
@@ -2918,7 +2923,7 @@ class RemoteHandler {
 }
 
 const USE_SNAPSHOT = typeof FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN === 'boolean' ? !FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN : true; // Default to true (use snapshot) when not explicitly defined
-class ModuleFederation {
+class FederationHost {
     initOptions(userOptions) {
         this.registerPlugins(userOptions.plugins);
         const options = this.formatOptions(this.options, userOptions);
@@ -3015,11 +3020,6 @@ class ModuleFederation {
     registerRemotes(remotes, options) {
         return this.remoteHandler.registerRemotes(remotes, options);
     }
-    registerShared(shared) {
-        this.sharedHandler.registerShared(this.options, polyfills._extends({}, this.options, {
-            shared
-        }));
-    }
     constructor(userOptions){
         this.hooks = new PluginSystem({
             beforeInit: new SyncWaterfallHook('beforeInit'),
@@ -3081,9 +3081,9 @@ var index = /*#__PURE__*/Object.freeze({
 exports.loadScript = sdk.loadScript;
 exports.loadScriptNode = sdk.loadScriptNode;
 exports.CurrentGlobal = CurrentGlobal;
+exports.FederationHost = FederationHost;
 exports.Global = Global;
 exports.Module = Module;
-exports.ModuleFederation = ModuleFederation;
 exports.addGlobalSnapshot = addGlobalSnapshot;
 exports.assert = assert;
 exports.getGlobalFederationConstructor = getGlobalFederationConstructor;

package/dist/index.esm.js

@@ -1,5 +1,5 @@
 import { _ as _extends, a as _object_without_properties_loose } from './polyfills.esm.js';
-import { createLogger, isBrowserEnv, isReactNativeEnv, isDebugMode, composeKeyWithSeparator, loadScriptNode, loadScript, safeToString, createLink, createScript, getResourceUrl, isManifestProvider, generateSnapshotFromManifest, warn as warn$1 } from '@module-federation/sdk';
+import { createLogger, isBrowserEnv, isReactNativeEnv, isDebugMode, composeKeyWithSeparator, loadScriptNode, loadScript, createLink, createScript, safeToString, getResourceUrl, isManifestProvider, generateSnapshotFromManifest, warn as warn$1 } from '@module-federation/sdk';
 export { loadScript, loadScriptNode } from '@module-federation/sdk';
 import { getShortErrorMsg, RUNTIME_008, runtimeDescMap, RUNTIME_001, RUNTIME_002, RUNTIME_007, RUNTIME_003, RUNTIME_005, RUNTIME_006, RUNTIME_004 } from '@module-federation/error-codes';
 
@@ -942,34 +942,6 @@ function getTargetSharedOptions(options) {
     return Object.assign({}, resolver(shareInfos[pkgName]), extraOptions == null ? void 0 : extraOptions.customShareInfo);
 }
 
-const ShareUtils = {
-    getRegisteredShare,
-    getGlobalShareScope
-};
-const GlobalUtils = {
-    Global,
-    nativeGlobal,
-    resetFederationGlobalInfo,
-    setGlobalFederationInstance,
-    getGlobalFederationConstructor,
-    setGlobalFederationConstructor,
-    getInfoWithoutType,
-    getGlobalSnapshot,
-    getTargetSnapshotInfoByModuleInfo,
-    getGlobalSnapshotInfoByModuleInfo,
-    setGlobalSnapshotInfoByModuleInfo,
-    addGlobalSnapshot,
-    getRemoteEntryExports,
-    registerGlobalPlugins,
-    getGlobalHostPlugins,
-    getPreloaded,
-    setPreloaded
-};
-var helpers = {
-    global: GlobalUtils,
-    share: ShareUtils
-};
-
 function getBuilderId() {
     //@ts-ignore
     return typeof FEDERATION_BUILD_IDENTIFIER !== 'undefined' ? FEDERATION_BUILD_IDENTIFIER : '';
@@ -1239,6 +1211,202 @@ function getRemoteInfo(remote) {
     });
 }
 
+function defaultPreloadArgs(preloadConfig) {
+    return _extends({
+        resourceCategory: 'sync',
+        share: true,
+        depsRemote: true,
+        prefetchInterface: false
+    }, preloadConfig);
+}
+function formatPreloadArgs(remotes, preloadArgs) {
+    return preloadArgs.map((args)=>{
+        const remoteInfo = matchRemote(remotes, args.nameOrAlias);
+        assert(remoteInfo, `Unable to preload ${args.nameOrAlias} as it is not included in ${!remoteInfo && safeToString({
+            remoteInfo,
+            remotes
+        })}`);
+        return {
+            remote: remoteInfo,
+            preloadConfig: defaultPreloadArgs(args)
+        };
+    });
+}
+function normalizePreloadExposes(exposes) {
+    if (!exposes) {
+        return [];
+    }
+    return exposes.map((expose)=>{
+        if (expose === '.') {
+            return expose;
+        }
+        if (expose.startsWith('./')) {
+            return expose.replace('./', '');
+        }
+        return expose;
+    });
+}
+function preloadAssets(remoteInfo, host, assets, // It is used to distinguish preload from load remote parallel loading
+useLinkPreload = true) {
+    const { cssAssets, jsAssetsWithoutEntry, entryAssets } = assets;
+    if (host.options.inBrowser) {
+        entryAssets.forEach((asset)=>{
+            const { moduleInfo } = asset;
+            const module = host.moduleCache.get(remoteInfo.name);
+            if (module) {
+                getRemoteEntry({
+                    origin: host,
+                    remoteInfo: moduleInfo,
+                    remoteEntryExports: module.remoteEntryExports
+                });
+            } else {
+                getRemoteEntry({
+                    origin: host,
+                    remoteInfo: moduleInfo,
+                    remoteEntryExports: undefined
+                });
+            }
+        });
+        if (useLinkPreload) {
+            const defaultAttrs = {
+                rel: 'preload',
+                as: 'style'
+            };
+            cssAssets.forEach((cssUrl)=>{
+                const { link: cssEl, needAttach } = createLink({
+                    url: cssUrl,
+                    cb: ()=>{
+                    // noop
+                    },
+                    attrs: defaultAttrs,
+                    createLinkHook: (url, attrs)=>{
+                        const res = host.loaderHook.lifecycle.createLink.emit({
+                            url,
+                            attrs
+                        });
+                        if (res instanceof HTMLLinkElement) {
+                            return res;
+                        }
+                        return;
+                    }
+                });
+                needAttach && document.head.appendChild(cssEl);
+            });
+        } else {
+            const defaultAttrs = {
+                rel: 'stylesheet',
+                type: 'text/css'
+            };
+            cssAssets.forEach((cssUrl)=>{
+                const { link: cssEl, needAttach } = createLink({
+                    url: cssUrl,
+                    cb: ()=>{
+                    // noop
+                    },
+                    attrs: defaultAttrs,
+                    createLinkHook: (url, attrs)=>{
+                        const res = host.loaderHook.lifecycle.createLink.emit({
+                            url,
+                            attrs
+                        });
+                        if (res instanceof HTMLLinkElement) {
+                            return res;
+                        }
+                        return;
+                    },
+                    needDeleteLink: false
+                });
+                needAttach && document.head.appendChild(cssEl);
+            });
+        }
+        if (useLinkPreload) {
+            const defaultAttrs = {
+                rel: 'preload',
+                as: 'script'
+            };
+            jsAssetsWithoutEntry.forEach((jsUrl)=>{
+                const { link: linkEl, needAttach } = createLink({
+                    url: jsUrl,
+                    cb: ()=>{
+                    // noop
+                    },
+                    attrs: defaultAttrs,
+                    createLinkHook: (url, attrs)=>{
+                        const res = host.loaderHook.lifecycle.createLink.emit({
+                            url,
+                            attrs
+                        });
+                        if (res instanceof HTMLLinkElement) {
+                            return res;
+                        }
+                        return;
+                    }
+                });
+                needAttach && document.head.appendChild(linkEl);
+            });
+        } else {
+            const defaultAttrs = {
+                fetchpriority: 'high',
+                type: (remoteInfo == null ? void 0 : remoteInfo.type) === 'module' ? 'module' : 'text/javascript'
+            };
+            jsAssetsWithoutEntry.forEach((jsUrl)=>{
+                const { script: scriptEl, needAttach } = createScript({
+                    url: jsUrl,
+                    cb: ()=>{
+                    // noop
+                    },
+                    attrs: defaultAttrs,
+                    createScriptHook: (url, attrs)=>{
+                        const res = host.loaderHook.lifecycle.createScript.emit({
+                            url,
+                            attrs
+                        });
+                        if (res instanceof HTMLScriptElement) {
+                            return res;
+                        }
+                        return;
+                    },
+                    needDeleteScript: true
+                });
+                needAttach && document.head.appendChild(scriptEl);
+            });
+        }
+    }
+}
+
+const ShareUtils = {
+    getRegisteredShare,
+    getGlobalShareScope
+};
+const GlobalUtils = {
+    Global,
+    nativeGlobal,
+    resetFederationGlobalInfo,
+    setGlobalFederationInstance,
+    getGlobalFederationConstructor,
+    setGlobalFederationConstructor,
+    getInfoWithoutType,
+    getGlobalSnapshot,
+    getTargetSnapshotInfoByModuleInfo,
+    getGlobalSnapshotInfoByModuleInfo,
+    setGlobalSnapshotInfoByModuleInfo,
+    addGlobalSnapshot,
+    getRemoteEntryExports,
+    registerGlobalPlugins,
+    getGlobalHostPlugins,
+    getPreloaded,
+    setPreloaded
+};
+var helpers = {
+    global: GlobalUtils,
+    share: ShareUtils,
+    utils: {
+        matchRemoteWithNameAndExpose,
+        preloadAssets,
+        getRemoteInfo
+    }
+};
+
 let Module = class Module {
     async getEntry() {
         if (this.remoteEntryExports) {
@@ -1562,169 +1730,6 @@ class PluginSystem {
     }
 }
 
-function defaultPreloadArgs(preloadConfig) {
-    return _extends({
-        resourceCategory: 'sync',
-        share: true,
-        depsRemote: true,
-        prefetchInterface: false
-    }, preloadConfig);
-}
-function formatPreloadArgs(remotes, preloadArgs) {
-    return preloadArgs.map((args)=>{
-        const remoteInfo = matchRemote(remotes, args.nameOrAlias);
-        assert(remoteInfo, `Unable to preload ${args.nameOrAlias} as it is not included in ${!remoteInfo && safeToString({
-            remoteInfo,
-            remotes
-        })}`);
-        return {
-            remote: remoteInfo,
-            preloadConfig: defaultPreloadArgs(args)
-        };
-    });
-}
-function normalizePreloadExposes(exposes) {
-    if (!exposes) {
-        return [];
-    }
-    return exposes.map((expose)=>{
-        if (expose === '.') {
-            return expose;
-        }
-        if (expose.startsWith('./')) {
-            return expose.replace('./', '');
-        }
-        return expose;
-    });
-}
-function preloadAssets(remoteInfo, host, assets, // It is used to distinguish preload from load remote parallel loading
-useLinkPreload = true) {
-    const { cssAssets, jsAssetsWithoutEntry, entryAssets } = assets;
-    if (host.options.inBrowser) {
-        entryAssets.forEach((asset)=>{
-            const { moduleInfo } = asset;
-            const module = host.moduleCache.get(remoteInfo.name);
-            if (module) {
-                getRemoteEntry({
-                    origin: host,
-                    remoteInfo: moduleInfo,
-                    remoteEntryExports: module.remoteEntryExports
-                });
-            } else {
-                getRemoteEntry({
-                    origin: host,
-                    remoteInfo: moduleInfo,
-                    remoteEntryExports: undefined
-                });
-            }
-        });
-        if (useLinkPreload) {
-            const defaultAttrs = {
-                rel: 'preload',
-                as: 'style'
-            };
-            cssAssets.forEach((cssUrl)=>{
-                const { link: cssEl, needAttach } = createLink({
-                    url: cssUrl,
-                    cb: ()=>{
-                    // noop
-                    },
-                    attrs: defaultAttrs,
-                    createLinkHook: (url, attrs)=>{
-                        const res = host.loaderHook.lifecycle.createLink.emit({
-                            url,
-                            attrs
-                        });
-                        if (res instanceof HTMLLinkElement) {
-                            return res;
-                        }
-                        return;
-                    }
-                });
-                needAttach && document.head.appendChild(cssEl);
-            });
-        } else {
-            const defaultAttrs = {
-                rel: 'stylesheet',
-                type: 'text/css'
-            };
-            cssAssets.forEach((cssUrl)=>{
-                const { link: cssEl, needAttach } = createLink({
-                    url: cssUrl,
-                    cb: ()=>{
-                    // noop
-                    },
-                    attrs: defaultAttrs,
-                    createLinkHook: (url, attrs)=>{
-                        const res = host.loaderHook.lifecycle.createLink.emit({
-                            url,
-                            attrs
-                        });
-                        if (res instanceof HTMLLinkElement) {
-                            return res;
-                        }
-                        return;
-                    },
-                    needDeleteLink: false
-                });
-                needAttach && document.head.appendChild(cssEl);
-            });
-        }
-        if (useLinkPreload) {
-            const defaultAttrs = {
-                rel: 'preload',
-                as: 'script'
-            };
-            jsAssetsWithoutEntry.forEach((jsUrl)=>{
-                const { link: linkEl, needAttach } = createLink({
-                    url: jsUrl,
-                    cb: ()=>{
-                    // noop
-                    },
-                    attrs: defaultAttrs,
-                    createLinkHook: (url, attrs)=>{
-                        const res = host.loaderHook.lifecycle.createLink.emit({
-                            url,
-                            attrs
-                        });
-                        if (res instanceof HTMLLinkElement) {
-                            return res;
-                        }
-                        return;
-                    }
-                });
-                needAttach && document.head.appendChild(linkEl);
-            });
-        } else {
-            const defaultAttrs = {
-                fetchpriority: 'high',
-                type: (remoteInfo == null ? void 0 : remoteInfo.type) === 'module' ? 'module' : 'text/javascript'
-            };
-            jsAssetsWithoutEntry.forEach((jsUrl)=>{
-                const { script: scriptEl, needAttach } = createScript({
-                    url: jsUrl,
-                    cb: ()=>{
-                    // noop
-                    },
-                    attrs: defaultAttrs,
-                    createScriptHook: (url, attrs)=>{
-                        const res = host.loaderHook.lifecycle.createScript.emit({
-                            url,
-                            attrs
-                        });
-                        if (res instanceof HTMLScriptElement) {
-                            return res;
-                        }
-                        return;
-                    },
-                    needDeleteScript: true
-                });
-                needAttach && document.head.appendChild(scriptEl);
-            });
-        }
-    }
-}
-
 function assignRemoteInfo(remoteInfo, remoteSnapshot) {
     const remoteEntryInfo = getRemoteEntryInfoFromSnapshot(remoteSnapshot);
     if (!remoteEntryInfo.url) {
@@ -2917,7 +2922,7 @@ class RemoteHandler {
 }
 
 const USE_SNAPSHOT = typeof FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN === 'boolean' ? !FEDERATION_OPTIMIZE_NO_SNAPSHOT_PLUGIN : true; // Default to true (use snapshot) when not explicitly defined
-class ModuleFederation {
+class FederationHost {
     initOptions(userOptions) {
         this.registerPlugins(userOptions.plugins);
         const options = this.formatOptions(this.options, userOptions);
@@ -3014,11 +3019,6 @@ class ModuleFederation {
     registerRemotes(remotes, options) {
         return this.remoteHandler.registerRemotes(remotes, options);
     }
-    registerShared(shared) {
-        this.sharedHandler.registerShared(this.options, _extends({}, this.options, {
-            shared
-        }));
-    }
     constructor(userOptions){
         this.hooks = new PluginSystem({
             beforeInit: new SyncWaterfallHook('beforeInit'),
@@ -3077,4 +3077,4 @@ var index = /*#__PURE__*/Object.freeze({
   __proto__: null
 });
 
-export { CurrentGlobal, Global, Module, ModuleFederation, addGlobalSnapshot, assert, getGlobalFederationConstructor, getGlobalSnapshot, getInfoWithoutType, getRegisteredShare, getRemoteEntry, getRemoteInfo, helpers, isStaticResourcesEqual, matchRemoteWithNameAndExpose, registerGlobalPlugins, resetFederationGlobalInfo, safeWrapper, satisfy, setGlobalFederationConstructor, setGlobalFederationInstance, index as types };
+export { CurrentGlobal, FederationHost, Global, Module, addGlobalSnapshot, assert, getGlobalFederationConstructor, getGlobalSnapshot, getInfoWithoutType, getRegisteredShare, getRemoteEntry, getRemoteInfo, helpers, isStaticResourcesEqual, matchRemoteWithNameAndExpose, registerGlobalPlugins, resetFederationGlobalInfo, safeWrapper, satisfy, setGlobalFederationConstructor, setGlobalFederationInstance, index as types };

package/dist/src/core.d.ts

@@ -6,25 +6,25 @@ import { AsyncHook, AsyncWaterfallHook, PluginSystem, SyncHook, SyncWaterfallHoo
 import { SnapshotHandler } from './plugins/snapshot/SnapshotHandler';
 import { SharedHandler } from './shared';
 import { RemoteHandler } from './remote';
-export declare class ModuleFederation {
+export declare class FederationHost {
     options: Options;
     hooks: PluginSystem<{
         beforeInit: SyncWaterfallHook<{
             userOptions: UserOptions;
             options: Options;
-            origin: ModuleFederation;
+            origin: FederationHost;
             shareInfo: ShareInfos;
         }>;
         init: SyncHook<[{
             options: Options;
-            origin: ModuleFederation;
+            origin: FederationHost;
         }], void>;
         beforeInitContainer: AsyncWaterfallHook<{
             shareScope: ShareScopeMap[string];
             initScope: InitScope;
             remoteEntryInitOptions: RemoteEntryInitOptions;
             remoteInfo: RemoteInfo;
-            origin: ModuleFederation;
+            origin: FederationHost;
         }>;
         initContainer: AsyncWaterfallHook<{
             shareScope: ShareScopeMap[string];
@@ -32,7 +32,7 @@ export declare class ModuleFederation {
             remoteEntryInitOptions: RemoteEntryInitOptions;
             remoteInfo: RemoteInfo;
             remoteEntryExports: RemoteEntryExports;
-            origin: ModuleFederation;
+            origin: FederationHost;
             id: string;
             remoteSnapshot?: ModuleInfo;
         }>;
@@ -63,7 +63,7 @@ export declare class ModuleFederation {
         fetch: AsyncHook<[string, RequestInit], false | void | Promise<Response>>;
         loadEntryError: AsyncHook<[{
             getRemoteEntry: typeof getRemoteEntry;
-            origin: ModuleFederation;
+            origin: FederationHost;
             remoteInfo: RemoteInfo;
             remoteEntryExports?: RemoteEntryExports | undefined;
             globalLoading: Record<string, Promise<void | RemoteEntryExports> | undefined>;
@@ -111,5 +111,4 @@ export declare class ModuleFederation {
     registerRemotes(remotes: Remote[], options?: {
         force?: boolean;
     }): void;
-    registerShared(shared: UserOptions['shared']): void;
 }

package/dist/src/global.d.ts

@@ -1,13 +1,13 @@
-import { ModuleFederation } from './core';
+import { FederationHost } from './core';
 import { RemoteEntryExports, GlobalShareScopeMap, Remote, Optional } from './type';
 import { GlobalModuleInfo, ModuleInfo } from '@module-federation/sdk';
-import { ModuleFederationRuntimePlugin } from './type/plugin';
+import { FederationRuntimePlugin } from './type/plugin';
 export interface Federation {
-    __GLOBAL_PLUGIN__: Array<ModuleFederationRuntimePlugin>;
+    __GLOBAL_PLUGIN__: Array<FederationRuntimePlugin>;
     __DEBUG_CONSTRUCTOR_VERSION__?: string;
     moduleInfo: GlobalModuleInfo;
-    __DEBUG_CONSTRUCTOR__?: typeof ModuleFederation;
-    __INSTANCES__: Array<ModuleFederation>;
+    __DEBUG_CONSTRUCTOR__?: typeof FederationHost;
+    __INSTANCES__: Array<FederationHost>;
     __SHARE__: GlobalShareScopeMap;
     __MANIFEST_LOADING__: Record<string, Promise<ModuleInfo>>;
     __PRELOADED_MAP__: Map<string, boolean>;
@@ -20,9 +20,9 @@ declare global {
 }
 export declare const globalLoading: Record<string, Promise<void | RemoteEntryExports> | undefined>;
 export declare function resetFederationGlobalInfo(): void;
-export declare function setGlobalFederationInstance(FederationInstance: ModuleFederation): void;
-export declare function getGlobalFederationConstructor(): typeof ModuleFederation | undefined;
-export declare function setGlobalFederationConstructor(FederationConstructor: typeof ModuleFederation | undefined, isDebug?: boolean): void;
+export declare function setGlobalFederationInstance(FederationInstance: FederationHost): void;
+export declare function getGlobalFederationConstructor(): typeof FederationHost | undefined;
+export declare function setGlobalFederationConstructor(FederationConstructor: typeof FederationHost | undefined, isDebug?: boolean): void;
 export declare function getInfoWithoutType<T extends object>(target: T, key: keyof T): {
     value: T[keyof T] | undefined;
     key: string;
@@ -36,7 +36,7 @@ export declare const getRemoteEntryExports: (name: string, globalName: string |
     remoteEntryKey: string;
     entryExports: RemoteEntryExports | undefined;
 };
-export declare const registerGlobalPlugins: (plugins: Array<ModuleFederationRuntimePlugin>) => void;
-export declare const getGlobalHostPlugins: () => Array<ModuleFederationRuntimePlugin>;
+export declare const registerGlobalPlugins: (plugins: Array<FederationRuntimePlugin>) => void;
+export declare const getGlobalHostPlugins: () => Array<FederationRuntimePlugin>;
 export declare const getPreloaded: (id: string) => boolean | undefined;
 export declare const setPreloaded: (id: string) => Map<string, boolean>;

package/dist/src/helpers.d.ts

@@ -1,5 +1,7 @@
 import { resetFederationGlobalInfo, setGlobalFederationInstance, getGlobalFederationConstructor, setGlobalFederationConstructor, getInfoWithoutType, getGlobalSnapshot, getTargetSnapshotInfoByModuleInfo, getGlobalSnapshotInfoByModuleInfo, setGlobalSnapshotInfoByModuleInfo, addGlobalSnapshot, getRemoteEntryExports, registerGlobalPlugins, getGlobalHostPlugins, getPreloaded, setPreloaded, Global } from './global';
 import { getRegisteredShare, getGlobalShareScope } from './utils/share';
+import { getRemoteInfo, matchRemoteWithNameAndExpose } from './utils';
+import { preloadAssets } from './utils/preload';
 interface IShareUtils {
     getRegisteredShare: typeof getRegisteredShare;
     getGlobalShareScope: typeof getGlobalShareScope;
@@ -26,6 +28,11 @@ interface IGlobalUtils {
 declare const _default: {
     global: IGlobalUtils;
     share: IShareUtils;
+    utils: {
+        matchRemoteWithNameAndExpose: typeof matchRemoteWithNameAndExpose;
+        preloadAssets: typeof preloadAssets;
+        getRemoteInfo: typeof getRemoteInfo;
+    };
 };
 export default _default;
 export type { IGlobalUtils, IShareUtils };

package/dist/src/index.d.ts

@@ -1,7 +1,7 @@
 import helpers, { type IGlobalUtils, type IShareUtils } from './helpers';
-export { ModuleFederation } from './core';
+export { FederationHost } from './core';
 export { type Federation, CurrentGlobal, Global, getGlobalFederationConstructor, setGlobalFederationInstance, setGlobalFederationConstructor, resetFederationGlobalInfo, addGlobalSnapshot, getGlobalSnapshot, getInfoWithoutType, } from './global';
-export type { UserOptions, ModuleFederationRuntimePlugin } from './type';
+export type { UserOptions, FederationRuntimePlugin } from './type';
 export { assert } from './utils/logger';
 export { registerGlobalPlugins } from './global';
 export { getRemoteEntry, getRemoteInfo, isStaticResourcesEqual, matchRemoteWithNameAndExpose, safeWrapper, } from './utils';

package/dist/src/module/index.d.ts

@@ -1,5 +1,5 @@
 import { ModuleInfo } from '@module-federation/sdk';
-import { ModuleFederation } from '../core';
+import { FederationHost } from '../core';
 import { RemoteEntryExports, RemoteInfo } from '../type';
 export type ModuleOptions = ConstructorParameters<typeof Module>[0];
 declare class Module {
@@ -7,10 +7,10 @@ declare class Module {
     inited: boolean;
     remoteEntryExports?: RemoteEntryExports;
     lib: RemoteEntryExports | undefined;
-    host: ModuleFederation;
+    host: FederationHost;
     constructor({ remoteInfo, host, }: {
         remoteInfo: RemoteInfo;
-        host: ModuleFederation;
+        host: FederationHost;
     });
     getEntry(): Promise<RemoteEntryExports>;
     get(id: string, expose: string, options?: {

package/dist/src/plugins/generate-preload-assets.d.ts

@@ -1,8 +1,8 @@
 import { GlobalModuleInfo, ModuleInfo } from '@module-federation/sdk';
-import { ModuleFederationRuntimePlugin, PreloadAssets, PreloadOptions, RemoteInfoOptionalVersion } from '../type';
-import { ModuleFederation } from '../core';
+import { FederationRuntimePlugin, PreloadAssets, PreloadOptions, RemoteInfoOptionalVersion } from '../type';
+import { FederationHost } from '../core';
 declare global {
     var __INIT_VMOK_DEPLOY_GLOBAL_DATA__: boolean | undefined;
 }
-export declare function generatePreloadAssets(origin: ModuleFederation, preloadOptions: PreloadOptions[number], remote: RemoteInfoOptionalVersion, globalSnapshot: GlobalModuleInfo, remoteSnapshot: ModuleInfo): PreloadAssets;
-export declare const generatePreloadAssetsPlugin: () => ModuleFederationRuntimePlugin;
+export declare function generatePreloadAssets(origin: FederationHost, preloadOptions: PreloadOptions[number], remote: RemoteInfoOptionalVersion, globalSnapshot: GlobalModuleInfo, remoteSnapshot: ModuleInfo): PreloadAssets;
+export declare const generatePreloadAssetsPlugin: () => FederationRuntimePlugin;

package/dist/src/plugins/snapshot/SnapshotHandler.d.ts

@@ -2,15 +2,15 @@ import { GlobalModuleInfo, Manifest, ModuleInfo } from '@module-federation/sdk';
 import { Options, Remote } from '../../type';
 import { getGlobalSnapshot } from '../../global';
 import { PluginSystem, AsyncHook, AsyncWaterfallHook } from '../../utils/hooks';
-import { ModuleFederation } from '../../core';
-export declare function getGlobalRemoteInfo(moduleInfo: Remote, origin: ModuleFederation): {
+import { FederationHost } from '../../core';
+export declare function getGlobalRemoteInfo(moduleInfo: Remote, origin: FederationHost): {
     hostGlobalSnapshot: ModuleInfo | undefined;
     globalSnapshot: ReturnType<typeof getGlobalSnapshot>;
     remoteSnapshot: GlobalModuleInfo[string] | undefined;
 };
 export declare class SnapshotHandler {
     loadingHostSnapshot: Promise<GlobalModuleInfo | void> | null;
-    HostInstance: ModuleFederation;
+    HostInstance: FederationHost;
     manifestCache: Map<string, Manifest>;
     hooks: PluginSystem<{
         beforeLoadRemoteSnapshot: AsyncHook<[{
@@ -34,15 +34,15 @@ export declare class SnapshotHandler {
         }>;
         afterLoadSnapshot: AsyncWaterfallHook<{
             id?: string;
-            host: ModuleFederation;
+            host: FederationHost;
             options: Options;
             moduleInfo: Remote;
             remoteSnapshot: ModuleInfo;
         }>;
     }>;
-    loaderHook: ModuleFederation['loaderHook'];
+    loaderHook: FederationHost['loaderHook'];
     manifestLoading: Record<string, Promise<ModuleInfo>>;
-    constructor(HostInstance: ModuleFederation);
+    constructor(HostInstance: FederationHost);
     loadRemoteSnapshotInfo({ moduleInfo, id, expose, }: {
         moduleInfo: Remote;
         id?: string;

package/dist/src/plugins/snapshot/index.d.ts

@@ -1,5 +1,5 @@
 import { ModuleInfo } from '@module-federation/sdk';
-import { ModuleFederationRuntimePlugin } from '../../type/plugin';
+import { FederationRuntimePlugin } from '../../type/plugin';
 import { RemoteInfo } from '../../type';
 export declare function assignRemoteInfo(remoteInfo: RemoteInfo, remoteSnapshot: ModuleInfo): void;
-export declare function snapshotPlugin(): ModuleFederationRuntimePlugin;
+export declare function snapshotPlugin(): FederationRuntimePlugin;

package/dist/src/remote/index.d.ts

@@ -1,6 +1,6 @@
 import { ModuleInfo, GlobalModuleInfo } from '@module-federation/sdk';
 import { Options, UserOptions, PreloadAssets, PreloadOptions, PreloadRemoteArgs, Remote, RemoteInfo, RemoteEntryExports, CallFrom } from '../type';
-import { ModuleFederation } from '../core';
+import { FederationHost } from '../core';
 import { PluginSystem, AsyncHook, AsyncWaterfallHook, SyncHook, SyncWaterfallHook } from '../utils/hooks';
 import { Module, ModuleOptions } from '../module';
 export interface LoadRemoteMatch {
@@ -9,12 +9,12 @@ export interface LoadRemoteMatch {
     expose: string;
     remote: Remote;
     options: Options;
-    origin: ModuleFederation;
+    origin: FederationHost;
     remoteInfo: RemoteInfo;
     remoteSnapshot?: ModuleInfo;
 }
 export declare class RemoteHandler {
-    host: ModuleFederation;
+    host: FederationHost;
     idToRemoteMap: Record<string, {
         name: string;
         expose: string;
@@ -22,16 +22,16 @@ export declare class RemoteHandler {
     hooks: PluginSystem<{
         beforeRegisterRemote: SyncWaterfallHook<{
             remote: Remote;
-            origin: ModuleFederation;
+            origin: FederationHost;
         }>;
         registerRemote: SyncWaterfallHook<{
             remote: Remote;
-            origin: ModuleFederation;
+            origin: FederationHost;
         }>;
         beforeRequest: AsyncWaterfallHook<{
             id: string;
             options: Options;
-            origin: ModuleFederation;
+            origin: FederationHost;
         }>;
         onLoad: AsyncHook<[{
             id: string;
@@ -39,7 +39,7 @@ export declare class RemoteHandler {
             pkgNameOrAlias: string;
             remote: Remote;
             options: ModuleOptions;
-            origin: ModuleFederation;
+            origin: FederationHost;
             exposeModule: any;
             exposeModuleFactory: any;
             moduleInstance: Module;
@@ -50,7 +50,7 @@ export declare class RemoteHandler {
             remote: Remote;
             remoteSnapshot: ModuleInfo;
             preloadConfig: PreloadRemoteArgs;
-            origin: ModuleFederation;
+            origin: FederationHost;
         }], void>;
         errorLoadRemote: AsyncHook<[{
             id: string;
@@ -58,15 +58,15 @@ export declare class RemoteHandler {
             options?: any;
             from: CallFrom;
             lifecycle: "beforeRequest" | "beforeLoadShare" | "afterResolve" | "onLoad";
-            origin: ModuleFederation;
+            origin: FederationHost;
         }], unknown>;
         beforePreloadRemote: AsyncHook<[{
             preloadOps: Array<PreloadRemoteArgs>;
             options: Options;
-            origin: ModuleFederation;
+            origin: FederationHost;
         }], false | void | Promise<false | void>>;
         generatePreloadAssets: AsyncHook<[{
-            origin: ModuleFederation;
+            origin: FederationHost;
             preloadOptions: PreloadOptions[number];
             remote: Remote;
             remoteInfo: RemoteInfo;
@@ -76,15 +76,15 @@ export declare class RemoteHandler {
         afterPreloadRemote: AsyncHook<{
             preloadOps: Array<PreloadRemoteArgs>;
             options: Options;
-            origin: ModuleFederation;
+            origin: FederationHost;
         }, false | void | Promise<false | void>>;
         loadEntry: AsyncHook<[{
-            loaderHook: ModuleFederation["loaderHook"];
+            loaderHook: FederationHost["loaderHook"];
             remoteInfo: RemoteInfo;
             remoteEntryExports?: RemoteEntryExports;
         }], Promise<RemoteEntryExports>>;
     }>;
-    constructor(host: ModuleFederation);
+    constructor(host: FederationHost);
     formatAndRegisterRemote(globalOptions: Options, userOptions: UserOptions): Remote[];
     setIdToRemoteMap(id: string, remoteMatchInfo: LoadRemoteMatch): void;
     loadRemote<T>(id: string, options?: {

package/dist/src/shared/index.d.ts

@@ -1,10 +1,10 @@
 import { Federation } from '../global';
 import { Options, ShareScopeMap, ShareInfos, Shared, UserOptions, ShareStrategy, InitScope, InitTokens, CallFrom } from '../type';
-import { ModuleFederation } from '../core';
+import { FederationHost } from '../core';
 import { PluginSystem, AsyncHook, AsyncWaterfallHook, SyncWaterfallHook } from '../utils/hooks';
 import { LoadRemoteMatch } from '../remote';
 export declare class SharedHandler {
-    host: ModuleFederation;
+    host: FederationHost;
     shareScopeMap: ShareScopeMap;
     hooks: PluginSystem<{
         afterResolve: AsyncWaterfallHook<LoadRemoteMatch>;
@@ -12,9 +12,9 @@ export declare class SharedHandler {
             pkgName: string;
             shareInfo?: Shared;
             shared: Options["shared"];
-            origin: ModuleFederation;
+            origin: FederationHost;
         }>;
-        loadShare: AsyncHook<[ModuleFederation, string, ShareInfos], false | void | Promise<false | void>>;
+        loadShare: AsyncHook<[FederationHost, string, ShareInfos], false | void | Promise<false | void>>;
         resolveShare: SyncWaterfallHook<{
             shareScopeMap: ShareScopeMap;
             scope: string;
@@ -26,13 +26,13 @@ export declare class SharedHandler {
         initContainerShareScopeMap: SyncWaterfallHook<{
             shareScope: ShareScopeMap[string];
             options: Options;
-            origin: ModuleFederation;
+            origin: FederationHost;
             scopeName: string;
             hostShareScopeMap?: ShareScopeMap;
         }>;
     }>;
     initTokens: InitTokens;
-    constructor(host: ModuleFederation);
+    constructor(host: FederationHost);
     registerShared(globalOptions: Options, userOptions: UserOptions): {
         shareInfos: ShareInfos;
         shared: {

package/dist/src/type/config.d.ts

@@ -1,5 +1,5 @@
 import type { RemoteWithEntry, RemoteWithVersion, Module, RemoteEntryType } from '@module-federation/sdk';
-import { ModuleFederationRuntimePlugin } from './plugin';
+import { FederationRuntimePlugin } from './plugin';
 export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
 export type PartialOptional<T, K extends keyof T> = Omit<T, K> & {
     [P in K]-?: T[P];
@@ -88,7 +88,7 @@ export interface Options {
     version?: string;
     remotes: Array<Remote>;
     shared: ShareInfos;
-    plugins: Array<ModuleFederationRuntimePlugin>;
+    plugins: Array<FederationRuntimePlugin>;
     inBrowser: boolean;
     shareStrategy?: ShareStrategy;
 }

package/dist/src/type/plugin.d.ts

@@ -1,9 +1,9 @@
-import { ModuleFederation } from '../core';
+import { FederationHost } from '../core';
 import { Module } from '../module';
 import { SnapshotHandler } from '../plugins/snapshot/SnapshotHandler';
 import { SharedHandler } from '../shared';
 import { RemoteHandler } from '../remote';
-type CoreLifeCycle = ModuleFederation['hooks']['lifecycle'];
+type CoreLifeCycle = FederationHost['hooks']['lifecycle'];
 type CoreLifeCyclePartial = Partial<{
     [k in keyof CoreLifeCycle]: Parameters<CoreLifeCycle[k]['on']>[0];
 }>;
@@ -27,7 +27,7 @@ type RemoteLifeCycle = RemoteHandler['hooks']['lifecycle'];
 type RemoteLifeCycleCyclePartial = Partial<{
     [k in keyof RemoteLifeCycle]: Parameters<RemoteLifeCycle[k]['on']>[0];
 }>;
-export type ModuleFederationRuntimePlugin = CoreLifeCyclePartial & SnapshotLifeCycleCyclePartial & SharedLifeCycleCyclePartial & RemoteLifeCycleCyclePartial & ModuleLifeCycleCyclePartial & ModuleBridgeLifeCycleCyclePartial & {
+export type FederationRuntimePlugin = CoreLifeCyclePartial & SnapshotLifeCycleCyclePartial & SharedLifeCycleCyclePartial & RemoteLifeCycleCyclePartial & ModuleLifeCycleCyclePartial & ModuleBridgeLifeCycleCyclePartial & {
     name: string;
     version?: string;
 };

package/dist/src/utils/load.d.ts

@@ -1,8 +1,8 @@
-import { ModuleFederation } from '../core';
+import { FederationHost } from '../core';
 import { Remote, RemoteEntryExports, RemoteInfo } from '../type';
 export declare function getRemoteEntryUniqueKey(remoteInfo: RemoteInfo): string;
 export declare function getRemoteEntry({ origin, remoteEntryExports, remoteInfo, }: {
-    origin: ModuleFederation;
+    origin: FederationHost;
     remoteInfo: RemoteInfo;
     remoteEntryExports?: RemoteEntryExports | undefined;
 }): Promise<RemoteEntryExports | false | void>;

package/dist/src/utils/plugin.d.ts

@@ -1,4 +1,4 @@
-import { ModuleFederation } from '../core';
+import { FederationHost } from '../core';
 import { UserOptions } from '../type';
 import { Module } from '../module';
-export declare function registerPlugins(plugins: UserOptions['plugins'], hookInstances: Array<ModuleFederation['hooks'] | ModuleFederation['snapshotHandler']['hooks'] | ModuleFederation['sharedHandler']['hooks'] | ModuleFederation['remoteHandler']['hooks'] | Module['host']['loaderHook'] | Module['host']['bridgeHook']>): import("../type").ModuleFederationRuntimePlugin[] | undefined;
+export declare function registerPlugins(plugins: UserOptions['plugins'], hookInstances: Array<FederationHost['hooks'] | FederationHost['snapshotHandler']['hooks'] | FederationHost['sharedHandler']['hooks'] | FederationHost['remoteHandler']['hooks'] | Module['host']['loaderHook'] | Module['host']['bridgeHook']>): import("../type").FederationRuntimePlugin[] | undefined;

package/dist/src/utils/preload.d.ts

@@ -1,6 +1,6 @@
 import { PreloadAssets, PreloadConfig, PreloadOptions, PreloadRemoteArgs, Remote, RemoteInfo, depsPreloadArg } from '../type';
-import { ModuleFederation } from '../core';
+import { FederationHost } from '../core';
 export declare function defaultPreloadArgs(preloadConfig: PreloadRemoteArgs | depsPreloadArg): PreloadConfig;
 export declare function formatPreloadArgs(remotes: Array<Remote>, preloadArgs: Array<PreloadRemoteArgs>): PreloadOptions;
 export declare function normalizePreloadExposes(exposes?: string[]): string[];
-export declare function preloadAssets(remoteInfo: RemoteInfo, host: ModuleFederation, assets: PreloadAssets, useLinkPreload?: boolean): void;
+export declare function preloadAssets(remoteInfo: RemoteInfo, host: FederationHost, assets: PreloadAssets, useLinkPreload?: boolean): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/runtime-core",
-  "version": "0.0.0-next-20250707074728",
+  "version": "0.0.0-next-20250708033956",
   "type": "module",
   "author": "zhouxiao <codingzx@gmail.com>",
   "main": "./dist/index.cjs.cjs",
@@ -52,7 +52,7 @@
     }
   },
   "dependencies": {
-    "@module-federation/sdk": "0.0.0-next-20250707074728",
-    "@module-federation/error-codes": "0.0.0-next-20250707074728"
+    "@module-federation/sdk": "0.0.0-next-20250708033956",
+    "@module-federation/error-codes": "0.0.0-next-20250708033956"
   }
 }