@module-federation/runtime-core 0.0.0-feat-shared-treeshake-poc-20260112063915 → 0.0.0-feat-modern-3-0-20260113090730

package/dist/index.cjs.cjs

@@ -201,7 +201,7 @@ function getGlobalFederationConstructor() {
 function setGlobalFederationConstructor(FederationConstructor, isDebug = sdk.isDebugMode()) {
     if (isDebug) {
         CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR__ = FederationConstructor;
-        CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "0.0.0-feat-shared-treeshake-poc-20260112063915";
+        CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "0.0.0-feat-modern-3-0-20260113090730";
     }
 }
 // eslint-disable-next-line @typescript-eslint/ban-types
@@ -808,9 +808,6 @@ function formatShare(shareArgs, from, name, shareStrategy) {
             throw new Error(`Can not get shared '${name}'!`);
         });
     }
-    if (shareArgs.shareConfig?.eager && shareArgs.treeShaking) {
-        throw new Error('Can not set "eager:true" and "treeShaking" at the same time!');
-    }
     return {
         deps: [],
         useIn: [],
@@ -831,67 +828,37 @@ function formatShare(shareArgs, from, name, shareStrategy) {
             ? shareArgs.scope
             : [shareArgs.scope ?? 'default'],
         strategy: (shareArgs.strategy ?? shareStrategy) || 'version-first',
-        treeShaking: shareArgs.treeShaking
-            ? {
-                ...shareArgs.treeShaking,
-                mode: shareArgs.treeShaking.mode ?? 'server-calc',
-                status: shareArgs.treeShaking.status ?? 1 /* TreeShakingStatus.UNKNOWN */,
-                useIn: [],
-            }
-            : undefined,
     };
 }
