@module-federation/runtime-core 0.0.0-feat-rspack-async-startup-20251223091151 → 0.0.0-feat-shared-treeshake-poc-20251224120020

package/dist/index.esm.js

@@ -200,7 +200,7 @@ function getGlobalFederationConstructor() {
 function setGlobalFederationConstructor(FederationConstructor, isDebug = isDebugMode()) {
     if (isDebug) {
         CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR__ = FederationConstructor;
-        CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "0.0.0-feat-rspack-async-startup-20251223091151";
+        CurrentGlobal.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = "0.0.0-feat-shared-treeshake-poc-20251224120020";
     }
 }
 // eslint-disable-next-line @typescript-eslint/ban-types
@@ -807,6 +807,9 @@ function formatShare(shareArgs, from, name, shareStrategy) {
             throw new Error(`Can not get shared '${name}'!`);
         });
     }
+    if (shareArgs.shareConfig?.eager && shareArgs.treeshake) {
+        throw new Error('Can not set "eager:true" and "treeshake" at the same time!');
+    }
     return {
         deps: [],
         useIn: [],
@@ -827,37 +830,67 @@ function formatShare(shareArgs, from, name, shareStrategy) {
             ? shareArgs.scope
             : [shareArgs.scope ?? 'default'],
         strategy: (shareArgs.strategy ?? shareStrategy) || 'version-first',
+        treeshake: shareArgs.treeshake
+            ? {
+                ...shareArgs.treeshake,
+                strategy: shareArgs.treeshake.strategy ?? 'server',
+                status: shareArgs.treeshake.status ?? 1 /* TreeshakeStatus.UNKNOWN */,
+                useIn: [],
+            }
+            : undefined,
     };
 }
-function formatShareConfigs(globalOptions, userOptions) {
-    const shareArgs = userOptions.shared || {};
-    const from = userOptions.name;
-    const shareInfos = Object.keys(shareArgs).reduce((res, pkgName) => {
+function formatShareConfigs(prevOptions, newOptions) {
+    const shareArgs = newOptions.shared || {};
+    const from = newOptions.name;
+    const newShareInfos = 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, userOptions.shareStrategy));
+            res[pkgName].push(formatShare(shareConfig, from, pkgName, newOptions.shareStrategy));
         });
         return res;
     }, {});