-function formatShareConfigs(prevOptions, newOptions) {
-    const shareArgs = newOptions.shared || {};
-    const from = newOptions.name;
-    const newShareInfos = Object.keys(shareArgs).reduce((res, pkgName) => {
+function formatShareConfigs(globalOptions, userOptions) {
+    const shareArgs = userOptions.shared || {};
+    const from = userOptions.name;
+    const shareInfos = Object.keys(shareArgs).reduce((res, pkgName) => {
         const arrayShareArgs = arrayOptions(shareArgs[pkgName]);
         res[pkgName] = res[pkgName] || [];
         arrayShareArgs.forEach((shareConfig) => {
-            res[pkgName].push(formatShare(shareConfig, from, pkgName, newOptions.shareStrategy));
+            res[pkgName].push(formatShare(shareConfig, from, pkgName, userOptions.shareStrategy));
         });
         return res;
     }, {});
-    const allShareInfos = {
-        ...prevOptions.shared,
+    const shared = {
+        ...globalOptions.shared,
     };
-    Object.keys(newShareInfos).forEach((shareKey) => {
-        if (!allShareInfos[shareKey]) {
-            allShareInfos[shareKey] = newShareInfos[shareKey];
+    Object.keys(shareInfos).forEach((shareKey) => {
+        if (!shared[shareKey]) {
+            shared[shareKey] = shareInfos[shareKey];
         }
         else {
-            newShareInfos[shareKey].forEach((newUserSharedOptions) => {
-                const isSameVersion = allShareInfos[shareKey].find((sharedVal) => sharedVal.version === newUserSharedOptions.version);
+            shareInfos[shareKey].forEach((newUserSharedOptions) => {
+                const isSameVersion = shared[shareKey].find((sharedVal) => sharedVal.version === newUserSharedOptions.version);
                 if (!isSameVersion) {
-                    allShareInfos[shareKey].push(newUserSharedOptions);
+                    shared[shareKey].push(newUserSharedOptions);
                 }
             });
         }
     });
-    return { allShareInfos, newShareInfos };
-}
-function shouldUseTreeShaking(treeShaking, usedExports) {
-    if (!treeShaking) {
-        return false;
-    }
-    const { status, mode } = treeShaking;
-    if (status === 0 /* TreeShakingStatus.NO_USE */) {
-        return false;
-    }
-    if (status === 2 /* TreeShakingStatus.CALCULATED */) {
-        return true;
-    }
-    if (mode === 'runtime-infer') {
-        if (!usedExports) {
-            return true;
-        }
-        return isMatchUsedExports(treeShaking, usedExports);
-    }
-    return false;
+    return { shared, shareInfos };
 }
-/**
- * compare version a and b, return true if a is less than b
- */
 function versionLt(a, b) {
     const transformInvalidVersion = (version) => {
         const isNumberVersion = !Number.isNaN(Number(version));
@@ -937,79 +904,19 @@ const isLoaded = (shared) => {
 const isLoading = (shared) => {
     return Boolean(shared.loading);
 };
-const isMatchUsedExports = (treeShaking, usedExports) => {
-    if (!treeShaking || !usedExports) {
-        return false;
-    }
-    const { usedExports: treeShakingUsedExports } = treeShaking;
-    if (!treeShakingUsedExports) {
-        return false;
-    }
-    if (usedExports.every((e) => treeShakingUsedExports.includes(e))) {
-        return true;
-    }
-    return false;
-};
-function findSingletonVersionOrderByVersion(shareScopeMap, scope, pkgName, treeShaking) {
+function findSingletonVersionOrderByVersion(shareScopeMap, scope, pkgName) {
     const versions = shareScopeMap[scope][pkgName];
-    let version = '';
-    let useTreesShaking = shouldUseTreeShaking(treeShaking);
-    // return false means use prev version
     const callback = function (prev, cur) {
-        if (useTreesShaking) {
-            if (!versions[prev].treeShaking) {
-                return true;
-            }
-            if (!versions[cur].treeShaking) {
-                return false;
-            }
-            return !isLoaded(versions[prev].treeShaking) && versionLt(prev, cur);
-        }
         return !isLoaded(versions[prev]) && versionLt(prev, cur);
     };
-    if (useTreesShaking) {
-        version = findVersion(shareScopeMap[scope][pkgName], callback);
-        if (version) {
-            return {
-                version,
-                useTreesShaking,
-            };
-        }
-        useTreesShaking = false;
-    }
-    return {
-        version: findVersion(shareScopeMap[scope][pkgName], callback),
-        useTreesShaking,
-    };
+    return findVersion(shareScopeMap[scope][pkgName], callback);
 }
-const isLoadingOrLoaded = (shared) => {
-    return isLoaded(shared) || isLoading(shared);
-};
-function findSingletonVersionOrderByLoaded(shareScopeMap, scope, pkgName, treeShaking) {
+function findSingletonVersionOrderByLoaded(shareScopeMap, scope, pkgName) {
     const versions = shareScopeMap[scope][pkgName];
-    let version = '';
-    let useTreesShaking = shouldUseTreeShaking(treeShaking);
-    // return false means use prev version
     const callback = function (prev, cur) {
-        if (useTreesShaking) {
-            if (!versions[prev].treeShaking) {
-                return true;
-            }
-            if (!versions[cur].treeShaking) {
-                return false;
-            }
-            if (isLoadingOrLoaded(versions[cur].treeShaking)) {
-                if (isLoadingOrLoaded(versions[prev].treeShaking)) {
-                    return Boolean(versionLt(prev, cur));
-                }
-                else {
-                    return true;
-                }
-            }
-            if (isLoadingOrLoaded(versions[prev].treeShaking)) {
-                return false;
-            }
-        }
+        const isLoadingOrLoaded = (shared) => {
+            return isLoaded(shared) || isLoading(shared);
+        };
         if (isLoadingOrLoaded(versions[cur])) {
             if (isLoadingOrLoaded(versions[prev])) {
                 return Boolean(versionLt(prev, cur));
@@ -1023,20 +930,7 @@ function findSingletonVersionOrderByLoaded(shareScopeMap, scope, pkgName, treeSh
         }
         return versionLt(prev, cur);
     };
-    if (useTreesShaking) {
-        version = findVersion(shareScopeMap[scope][pkgName], callback);
-        if (version) {
-            return {
-                version,
-                useTreesShaking,
-            };
-        }
-        useTreesShaking = false;
-    }
-    return {
-        version: findVersion(shareScopeMap[scope][pkgName], callback),
-        useTreesShaking,
-    };
+    return findVersion(shareScopeMap[scope][pkgName], callback);
 }
 function getFindShareFunction(strategy) {
     if (strategy === 'loaded-first') {
@@ -1048,7 +942,7 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
     if (!localShareScopeMap) {
         return;
     }
-    const { shareConfig, scope = DEFAULT_SCOPE, strategy, treeShaking, } = shareInfo;
+    const { shareConfig, scope = DEFAULT_SCOPE, strategy } = shareInfo;
     const scopes = Array.isArray(scope) ? scope : [scope];
     for (const sc of scopes) {
         if (shareConfig &&
@@ -1056,13 +950,14 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
             localShareScopeMap[sc][pkgName]) {
             const { requiredVersion } = shareConfig;
             const findShareFunction = getFindShareFunction(strategy);
-            const { version: maxOrSingletonVersion, useTreesShaking } = findShareFunction(localShareScopeMap, sc, pkgName, treeShaking);
+            const maxOrSingletonVersion = findShareFunction(localShareScopeMap, sc, pkgName);
+            //@ts-ignore
             const defaultResolver = () => {
-                const shared = localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
                 if (shareConfig.singleton) {
                     if (typeof requiredVersion === 'string' &&
                         !satisfy(maxOrSingletonVersion, requiredVersion)) {
-                        const msg = `Version ${maxOrSingletonVersion} from ${maxOrSingletonVersion && shared.from} of shared singleton module ${pkgName} does not satisfy the requirement of ${shareInfo.from} which needs ${requiredVersion})`;
+                        const msg = `Version ${maxOrSingletonVersion} from ${maxOrSingletonVersion &&
+                            localShareScopeMap[sc][pkgName][maxOrSingletonVersion].from} of shared singleton module ${pkgName} does not satisfy the requirement of ${shareInfo.from} which needs ${requiredVersion})`;
                         if (shareConfig.strictVersion) {
                             error(msg);
                         }
@@ -1070,48 +965,21 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
                             warn(msg);
                         }
                     }
-                    return {
-                        shared,
-                        useTreesShaking,
-                    };
+                    return localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
                 }
                 else {
                     if (requiredVersion === false || requiredVersion === '*') {
-                        return {
-                            shared,
-                            useTreesShaking,
-                        };
+                        return localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
                     }
                     if (satisfy(maxOrSingletonVersion, requiredVersion)) {
-                        return {
-                            shared,
-                            useTreesShaking,
-                        };
-                    }
-                    const _usedTreeShaking = shouldUseTreeShaking(treeShaking);
-                    if (_usedTreeShaking) {
-                        for (const [versionKey, versionValue] of Object.entries(localShareScopeMap[sc][pkgName])) {
-                            if (!shouldUseTreeShaking(versionValue.treeShaking, treeShaking?.usedExports)) {
-                                continue;
-                            }
-                            if (satisfy(versionKey, requiredVersion)) {
-                                return {
-                                    shared: versionValue,
-                                    useTreesShaking: _usedTreeShaking,
-                                };
-                            }
-                        }
+                        return localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
                     }
                     for (const [versionKey, versionValue] of Object.entries(localShareScopeMap[sc][pkgName])) {
                         if (satisfy(versionKey, requiredVersion)) {
-                            return {
-                                shared: versionValue,
-                                useTreesShaking: false,
-                            };
+                            return versionValue;
                         }
                     }
                 }
-                return;
             };
             const params = {
                 shareScopeMap: localShareScopeMap,
@@ -1119,7 +987,6 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
                 pkgName,
                 version: maxOrSingletonVersion,
                 GlobalFederation: Global.__FEDERATION__,
-                shareInfo,
                 resolver: defaultResolver,
             };
             const resolveShared = resolveShare.emit(params) || params;
@@ -1141,47 +1008,13 @@ function getTargetSharedOptions(options) {
             shareVersionMap[shared.version] = shared;
         });
         const callback = function (prev, cur) {
-            return (
-            // TODO: consider multiple treeShaking shared scenes
-            !isLoaded(shareVersionMap[prev]) && versionLt(prev, cur));
+            return !isLoaded(shareVersionMap[prev]) && versionLt(prev, cur);
         };
         const maxVersion = findVersion(shareVersionMap, callback);
         return shareVersionMap[maxVersion];
     };
     const resolver = extraOptions?.resolver ?? defaultResolver;
-    const isPlainObject = (val) => {
-        return val !== null && typeof val === 'object' && !Array.isArray(val);
-    };
-    const merge = (...sources) => {
-        const out = {};
-        for (const src of sources) {
-            if (!src)
-                continue;
-            for (const [key, value] of Object.entries(src)) {
-                const prev = out[key];
-                if (isPlainObject(prev) && isPlainObject(value)) {
-                    out[key] = merge(prev, value);
-                }
-                else if (value !== undefined) {
-                    out[key] = value;
-                }
-            }
-        }
-        return out;
-    };
-    return merge(resolver(shareInfos[pkgName]), extraOptions?.customShareInfo);
-}
-const addUseIn = (shared, from) => {
-    if (!shared.useIn) {
-        shared.useIn = [];
-    }
-    addUniqueItem(shared.useIn, from);
-};
-function directShare(shared, useTreesShaking) {
-    if (useTreesShaking && shared.treeShaking) {
-        return shared.treeShaking;
-    }
-    return shared;
+    return Object.assign({}, resolver(shareInfos[pkgName]), extraOptions?.customShareInfo);
 }
 
 function getBuilderId() {
@@ -1693,40 +1526,6 @@ var helpers = {
     },
 };
 
-function createRemoteEntryInitOptions(remoteInfo, hostShareScopeMap) {
-    const localShareScopeMap = hostShareScopeMap;
-    const shareScopeKeys = Array.isArray(remoteInfo.shareScope)
-        ? remoteInfo.shareScope
-        : [remoteInfo.shareScope];
-    if (!shareScopeKeys.length) {
-        shareScopeKeys.push('default');
-    }
-    shareScopeKeys.forEach((shareScopeKey) => {
-        if (!localShareScopeMap[shareScopeKey]) {
-            localShareScopeMap[shareScopeKey] = {};
-        }
-    });
-    const remoteEntryInitOptions = {
-        version: remoteInfo.version || '',
-        shareScopeKeys: Array.isArray(remoteInfo.shareScope)
-            ? shareScopeKeys
-            : remoteInfo.shareScope || 'default',
-    };
-    // Help to find host instance
-    Object.defineProperty(remoteEntryInitOptions, 'shareScopeMap', {
-        value: localShareScopeMap,
-        // remoteEntryInitOptions will be traversed and assigned during container init, ,so this attribute is not allowed to be traversed
-        enumerable: false,
-    });
-    // TODO: compate legacy init params, should use shareScopeMap if exist
-    const shareScope = localShareScopeMap[shareScopeKeys[0]];
-    const initScope = [];
-    return {
-        remoteEntryInitOptions,
-        shareScope,
-        initScope,
-    };
-}
 class Module {
     constructor({ remoteInfo, host, }) {
         this.inited = false;
@@ -1748,12 +1547,37 @@ class Module {
         return this.remoteEntryExports;
     }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-    async get(id, expose, options, remoteSnapshot) {
-        const { loadFactory = true } = options || { loadFactory: true };
+    async init(id, remoteSnapshot) {
         // Get remoteEntry.js
         const remoteEntryExports = await this.getEntry();
         if (!this.inited) {
-            const { remoteEntryInitOptions, shareScope, initScope } = createRemoteEntryInitOptions(this.remoteInfo, this.host.shareScopeMap);
+            const localShareScopeMap = this.host.shareScopeMap;
+            const shareScopeKeys = Array.isArray(this.remoteInfo.shareScope)
+                ? this.remoteInfo.shareScope
+                : [this.remoteInfo.shareScope];
+            if (!shareScopeKeys.length) {
+                shareScopeKeys.push('default');
+            }
+            shareScopeKeys.forEach((shareScopeKey) => {
+                if (!localShareScopeMap[shareScopeKey]) {
+                    localShareScopeMap[shareScopeKey] = {};
+                }
+            });
+            // TODO: compate legacy init params, should use shareScopeMap if exist
+            const shareScope = localShareScopeMap[shareScopeKeys[0]];
+            const initScope = [];
+            const remoteEntryInitOptions = {
+                version: this.remoteInfo.version || '',
+                shareScopeKeys: Array.isArray(this.remoteInfo.shareScope)
+                    ? shareScopeKeys
+                    : this.remoteInfo.shareScope || 'default',
+            };
+            // Help to find host instance
+            Object.defineProperty(remoteEntryInitOptions, 'shareScopeMap', {
+                value: localShareScopeMap,
+                // remoteEntryInitOptions will be traversed and assigned during container init, ,so this attribute is not allowed to be traversed
+                enumerable: false,
+            });
             const initContainerOptions = await this.host.hooks.lifecycle.beforeInitContainer.emit({
                 shareScope,
                 // @ts-ignore shareScopeMap will be set by Object.defineProperty
@@ -1778,6 +1602,12 @@ class Module {
                 remoteEntryExports,
             });
         }
+        return remoteEntryExports;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    async get(id, expose, options, remoteSnapshot) {
+        const { loadFactory = true } = options || { loadFactory: true };
+        const remoteEntryExports = await this.init(id, remoteSnapshot);
         this.lib = remoteEntryExports;
         this.inited = true;
         let moduleFactory;
@@ -2233,7 +2063,7 @@ function generatePreloadAssets(origin, preloadOptions, remote, globalSnapshot, r
     }, true, memo, remoteSnapshot);
     if (remoteSnapshot.shared && remoteSnapshot.shared.length > 0) {
         const collectSharedAssets = (shareInfo, snapshotShared) => {
-            const { shared: registeredShared } = getRegisteredShare(origin.shareScopeMap, snapshotShared.sharedName, shareInfo, origin.sharedHandler.hooks.lifecycle.resolveShare) || {};
+            const registeredShared = getRegisteredShare(origin.shareScopeMap, snapshotShared.sharedName, shareInfo, origin.sharedHandler.hooks.lifecycle.resolveShare);
             // If the global share does not exist, or the lib function does not exist, it means that the shared has not been loaded yet and can be preloaded.
             if (registeredShared && typeof registeredShared.lib === 'function') {
                 snapshotShared.assets.js.sync.forEach((asset) => {
@@ -2524,7 +2354,6 @@ class SnapshotHandler {
 class SharedHandler {
     constructor(host) {
         this.hooks = new PluginSystem({
-            beforeRegisterShare: new SyncWaterfallHook('beforeRegisterShare'),
             afterResolve: new AsyncWaterfallHook('afterResolve'),
             beforeLoadShare: new AsyncWaterfallHook('beforeLoadShare'),
             // not used yet
@@ -2540,17 +2369,12 @@ class SharedHandler {
     }
     // register shared in shareScopeMap
     registerShared(globalOptions, userOptions) {
-        const { newShareInfos, allShareInfos } = formatShareConfigs(globalOptions, userOptions);
-        const sharedKeys = Object.keys(newShareInfos);
+        const { shareInfos, shared } = formatShareConfigs(globalOptions, userOptions);
+        const sharedKeys = Object.keys(shareInfos);
         sharedKeys.forEach((sharedKey) => {
-            const sharedVals = newShareInfos[sharedKey];
+            const sharedVals = shareInfos[sharedKey];
             sharedVals.forEach((sharedVal) => {
                 sharedVal.scope.forEach((sc) => {
-                    this.hooks.lifecycle.beforeRegisterShare.emit({
-                        origin: this.host,
-                        pkgName: sharedKey,
-                        shared: sharedVal,
-                    });
                     const registeredShared = this.shareScopeMap[sc]?.[sharedKey];
                     if (!registeredShared) {
                         this.setShared({
@@ -2566,8 +2390,8 @@ class SharedHandler {
             });
         });
         return {
-            newShareInfos,
-            allShareInfos,
+            shareInfos,
+            shared,
         };
     }
     async loadShare(pkgName, extraOptions) {
@@ -2598,61 +2422,61 @@ class SharedHandler {
         const { shareInfo: shareOptionsRes } = loadShareRes;
         // Assert that shareInfoRes exists, if not, throw an error
         assert(shareOptionsRes, `Cannot find ${pkgName} Share in the ${host.options.name}. Please ensure that the ${pkgName} Share parameters have been injected`);
-        const { shared: registeredShared, useTreesShaking } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare) || {};
-        if (registeredShared) {
-            const targetShared = directShare(registeredShared, useTreesShaking);
-            if (targetShared.lib) {
-                addUseIn(targetShared, host.options.name);
-                return targetShared.lib;
-            }
-            else if (targetShared.loading && !targetShared.loaded) {
-                const factory = await targetShared.loading;
-                targetShared.loaded = true;
-                if (!targetShared.lib) {
-                    targetShared.lib = factory;
-                }
-                addUseIn(targetShared, host.options.name);
-                return factory;
-            }
-            else {
-                const asyncLoadProcess = async () => {
-                    const factory = await targetShared.get();
-                    addUseIn(targetShared, host.options.name);
-                    targetShared.loaded = true;
-                    targetShared.lib = factory;
-                    return factory;
-                };
-                const loading = asyncLoadProcess();
-                this.setShared({
-                    pkgName,
-                    loaded: false,
-                    shared: registeredShared,
-                    from: host.options.name,
-                    lib: null,
-                    loading,
-                    treeShaking: useTreesShaking
-                        ? targetShared
-                        : undefined,
-                });
-                return loading;
+        // Retrieve from cache
+        const registeredShared = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare);
+        const addUseIn = (shared) => {
+            if (!shared.useIn) {
+                shared.useIn = [];
             }
+            addUniqueItem(shared.useIn, host.options.name);
+        };
+        if (registeredShared && registeredShared.lib) {
+            addUseIn(registeredShared);
+            return registeredShared.lib;
+        }
+        else if (registeredShared &&
+            registeredShared.loading &&
+            !registeredShared.loaded) {
+            const factory = await registeredShared.loading;
+            registeredShared.loaded = true;
+            if (!registeredShared.lib) {
+                registeredShared.lib = factory;
+            }
+            addUseIn(registeredShared);
+            return factory;
+        }
+        else if (registeredShared) {
+            const asyncLoadProcess = async () => {
+                const factory = await registeredShared.get();
+                addUseIn(registeredShared);
+                registeredShared.loaded = true;
+                registeredShared.lib = factory;
+                return factory;
+            };
+            const loading = asyncLoadProcess();
+            this.setShared({
+                pkgName,
+                loaded: false,
+                shared: registeredShared,
+                from: host.options.name,
+                lib: null,
+                loading,
+            });
+            return loading;
         }
         else {
             if (extraOptions?.customShareInfo) {
                 return false;
             }
-            const _useTreeShaking = shouldUseTreeShaking(shareOptionsRes.treeShaking);
-            const targetShared = directShare(shareOptionsRes, _useTreeShaking);
             const asyncLoadProcess = async () => {
-                const factory = await targetShared.get();
-                targetShared.lib = factory;
-                targetShared.loaded = true;
-                addUseIn(targetShared, host.options.name);
-                const { shared: gShared, useTreesShaking: gUseTreeShaking } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare) || {};
+                const factory = await shareOptionsRes.get();
+                shareOptionsRes.lib = factory;
+                shareOptionsRes.loaded = true;
+                addUseIn(shareOptionsRes);
+                const gShared = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare);
                 if (gShared) {
-                    const targetGShared = directShare(gShared, gUseTreeShaking);
-                    targetGShared.lib = factory;
-                    targetGShared.loaded = true;
+                    gShared.lib = factory;
+                    gShared.loaded = true;
                     gShared.from = shareOptionsRes.from;
                 }
                 return factory;
@@ -2665,9 +2489,6 @@ class SharedHandler {
                 from: host.options.name,
                 lib: null,
                 loading,
-                treeShaking: _useTreeShaking
-                    ? targetShared
-                    : undefined,
             });
             return loading;
         }
@@ -2707,17 +2528,15 @@ class SharedHandler {
             const { version, eager } = shared;
             scope[name] = scope[name] || {};
             const versions = scope[name];
-            const activeVersion = versions[version] && directShare(versions[version]);
+            const activeVersion = versions[version];
             const activeVersionEager = Boolean(activeVersion &&
-                (('eager' in activeVersion && activeVersion.eager) ||
-                    ('shareConfig' in activeVersion &&
-                        activeVersion.shareConfig?.eager)));
+                (activeVersion.eager || activeVersion.shareConfig?.eager));
             if (!activeVersion ||
                 (activeVersion.strategy !== 'loaded-first' &&
                     !activeVersion.loaded &&
                     (Boolean(!eager) !== !activeVersionEager
                         ? eager
-                        : hostName > versions[version].from))) {
+                        : hostName > activeVersion.from))) {
                 versions[version] = shared;
             }
         };
@@ -2725,32 +2544,7 @@ class SharedHandler {
             const { module } = await host.remoteHandler.getRemoteModuleAndOptions({
                 id: key,
             });
-            if (module.getEntry) {
-                let remoteEntryExports;
-                try {
-                    remoteEntryExports = await module.getEntry();
-                }
-                catch (error) {
-                    remoteEntryExports =
-                        (await host.remoteHandler.hooks.lifecycle.errorLoadRemote.emit({
-                            id: key,
-                            error,
-                            from: 'runtime',
-                            lifecycle: 'beforeLoadShare',
-                            origin: host,
-                        }));
-                }
-                if (!module.inited) {
-                    const initFn = (mod) => {
-                        const { remoteEntryInitOptions } = createRemoteEntryInitOptions(module.remoteInfo, host.shareScopeMap);
-                        return (mod &&
-                            mod.init &&
-                            mod.init(shareScope[shareScopeName], initScope, remoteEntryInitOptions));
-                    };
-                    await initFn(remoteEntryExports);
-                    module.inited = true;
-                }
-            }
+            await module.init();
         };
         Object.keys(host.options.shared).forEach((shareName) => {
             const sharedArr = host.options.shared[shareName];
@@ -2787,10 +2581,16 @@ class SharedHandler {
                 this.initializeSharing(shareScope, { strategy: shareOptions.strategy });
             });
         }
-        const { shared: registeredShared, useTreesShaking } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptions, this.hooks.lifecycle.resolveShare) || {};
+        const registeredShared = getRegisteredShare(this.shareScopeMap, pkgName, shareOptions, this.hooks.lifecycle.resolveShare);
+        const addUseIn = (shared) => {
+            if (!shared.useIn) {
+                shared.useIn = [];
+            }
+            addUniqueItem(shared.useIn, host.options.name);
+        };
         if (registeredShared) {
             if (typeof registeredShared.lib === 'function') {
-                addUseIn(registeredShared, host.options.name);
+                addUseIn(registeredShared);
                 if (!registeredShared.loaded) {
                     registeredShared.loaded = true;
                     if (registeredShared.from === host.options.name) {
@@ -2802,7 +2602,7 @@ class SharedHandler {
             if (typeof registeredShared.get === 'function') {
                 const module = registeredShared.get();
                 if (!(module instanceof Promise)) {
-                    addUseIn(registeredShared, host.options.name);
+                    addUseIn(registeredShared);
                     this.setShared({
                         pkgName,
                         loaded: true,
@@ -2855,20 +2655,9 @@ class SharedHandler {
             hostShareScopeMap: extraOptions.hostShareScopeMap,
         });
     }
-    setShared({ pkgName, shared, from, lib, loading, loaded, get, treeShaking, }) {
+    setShared({ pkgName, shared, from, lib, loading, loaded, get, }) {
         const { version, scope = 'default', ...shareInfo } = shared;
         const scopes = Array.isArray(scope) ? scope : [scope];
-        const mergeAttrs = (shared) => {
-            const merge = (s, key, val) => {
-                if (val && !s[key]) {
-                    s[key] = val;
-                }
-            };
-            const targetShared = (treeShaking ? shared.treeShaking : shared);
-            merge(targetShared, 'loaded', loaded);
-            merge(targetShared, 'loading', loading);
-            merge(targetShared, 'get', get);
-        };
         scopes.forEach((sc) => {
             if (!this.shareScopeMap[sc]) {
                 this.shareScopeMap[sc] = {};
@@ -2882,10 +2671,21 @@ class SharedHandler {
                     scope: [sc],
                     ...shareInfo,
                     lib,
+                    loaded,
+                    loading,
                 };
+                if (get) {
+                    this.shareScopeMap[sc][pkgName][version].get = get;
+                }
+                return;
             }
             const registeredShared = this.shareScopeMap[sc][pkgName][version];
-            mergeAttrs(registeredShared);
+            if (loading && !registeredShared.loading) {
+                registeredShared.loading = loading;
+            }
+            if (loaded && !registeredShared.loaded) {
+                registeredShared.loaded = loaded;
+            }
             if (from && registeredShared.from !== from) {
                 registeredShared.from = from;
             }
@@ -2913,7 +2713,6 @@ class RemoteHandler {
             generatePreloadAssets: new AsyncHook('generatePreloadAssets'),
             // not used yet
             afterPreloadRemote: new AsyncHook(),
-            // TODO: Move to loaderHook
             loadEntry: new AsyncHook(),
         });
         this.host = host;
@@ -3262,7 +3061,7 @@ class ModuleFederation {
             // maybe will change, temporarily for internal use only
             initContainer: new AsyncWaterfallHook('initContainer'),
         });
-        this.version = "0.0.0-feat-shared-treeshake-poc-20260112063915";
+        this.version = "0.0.0-feat-modern-3-0-20260113090730";
         this.moduleCache = new Map();
         this.loaderHook = new PluginSystem({
             // FIXME: may not be suitable , not open to the public yet
@@ -3343,7 +3142,7 @@ class ModuleFederation {
         this.sharedHandler.initShareScopeMap(scopeName, shareScope, extraOptions);
     }
     formatOptions(globalOptions, userOptions) {
-        const { allShareInfos: shared} = formatShareConfigs(globalOptions, userOptions);
+        const { shared } = formatShareConfigs(globalOptions, userOptions);
         const { userOptions: userOptionsRes, options: globalOptionsRes } = this.hooks.lifecycle.beforeInit.emit({
             origin: this,
             userOptions,
@@ -3351,7 +3150,7 @@ class ModuleFederation {
             shareInfo: shared,
         });
         const remotes = this.remoteHandler.formatAndRegisterRemote(globalOptionsRes, userOptionsRes);
-        const { allShareInfos } = this.sharedHandler.registerShared(globalOptionsRes, userOptionsRes);
+        const { shared: handledShared } = this.sharedHandler.registerShared(globalOptionsRes, userOptionsRes);
         const plugins = [...globalOptionsRes.plugins];
         if (userOptionsRes.plugins) {
             userOptionsRes.plugins.forEach((plugin) => {
@@ -3365,7 +3164,7 @@ class ModuleFederation {
             ...userOptions,
             plugins,
             remotes,
-            shared: allShareInfos,
+            shared: handledShared,
         };
         this.hooks.lifecycle.init.emit({
             origin: this,