-    const shared = {
-        ...globalOptions.shared,
+    const allShareInfos = {
+        ...prevOptions.shared,
     };
-    Object.keys(shareInfos).forEach((shareKey) => {
-        if (!shared[shareKey]) {
-            shared[shareKey] = shareInfos[shareKey];
+    Object.keys(newShareInfos).forEach((shareKey) => {
+        if (!allShareInfos[shareKey]) {
+            allShareInfos[shareKey] = newShareInfos[shareKey];
         }
         else {
-            shareInfos[shareKey].forEach((newUserSharedOptions) => {
-                const isSameVersion = shared[shareKey].find((sharedVal) => sharedVal.version === newUserSharedOptions.version);
+            newShareInfos[shareKey].forEach((newUserSharedOptions) => {
+                const isSameVersion = allShareInfos[shareKey].find((sharedVal) => sharedVal.version === newUserSharedOptions.version);
                 if (!isSameVersion) {
-                    shared[shareKey].push(newUserSharedOptions);
+                    allShareInfos[shareKey].push(newUserSharedOptions);
                 }
             });
         }
     });
-    return { shared, shareInfos };
+    return { allShareInfos, newShareInfos };
 }
+function shouldUseTreeshake(treeshake, usedExports) {
+    if (!treeshake) {
+        return false;
+    }
+    const { status, strategy } = treeshake;
+    if (status === 0 /* TreeshakeStatus.NO_USE */) {
+        return false;
+    }
+    if (status === 2 /* TreeshakeStatus.CALCULATED */) {
+        return true;
+    }
+    if (strategy === 'infer') {
+        if (!usedExports) {
+            return true;
+        }
+        return isMatchUsedExports(treeshake, usedExports);
+    }
+    return false;
+}
+/**
+ * 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));
@@ -903,19 +936,79 @@ const isLoaded = (shared) => {
 const isLoading = (shared) => {
     return Boolean(shared.loading);
 };
-function findSingletonVersionOrderByVersion(shareScopeMap, scope, pkgName) {
+const isMatchUsedExports = (treeshake, usedExports) => {
+    if (!treeshake || !usedExports) {
+        return false;
+    }
+    const { usedExports: treeshakeUsedExports } = treeshake;
+    if (!treeshakeUsedExports) {
+        return false;
+    }
+    if (usedExports.every((e) => treeshakeUsedExports.includes(e))) {
+        return true;
+    }
+    return false;
+};
+function findSingletonVersionOrderByVersion(shareScopeMap, scope, pkgName, treeshake) {
     const versions = shareScopeMap[scope][pkgName];
+    let version = '';
+    let useTreeshake = shouldUseTreeshake(treeshake);
+    // return false means use prev version
     const callback = function (prev, cur) {
+        if (useTreeshake) {
+            if (!versions[prev].treeshake) {
+                return true;
+            }
+            if (!versions[cur].treeshake) {
+                return false;
+            }
+            return !isLoaded(versions[prev].treeshake) && versionLt(prev, cur);
+        }
         return !isLoaded(versions[prev]) && versionLt(prev, cur);
     };
-    return findVersion(shareScopeMap[scope][pkgName], callback);
+    if (useTreeshake) {
+        version = findVersion(shareScopeMap[scope][pkgName], callback);
+        if (version) {
+            return {
+                version,
+                useTreeshake,
+            };
+        }
+        useTreeshake = false;
+    }
+    return {
+        version: findVersion(shareScopeMap[scope][pkgName], callback),
+        useTreeshake,
+    };
 }
-function findSingletonVersionOrderByLoaded(shareScopeMap, scope, pkgName) {
+const isLoadingOrLoaded = (shared) => {
+    return isLoaded(shared) || isLoading(shared);
+};
+function findSingletonVersionOrderByLoaded(shareScopeMap, scope, pkgName, treeshake) {
     const versions = shareScopeMap[scope][pkgName];
+    let version = '';
+    let useTreeshake = shouldUseTreeshake(treeshake);
+    // return false means use prev version
     const callback = function (prev, cur) {
-        const isLoadingOrLoaded = (shared) => {
-            return isLoaded(shared) || isLoading(shared);
-        };
+        if (useTreeshake) {
+            if (!versions[prev].treeshake) {
+                return true;
+            }
+            if (!versions[cur].treeshake) {
+                return false;
+            }
+            if (isLoadingOrLoaded(versions[cur].treeshake)) {
+                if (isLoadingOrLoaded(versions[prev].treeshake)) {
+                    return Boolean(versionLt(prev, cur));
+                }
+                else {
+                    return true;
+                }
+            }
+            if (isLoadingOrLoaded(versions[prev].treeshake)) {
+                return false;
+            }
+        }
         if (isLoadingOrLoaded(versions[cur])) {
             if (isLoadingOrLoaded(versions[prev])) {
                 return Boolean(versionLt(prev, cur));
@@ -929,7 +1022,20 @@ function findSingletonVersionOrderByLoaded(shareScopeMap, scope, pkgName) {
         }
         return versionLt(prev, cur);
     };
-    return findVersion(shareScopeMap[scope][pkgName], callback);
+    if (useTreeshake) {
+        version = findVersion(shareScopeMap[scope][pkgName], callback);
+        if (version) {
+            return {
+                version,
+                useTreeshake,
+            };
+        }
+        useTreeshake = false;
+    }
+    return {
+        version: findVersion(shareScopeMap[scope][pkgName], callback),
+        useTreeshake,
+    };
 }
 function getFindShareFunction(strategy) {
     if (strategy === 'loaded-first') {
@@ -941,7 +1047,7 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
     if (!localShareScopeMap) {
         return;
     }
-    const { shareConfig, scope = DEFAULT_SCOPE, strategy } = shareInfo;
+    const { shareConfig, scope = DEFAULT_SCOPE, strategy, treeshake } = shareInfo;
     const scopes = Array.isArray(scope) ? scope : [scope];
     for (const sc of scopes) {
         if (shareConfig &&
@@ -949,14 +1055,13 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
             localShareScopeMap[sc][pkgName]) {
             const { requiredVersion } = shareConfig;
             const findShareFunction = getFindShareFunction(strategy);
-            const maxOrSingletonVersion = findShareFunction(localShareScopeMap, sc, pkgName);
-            //@ts-ignore
+            const { version: maxOrSingletonVersion, useTreeshake } = findShareFunction(localShareScopeMap, sc, pkgName, treeshake);
             const defaultResolver = () => {
+                const shared = localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
                 if (shareConfig.singleton) {
                     if (typeof requiredVersion === 'string' &&
                         !satisfy(maxOrSingletonVersion, 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})`;
+                        const msg = `Version ${maxOrSingletonVersion} from ${maxOrSingletonVersion && shared.from} of shared singleton module ${pkgName} does not satisfy the requirement of ${shareInfo.from} which needs ${requiredVersion})`;
                         if (shareConfig.strictVersion) {
                             error(msg);
                         }
@@ -964,21 +1069,48 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
                             warn(msg);
                         }
                     }
-                    return localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
+                    return {
+                        shared,
+                        useTreeshake,
+                    };
                 }
                 else {
                     if (requiredVersion === false || requiredVersion === '*') {
-                        return localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
+                        return {
+                            shared,
+                            useTreeshake,
+                        };
                     }
                     if (satisfy(maxOrSingletonVersion, requiredVersion)) {
-                        return localShareScopeMap[sc][pkgName][maxOrSingletonVersion];
+                        return {
+                            shared,
+                            useTreeshake,
+                        };
+                    }
+                    const _usedTreeshake = shouldUseTreeshake(treeshake);
+                    if (_usedTreeshake) {
+                        for (const [versionKey, versionValue] of Object.entries(localShareScopeMap[sc][pkgName])) {
+                            if (!shouldUseTreeshake(versionValue.treeshake, treeshake?.usedExports)) {
+                                continue;
+                            }
+                            if (satisfy(versionKey, requiredVersion)) {
+                                return {
+                                    shared: versionValue,
+                                    useTreeshake: _usedTreeshake,
+                                };
+                            }
+                        }
                     }
                     for (const [versionKey, versionValue] of Object.entries(localShareScopeMap[sc][pkgName])) {
                         if (satisfy(versionKey, requiredVersion)) {
-                            return versionValue;
+                            return {
+                                shared: versionValue,
+                                useTreeshake: false,
+                            };
                         }
                     }
                 }
+                return;
             };
             const params = {
                 shareScopeMap: localShareScopeMap,
@@ -986,6 +1118,7 @@ function getRegisteredShare(localShareScopeMap, pkgName, shareInfo, resolveShare
                 pkgName,
                 version: maxOrSingletonVersion,
                 GlobalFederation: Global.__FEDERATION__,
+                shareInfo,
                 resolver: defaultResolver,
             };
             const resolveShared = resolveShare.emit(params) || params;
@@ -1007,13 +1140,47 @@ function getTargetSharedOptions(options) {
             shareVersionMap[shared.version] = shared;
         });
         const callback = function (prev, cur) {
-            return !isLoaded(shareVersionMap[prev]) && versionLt(prev, cur);
+            return (
+            // TODO: consider multiple treeshake shared scenes
+            !isLoaded(shareVersionMap[prev]) && versionLt(prev, cur));
         };
         const maxVersion = findVersion(shareVersionMap, callback);
         return shareVersionMap[maxVersion];
     };
     const resolver = extraOptions?.resolver ?? defaultResolver;
-    return Object.assign({}, resolver(shareInfos[pkgName]), extraOptions?.customShareInfo);
+    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, useTreeshake) {
+    if (useTreeshake && shared.treeshake) {
+        return shared.treeshake;
+    }
+    return shared;
 }
 
 function getBuilderId() {
@@ -1525,6 +1692,40 @@ 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;
@@ -1536,8 +1737,7 @@ class Module {
         if (this.remoteEntryExports) {
             return this.remoteEntryExports;
         }
-        let remoteEntryExports;
-        remoteEntryExports = await getRemoteEntry({
+        const remoteEntryExports = await getRemoteEntry({
             origin: this.host,
             remoteInfo: this.remoteInfo,
             remoteEntryExports: this.remoteEntryExports,
@@ -1552,33 +1752,7 @@ class Module {
         // Get remoteEntry.js
         const remoteEntryExports = await this.getEntry();
         if (!this.inited) {
-            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 { remoteEntryInitOptions, shareScope, initScope } = createRemoteEntryInitOptions(this.remoteInfo, this.host.shareScopeMap);
             const initContainerOptions = await this.host.hooks.lifecycle.beforeInitContainer.emit({
                 shareScope,
                 // @ts-ignore shareScopeMap will be set by Object.defineProperty
@@ -2058,7 +2232,7 @@ function generatePreloadAssets(origin, preloadOptions, remote, globalSnapshot, r
     }, true, memo, remoteSnapshot);
     if (remoteSnapshot.shared && remoteSnapshot.shared.length > 0) {
         const collectSharedAssets = (shareInfo, snapshotShared) => {
-            const registeredShared = getRegisteredShare(origin.shareScopeMap, snapshotShared.sharedName, shareInfo, origin.sharedHandler.hooks.lifecycle.resolveShare);
+            const { shared: 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) => {
@@ -2349,6 +2523,7 @@ 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
@@ -2364,12 +2539,17 @@ class SharedHandler {
     }
     // register shared in shareScopeMap
     registerShared(globalOptions, userOptions) {
-        const { shareInfos, shared } = formatShareConfigs(globalOptions, userOptions);
-        const sharedKeys = Object.keys(shareInfos);
+        const { newShareInfos, allShareInfos } = formatShareConfigs(globalOptions, userOptions);
+        const sharedKeys = Object.keys(newShareInfos);
         sharedKeys.forEach((sharedKey) => {
-            const sharedVals = shareInfos[sharedKey];
+            const sharedVals = newShareInfos[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({
@@ -2385,8 +2565,8 @@ class SharedHandler {
             });
         });
         return {
-            shareInfos,
-            shared,
+            newShareInfos,
+            allShareInfos,
         };
     }
     async loadShare(pkgName, extraOptions) {
@@ -2417,61 +2597,59 @@ 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`);
-        // 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;
+        const { shared: registeredShared, useTreeshake } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare) || {};
+        if (registeredShared) {
+            const targetShared = directShare(registeredShared, useTreeshake);
+            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;
-            };
-            const loading = asyncLoadProcess();
-            this.setShared({
-                pkgName,
-                loaded: false,
-                shared: registeredShared,
-                from: host.options.name,
-                lib: null,
-                loading,
-            });
-            return loading;
+            }
+            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,
+                    treeshake: useTreeshake ? targetShared : undefined,
+                });
+                return loading;
+            }
         }
         else {
             if (extraOptions?.customShareInfo) {
                 return false;
             }
+            const _useTreeshake = shouldUseTreeshake(shareOptionsRes.treeshake);
+            const targetShared = directShare(shareOptionsRes, _useTreeshake);
             const asyncLoadProcess = async () => {
-                const factory = await shareOptionsRes.get();
-                shareOptionsRes.lib = factory;
-                shareOptionsRes.loaded = true;
-                addUseIn(shareOptionsRes);
-                const gShared = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare);
+                const factory = await targetShared.get();
+                targetShared.lib = factory;
+                targetShared.loaded = true;
+                addUseIn(targetShared, host.options.name);
+                const { shared: gShared, useTreeshake: gUseTreeshake } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptionsRes, this.hooks.lifecycle.resolveShare) || {};
                 if (gShared) {
-                    gShared.lib = factory;
-                    gShared.loaded = true;
+                    const targetGShared = directShare(gShared, gUseTreeshake);
+                    targetGShared.lib = factory;
+                    targetGShared.loaded = true;
                     gShared.from = shareOptionsRes.from;
                 }
                 return factory;
@@ -2484,6 +2662,7 @@ class SharedHandler {
                 from: host.options.name,
                 lib: null,
                 loading,
+                treeshake: _useTreeshake ? targetShared : undefined,
             });
             return loading;
         }
@@ -2523,19 +2702,20 @@ class SharedHandler {
             const { version, eager } = shared;
             scope[name] = scope[name] || {};
             const versions = scope[name];
-            const activeVersion = versions[version];
+            const activeVersion = versions[version] && directShare(versions[version]);
             const activeVersionEager = Boolean(activeVersion &&
-                (activeVersion.eager || activeVersion.shareConfig?.eager));
+                (('eager' in activeVersion && activeVersion.eager) ||
+                    ('shareConfig' in activeVersion &&
+                        activeVersion.shareConfig?.eager)));
             if (!activeVersion ||
                 (activeVersion.strategy !== 'loaded-first' &&
                     !activeVersion.loaded &&
                     (Boolean(!eager) !== !activeVersionEager
                         ? eager
-                        : hostName > activeVersion.from))) {
+                        : hostName > versions[version].from))) {
                 versions[version] = shared;
             }
         };
-        const initFn = (mod) => mod && mod.init && mod.init(shareScope[shareScopeName], initScope);
         const initRemoteModule = async (key) => {
             const { module } = await host.remoteHandler.getRemoteModuleAndOptions({
                 id: key,
@@ -2556,6 +2736,12 @@ class SharedHandler {
                         }));
                 }
                 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;
                 }
@@ -2596,16 +2782,10 @@ class SharedHandler {
                 this.initializeSharing(shareScope, { strategy: shareOptions.strategy });
             });
         }
-        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);
-        };
+        const { shared: registeredShared, useTreeshake } = getRegisteredShare(this.shareScopeMap, pkgName, shareOptions, this.hooks.lifecycle.resolveShare) || {};
         if (registeredShared) {
             if (typeof registeredShared.lib === 'function') {
-                addUseIn(registeredShared);
+                addUseIn(registeredShared, host.options.name);
                 if (!registeredShared.loaded) {
                     registeredShared.loaded = true;
                     if (registeredShared.from === host.options.name) {
@@ -2617,7 +2797,7 @@ class SharedHandler {
             if (typeof registeredShared.get === 'function') {
                 const module = registeredShared.get();
                 if (!(module instanceof Promise)) {
-                    addUseIn(registeredShared);
+                    addUseIn(registeredShared, host.options.name);
                     this.setShared({
                         pkgName,
                         loaded: true,
@@ -2661,6 +2841,39 @@ class SharedHandler {
     }
     initShareScopeMap(scopeName, shareScope, extraOptions = {}) {
         const { host } = this;
+        // const existedShareScope = this.shareScopeMap[scopeName];
+        // if (existedShareScope) {
+        //   Object.entries(shareScope).forEach(([pkgName, newVersions]) => {
+        //     const existedShareMap = existedShareScope[pkgName];
+        //     if (!existedShareMap) {
+        //       return;
+        //     }
+        //     Object.entries(existedShareMap).forEach(([version, existedShared]) => {
+        //       if (!shareScope[pkgName][version]) {
+        //         shareScope[pkgName][version] = existedShared;
+        //       }
+        //       // const newShared = newVersions[version];
+        //       // if (
+        //       //   newShared &&
+        //       //   newShared.treeshakeStatus === TreeshakeStatus.UNKNOWN &&
+        //       //   newShared.usedExports &&
+        //       //   existedShared.usedExports &&
+        //       //   existedShared.usedExports.some(
+        //       //     (exportName) => !newShared.usedExports?.includes(exportName),
+        //       //   )
+        //       // ) {
+        //       //   newShared.treeshakeStatus = TreeshakeStatus.NO_USE;
+        //       //   newShared._noMatchedUsedExports =
+        //       //     existedShared._noMatchedUsedExports || [];
+        //       //   const item: NoMatchedUsedExportsItem = [existedShared.from];
+        //       //   if (isDebugMode() && existedShared.usedExports) {
+        //       //     item.push(existedShared.usedExports);
+        //       //   }
+        //       //   newShared._noMatchedUsedExports.push(item);
+        //       // }
+        //     });
+        //   });
+        // }
         this.shareScopeMap[scopeName] = shareScope;
         this.hooks.lifecycle.initContainerShareScopeMap.emit({
             shareScope,
@@ -2670,9 +2883,20 @@ class SharedHandler {
             hostShareScopeMap: extraOptions.hostShareScopeMap,
         });
     }
-    setShared({ pkgName, shared, from, lib, loading, loaded, get, }) {
+    setShared({ pkgName, shared, from, lib, loading, loaded, get, treeshake, }) {
         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 = (treeshake ? shared.treeshake : shared);
+            merge(targetShared, 'loaded', loaded);
+            merge(targetShared, 'loading', loading);
+            merge(targetShared, 'get', get);
+        };
         scopes.forEach((sc) => {
             if (!this.shareScopeMap[sc]) {
                 this.shareScopeMap[sc] = {};
@@ -2686,21 +2910,10 @@ 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];
-            if (loading && !registeredShared.loading) {
-                registeredShared.loading = loading;
-            }
-            if (loaded && !registeredShared.loaded) {
-                registeredShared.loaded = loaded;
-            }
+            mergeAttrs(registeredShared);
             if (from && registeredShared.from !== from) {
                 registeredShared.from = from;
             }
@@ -2728,6 +2941,7 @@ class RemoteHandler {
             generatePreloadAssets: new AsyncHook('generatePreloadAssets'),
             // not used yet
             afterPreloadRemote: new AsyncHook(),
+            // TODO: Move to loaderHook
             loadEntry: new AsyncHook(),
         });
         this.host = host;
@@ -3076,7 +3290,7 @@ class ModuleFederation {
             // maybe will change, temporarily for internal use only
             initContainer: new AsyncWaterfallHook('initContainer'),
         });
-        this.version = "0.0.0-feat-rspack-async-startup-20251223091151";
+        this.version = "0.0.0-feat-shared-treeshake-poc-20251224120020";
         this.moduleCache = new Map();
         this.loaderHook = new PluginSystem({
             // FIXME: may not be suitable , not open to the public yet
@@ -3157,7 +3371,7 @@ class ModuleFederation {
         this.sharedHandler.initShareScopeMap(scopeName, shareScope, extraOptions);
     }
     formatOptions(globalOptions, userOptions) {
-        const { shared } = formatShareConfigs(globalOptions, userOptions);
+        const { allShareInfos: shared} = formatShareConfigs(globalOptions, userOptions);
         const { userOptions: userOptionsRes, options: globalOptionsRes } = this.hooks.lifecycle.beforeInit.emit({
             origin: this,
             userOptions,
@@ -3165,7 +3379,7 @@ class ModuleFederation {
             shareInfo: shared,
         });
         const remotes = this.remoteHandler.formatAndRegisterRemote(globalOptionsRes, userOptionsRes);
-        const { shared: handledShared } = this.sharedHandler.registerShared(globalOptionsRes, userOptionsRes);
+        const { allShareInfos } = this.sharedHandler.registerShared(globalOptionsRes, userOptionsRes);
         const plugins = [...globalOptionsRes.plugins];
         if (userOptionsRes.plugins) {
             userOptionsRes.plugins.forEach((plugin) => {
@@ -3179,7 +3393,7 @@ class ModuleFederation {
             ...userOptions,
             plugins,
             remotes,
-            shared: handledShared,
+            shared: allShareInfos,
         };
         this.hooks.lifecycle.init.emit({
             origin: this,