@rspack-debug/core 2.0.0-beta.0 → 2.0.0-beta.1

package/dist/index.js

@@ -3,7 +3,6 @@ import * as __rspack_external_process from "process";
 import { createRequire as __rspack_createRequire, createRequire } from "node:module";
 let __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
 import { __webpack_require__ } from "./rslib-runtime.js";
-import { AsyncParallelHook, AsyncSeriesBailHook, AsyncSeriesHook, AsyncSeriesWaterfallHook, HookMap, MultiHook, SyncBailHook, SyncHook, SyncWaterfallHook, maxStage, minStage, safeStage } from "@rspack/lite-tapable";
 import node_util, { format as external_node_util_format, inspect, promisify } from "node:util";
 import node_path, { isAbsolute, join, relative, resolve as external_node_path_resolve, sep } from "node:path";
 import node_querystring from "node:querystring";
@@ -302,6 +301,479 @@ __webpack_require__.r(ModuleFilenameHelpers_namespaceObject), __webpack_require_
 });
 let binding_namespaceObject = __rspack_createRequire_require(process.env.RSPACK_BINDING ? process.env.RSPACK_BINDING : "@rspack/binding");
 var binding_default = __webpack_require__.n(binding_namespaceObject);
+function _define_property(obj, key, value) {
+    return key in obj ? Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+    }) : obj[key] = value, obj;
+}
+class HookBase {
+    intercept(interceptor) {
+        if (this.interceptors.push(Object.assign({}, interceptor)), interceptor.register) for(let i = 0; i < this.taps.length; i++)this.taps[i] = interceptor.register(this.taps[i]);
+    }
+    _runRegisterInterceptors(options) {
+        return this.interceptors.reduce((options, interceptor)=>interceptor.register?.(options) ?? options, options);
+    }
+    _runCallInterceptors(...args) {
+        for (let interceptor of this.interceptors)interceptor.call && interceptor.call(...args);
+    }
+    _runErrorInterceptors(e) {
+        for (let interceptor of this.interceptors)interceptor.error && interceptor.error(e);
+    }
+    _runTapInterceptors(tap) {
+        for (let interceptor of this.interceptors)interceptor.tap && interceptor.tap(tap);
+    }
+    _runDoneInterceptors() {
+        for (let interceptor of this.interceptors)interceptor.done && interceptor.done();
+    }
+    _runResultInterceptors(r) {
+        for (let interceptor of this.interceptors)interceptor.result && interceptor.result(r);
+    }
+    withOptions(options) {
+        let mergeOptions = (opt)=>Object.assign({}, options, 'string' == typeof opt ? {
+                name: opt
+            } : opt);
+        return {
+            name: this.name,
+            tap: (opt, fn)=>this.tap(mergeOptions(opt), fn),
+            tapAsync: (opt, fn)=>this.tapAsync(mergeOptions(opt), fn),
+            tapPromise: (opt, fn)=>this.tapPromise(mergeOptions(opt), fn),
+            intercept: (interceptor)=>this.intercept(interceptor),
+            isUsed: ()=>this.isUsed(),
+            withOptions: (opt)=>this.withOptions(mergeOptions(opt)),
+            queryStageRange: (stageRange)=>this.queryStageRange(stageRange)
+        };
+    }
+    isUsed() {
+        return this.taps.length > 0 || this.interceptors.length > 0;
+    }
+    queryStageRange(stageRange) {
+        return new QueriedHook(stageRange, this);
+    }
+    callAsyncStageRange(queried) {
+        throw Error('Hook should implement there own _callAsyncStageRange');
+    }
+    callAsync(...args) {
+        return this.callAsyncStageRange(this.queryStageRange(allStageRange), ...args);
+    }
+    promiseStageRange(queried, ...args) {
+        return new Promise((resolve, reject)=>{
+            this.callAsyncStageRange(queried, ...args, (e, r)=>e ? reject(e) : resolve(r));
+        });
+    }
+    promise(...args) {
+        return this.promiseStageRange(this.queryStageRange(allStageRange), ...args);
+    }
+    tap(options, fn) {
+        this._tap('sync', options, fn);
+    }
+    tapAsync(options, fn) {
+        this._tap('async', options, fn);
+    }
+    tapPromise(options, fn) {
+        this._tap('promise', options, fn);
+    }
+    _tap(type, options, fn) {
+        let normalizedOptions = options;
+        if ('string' == typeof options) normalizedOptions = {
+            name: options.trim()
+        };
+        else if ('object' != typeof options || null === options) throw Error('Invalid tap options');
+        if ('string' != typeof normalizedOptions.name || '' === normalizedOptions.name) throw Error('Missing name for tap');
+        this._insert(this._runRegisterInterceptors(Object.assign({
+            type,
+            fn
+        }, normalizedOptions)));
+    }
+    _insert(item) {
+        let before;
+        'string' == typeof item.before ? before = new Set([
+            item.before
+        ]) : Array.isArray(item.before) && (before = new Set(item.before));
+        let stage = 0;
+        'number' == typeof item.stage && (stage = item.stage);
+        let i = this.taps.length;
+        for(; i > 0;){
+            i--;
+            let x = this.taps[i];
+            this.taps[i + 1] = x;
+            let xStage = x.stage || 0;
+            if (before) {
+                if (before.has(x.name)) {
+                    before.delete(x.name);
+                    continue;
+                }
+                if (before.size > 0) continue;
+            }
+            if (!(xStage > stage)) {
+                i++;
+                break;
+            }
+        }
+        this.taps[i] = item;
+    }
+    _prepareArgs(args) {
+        let len = this.args.length;
+        return args.length < len ? (args.length = len, args.fill(void 0, args.length, len)) : (args.length > len && (args.length = len), args);
+    }
+    constructor(args = [], name){
+        _define_property(this, "args", void 0), _define_property(this, "name", void 0), _define_property(this, "taps", void 0), _define_property(this, "interceptors", void 0), this.args = args, this.name = name, this.taps = [], this.interceptors = [];
+    }
+}
+let minStage = -1 / 0, maxStage = 1 / 0, allStageRange = [
+    minStage,
+    1 / 0
+], i32MAX = 2147483648 - 1, safeStage = (stage)=>stage < -2147483648 ? -2147483648 : stage > i32MAX ? i32MAX : stage;
+class QueriedHook {
+    isUsed() {
+        return !!(this.tapsInRange.length > 0 || this.stageRange[0] === minStage && this.hook.interceptors.some((i)=>i.call) || this.stageRange[1] === maxStage && this.hook.interceptors.some((i)=>i.done));
+    }
+    call(...args) {
+        if ('function' != typeof this.hook.callStageRange) throw Error('hook is not a SyncHook, call methods only exists on SyncHook');
+        return this.hook.callStageRange(this, ...args);
+    }
+    callAsync(...args) {
+        return this.hook.callAsyncStageRange(this, ...args);
+    }
+    promise(...args) {
+        return this.hook.promiseStageRange(this, ...args);
+    }
+    constructor(stageRange, hook){
+        _define_property(this, "stageRange", void 0), _define_property(this, "hook", void 0), _define_property(this, "tapsInRange", void 0);
+        let tapsInRange = [], [from, to] = stageRange;
+        for (let tap of hook.taps){
+            let stage = tap.stage ?? 0;
+            from <= stage && stage < to ? tapsInRange.push(tap) : to === maxStage && stage === maxStage && tapsInRange.push(tap);
+        }
+        this.stageRange = stageRange, this.hook = hook, this.tapsInRange = tapsInRange;
+    }
+}
+class SyncHook extends HookBase {
+    callAsyncStageRange(queried, ...args) {
+        let { stageRange: [from, to], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+        for (let tap of (from === minStage && this._runCallInterceptors(...args2), tapsInRange)){
+            this._runTapInterceptors(tap);
+            try {
+                tap.fn(...args2);
+            } catch (e) {
+                return this._runErrorInterceptors(e), cb(e);
+            }
+        }
+        to === maxStage && (this._runDoneInterceptors(), cb(null));
+    }
+    call(...args) {
+        return this.callStageRange(this.queryStageRange(allStageRange), ...args);
+    }
+    callStageRange(queried, ...args) {
+        let result, error;
+        if (this.callAsyncStageRange(queried, ...args, (e, r)=>{
+            error = e, result = r;
+        }), error) throw error;
+        return result;
+    }
+    tapAsync() {
+        throw Error('tapAsync is not supported on a SyncHook');
+    }
+    tapPromise() {
+        throw Error('tapPromise is not supported on a SyncHook');
+    }
+}
+class SyncBailHook extends HookBase {
+    callAsyncStageRange(queried, ...args) {
+        let { stageRange: [from, to], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+        for (let tap of (from === minStage && this._runCallInterceptors(...args2), tapsInRange)){
+            let r;
+            this._runTapInterceptors(tap);
+            try {
+                r = tap.fn(...args2);
+            } catch (e) {
+                return this._runErrorInterceptors(e), cb(e);
+            }
+            if (void 0 !== r) return this._runResultInterceptors(r), cb(null, r);
+        }
+        to === maxStage && (this._runDoneInterceptors(), cb(null));
+    }
+    call(...args) {
+        return this.callStageRange(this.queryStageRange(allStageRange), ...args);
+    }
+    callStageRange(queried, ...args) {
+        let result, error;
+        if (this.callAsyncStageRange(queried, ...args, (e, r)=>{
+            error = e, result = r;
+        }), error) throw error;
+        return result;
+    }
+    tapAsync() {
+        throw Error('tapAsync is not supported on a SyncBailHook');
+    }
+    tapPromise() {
+        throw Error('tapPromise is not supported on a SyncBailHook');
+    }
+}
+class SyncWaterfallHook extends HookBase {
+    callAsyncStageRange(queried, ...args) {
+        let { stageRange: [from, to], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+        for (let tap of (from === minStage && this._runCallInterceptors(...args2), tapsInRange)){
+            this._runTapInterceptors(tap);
+            try {
+                let r = tap.fn(...args2);
+                void 0 !== r && (args2[0] = r);
+            } catch (e) {
+                return this._runErrorInterceptors(e), cb(e);
+            }
+        }
+        to === maxStage && (this._runDoneInterceptors(), cb(null, args2[0]));
+    }
+    call(...args) {
+        return this.callStageRange(this.queryStageRange(allStageRange), ...args);
+    }
+    callStageRange(queried, ...args) {
+        let result, error;
+        if (this.callAsyncStageRange(queried, ...args, (e, r)=>{
+            error = e, result = r;
+        }), error) throw error;
+        return result;
+    }
+    tapAsync() {
+        throw Error('tapAsync is not supported on a SyncWaterfallHook');
+    }
+    tapPromise() {
+        throw Error('tapPromise is not supported on a SyncWaterfallHook');
+    }
+    constructor(args = [], name){
+        if (args.length < 1) throw Error('Waterfall hooks must have at least one argument');
+        super(args, name);
+    }
+}
+class AsyncParallelHook extends HookBase {
+    callAsyncStageRange(queried, ...args) {
+        let { stageRange: [from], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+        from === minStage && this._runCallInterceptors(...args2);
+        let done = ()=>{
+            this._runDoneInterceptors(), cb(null);
+        }, error = (e)=>{
+            this._runErrorInterceptors(e), cb(e);
+        };
+        if (0 === tapsInRange.length) return done();
+        let counter = tapsInRange.length;
+        for (let tap of tapsInRange){
+            if (this._runTapInterceptors(tap), 'promise' === tap.type) {
+                let promise = tap.fn(...args2);
+                if (!promise || !promise.then) throw Error(`Tap function (tapPromise) did not return promise (returned ${promise})`);
+                promise.then(()=>{
+                    0 == (counter -= 1) && done();
+                }, (e)=>{
+                    counter = 0, error(e);
+                });
+            } else if ('async' === tap.type) tap.fn(...args2, (e)=>{
+                e ? (counter = 0, error(e)) : 0 == (counter -= 1) && done();
+            });
+            else {
+                let hasError = !1;
+                try {
+                    tap.fn(...args2);
+                } catch (e) {
+                    hasError = !0, counter = 0, error(e);
+                }
+                hasError || 0 != --counter || done();
+            }
+            if (counter <= 0) return;
+        }
+    }
+}
+class AsyncSeriesHook extends HookBase {
+    callAsyncStageRange(queried, ...args) {
+        let { stageRange: [from], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+        from === minStage && this._runCallInterceptors(...args2);
+        let done = ()=>{
+            this._runDoneInterceptors(), cb(null);
+        }, error = (e)=>{
+            this._runErrorInterceptors(e), cb(e);
+        };
+        if (0 === tapsInRange.length) return done();
+        let index = 0, next = ()=>{
+            let tap = tapsInRange[index];
+            if (this._runTapInterceptors(tap), 'promise' === tap.type) {
+                let promise = tap.fn(...args2);
+                if (!promise || !promise.then) throw Error(`Tap function (tapPromise) did not return promise (returned ${promise})`);
+                promise.then(()=>{
+                    (index += 1) === tapsInRange.length ? done() : next();
+                }, (e)=>{
+                    index = tapsInRange.length, error(e);
+                });
+            } else if ('async' === tap.type) tap.fn(...args2, (e)=>{
+                e ? (index = tapsInRange.length, error(e)) : (index += 1) === tapsInRange.length ? done() : next();
+            });
+            else {
+                let hasError = !1;
+                try {
+                    tap.fn(...args2);
+                } catch (e) {
+                    hasError = !0, index = tapsInRange.length, error(e);
+                }
+                hasError || ((index += 1) === tapsInRange.length ? done() : next());
+            }
+            if (index === tapsInRange.length) return;
+        };
+        next();
+    }
+}
+class AsyncSeriesBailHook extends HookBase {
+    callAsyncStageRange(queried, ...args) {
+        let { stageRange: [from], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+        from === minStage && this._runCallInterceptors(...args2);
+        let done = ()=>{
+            this._runDoneInterceptors(), cb(null);
+        }, error = (e)=>{
+            this._runErrorInterceptors(e), cb(e);
+        }, result = (r)=>{
+            this._runResultInterceptors(r), cb(null, r);
+        };
+        if (0 === tapsInRange.length) return done();
+        let index = 0, next = ()=>{
+            let tap = tapsInRange[index];
+            if (this._runTapInterceptors(tap), 'promise' === tap.type) {
+                let promise = tap.fn(...args2);
+                if (!promise || !promise.then) throw Error(`Tap function (tapPromise) did not return promise (returned ${promise})`);
+                promise.then((r)=>{
+                    index += 1, void 0 !== r ? result(r) : index === tapsInRange.length ? done() : next();
+                }, (e)=>{
+                    index = tapsInRange.length, error(e);
+                });
+            } else if ('async' === tap.type) tap.fn(...args2, (e, r)=>{
+                e ? (index = tapsInRange.length, error(e)) : (index += 1, void 0 !== r ? result(r) : index === tapsInRange.length ? done() : next());
+            });
+            else {
+                let r, hasError = !1;
+                try {
+                    r = tap.fn(...args2);
+                } catch (e) {
+                    hasError = !0, index = tapsInRange.length, error(e);
+                }
+                hasError || (index += 1, void 0 !== r ? result(r) : index === tapsInRange.length ? done() : next());
+            }
+            if (index === tapsInRange.length) return;
+        };
+        next();
+    }
+}
+class AsyncSeriesWaterfallHook extends HookBase {
+    callAsyncStageRange(queried, ...args) {
+        let { stageRange: [from], tapsInRange } = queried, argsWithoutCb = args.slice(0, args.length - 1), cb = args[args.length - 1], args2 = this._prepareArgs(argsWithoutCb);
+        from === minStage && this._runCallInterceptors(...args2);
+        let result = (r)=>{
+            this._runResultInterceptors(r), cb(null, r);
+        }, error = (e)=>{
+            this._runErrorInterceptors(e), cb(e);
+        };
+        if (0 === tapsInRange.length) return result(args2[0]);
+        let index = 0, next = ()=>{
+            let tap = tapsInRange[index];
+            if (this._runTapInterceptors(tap), 'promise' === tap.type) {
+                let promise = tap.fn(...args2);
+                if (!promise || !promise.then) throw Error(`Tap function (tapPromise) did not return promise (returned ${promise})`);
+                promise.then((r)=>{
+                    index += 1, void 0 !== r && (args2[0] = r), index === tapsInRange.length ? result(args2[0]) : next();
+                }, (e)=>{
+                    index = tapsInRange.length, error(e);
+                });
+            } else if ('async' === tap.type) tap.fn(...args2, (e, r)=>{
+                e ? (index = tapsInRange.length, error(e)) : (index += 1, void 0 !== r && (args2[0] = r), index === tapsInRange.length ? result(args2[0]) : next());
+            });
+            else {
+                let hasError = !1;
+                try {
+                    let r = tap.fn(...args2);
+                    void 0 !== r && (args2[0] = r);
+                } catch (e) {
+                    hasError = !0, index = tapsInRange.length, error(e);
+                }
+                hasError || ((index += 1) === tapsInRange.length ? result(args2[0]) : next());
+            }
+            if (index === tapsInRange.length) return;
+        };
+        next();
+    }
+    constructor(args = [], name){
+        if (args.length < 1) throw Error('Waterfall hooks must have at least one argument');
+        super(args, name);
+    }
+}
+let defaultFactory = (key, hook)=>hook;
+class HookMap {
+    get(key) {
+        return this._map.get(key);
+    }
+    for(key) {
+        let hook = this.get(key);
+        if (void 0 !== hook) return hook;
+        let newHook = this._factory(key), interceptors = this._interceptors;
+        for(let i = 0; i < interceptors.length; i++){
+            let factory = interceptors[i].factory;
+            factory && (newHook = factory(key, newHook));
+        }
+        return this._map.set(key, newHook), newHook;
+    }
+    intercept(interceptor) {
+        this._interceptors.push(Object.assign({
+            factory: defaultFactory
+        }, interceptor));
+    }
+    isUsed() {
+        for (let key of this._map.keys()){
+            let hook = this.get(key);
+            if (hook?.isUsed()) return !0;
+        }
+        return !1;
+    }
+    queryStageRange(stageRange) {
+        return new QueriedHookMap(stageRange, this);
+    }
+    constructor(factory, name){
+        _define_property(this, "_map", new Map()), _define_property(this, "_factory", void 0), _define_property(this, "name", void 0), _define_property(this, "_interceptors", void 0), this.name = name, this._factory = factory, this._interceptors = [];
+    }
+}
+class QueriedHookMap {
+    get(key) {
+        return this.hookMap.get(key)?.queryStageRange(this.stageRange);
+    }
+    for(key) {
+        return this.hookMap.for(key).queryStageRange(this.stageRange);
+    }
+    isUsed() {
+        for (let key of this.hookMap._map.keys())if (this.get(key)?.isUsed()) return !0;
+        return !1;
+    }
+    constructor(stageRange, hookMap){
+        _define_property(this, "stageRange", void 0), _define_property(this, "hookMap", void 0), this.stageRange = stageRange, this.hookMap = hookMap;
+    }
+}
+class MultiHook {
+    tap(options, fn) {
+        for (let hook of this.hooks)hook.tap(options, fn);
+    }
+    tapAsync(options, fn) {
+        for (let hook of this.hooks)hook.tapAsync(options, fn);
+    }
+    tapPromise(options, fn) {
+        for (let hook of this.hooks)hook.tapPromise(options, fn);
+    }
+    isUsed() {
+        for (let hook of this.hooks)if (hook.isUsed()) return !0;
+        return !1;
+    }
+    intercept(interceptor) {
+        for (let hook of this.hooks)hook.intercept(interceptor);
+    }
+    withOptions(options) {
+        return new MultiHook(this.hooks.map((h)=>h.withOptions(options)), this.name);
+    }
+    constructor(hooks, name){
+        _define_property(this, "hooks", void 0), _define_property(this, "name", void 0), this.hooks = hooks, this.name = name;
+    }
+}
 let cutOffLoaderExecution = (stack)=>((stack, flag)=>{
         let stacks = stack.split('\n');
         for(let i = 0; i < stacks.length; i++)stacks[i].includes(flag) && (stacks.length = i);
@@ -1417,6 +1889,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 'chunks',
                 'modules'
             ]),
+            beforeModuleIds: new SyncHook([
+                'modules'
+            ]),
             finishModules: new AsyncSeriesHook([
                 'modules'
             ]),
@@ -2820,20 +3295,6 @@ class BulkUpdateDecorator extends Hash {
         return void 0 !== digestCache && 'string' == typeof result && digestCache.set(buffer, result), result;
     }
 }
-class DebugHash extends Hash {
-    string;
-    constructor(){
-        super(), this.string = '';
-    }
-    update(data) {
-        let normalizedData;
-        return (normalizedData = Buffer.isBuffer(data) ? data.toString('utf-8') : data).startsWith('debug-digest-') && (normalizedData = Buffer.from(normalizedData.slice(13), 'hex').toString()), this.string += `[${normalizedData}](${Error().stack?.split('\n', 3)[2]})\n`, this;
-    }
-    digest(encoding) {
-        let result = `debug-digest-${Buffer.from(this.string).toString('hex')}`;
-        return encoding ? result : Buffer.from(result);
-    }
-}
 class WasmHashAdapter extends Hash {
     wasmHash;
     constructor(wasmHash){
@@ -2849,8 +3310,6 @@ class WasmHashAdapter extends Hash {
 let createHash_createHash = (algorithm)=>{
     if ('function' == typeof algorithm) return new BulkUpdateDecorator(()=>new algorithm());
     switch(algorithm){
-        case 'debug':
-            return new DebugHash();
         case 'xxhash64':
             return new WasmHashAdapter((()=>{
                 if (!createXxhash64) {
@@ -3939,7 +4398,6 @@ function getRawJavascriptParserOptions(parser) {
         exportsPresence: !1 === parser.exportsPresence ? 'false' : parser.exportsPresence,
         importExportsPresence: !1 === parser.importExportsPresence ? 'false' : parser.importExportsPresence,
         reexportExportsPresence: !1 === parser.reexportExportsPresence ? 'false' : parser.reexportExportsPresence,
-        strictExportPresence: parser.strictExportPresence,
         worker: 'boolean' == typeof parser.worker ? parser.worker ? [
             '...'
         ] : [] : parser.worker,
@@ -3959,7 +4417,8 @@ function getRawJavascriptParserOptions(parser) {
 function getRawCssParserOptions(parser) {
     return {
         namedExports: parser.namedExports,
-        url: parser.url
+        url: parser.url,
+        resolveImport: parser.resolveImport
     };
 }
 function getRawGeneratorOptions(generator, type) {
@@ -4413,7 +4872,7 @@ let JsLoaderRspackPlugin = base_create(binding_namespaceObject.BuiltinPluginName
         test,
         client,
         currentActiveModules
-    }), 'thisCompilation'), middleware_require = createRequire(import.meta.url), LAZY_COMPILATION_PREFIX = '/lazy-compilation-using-', noop = (_req, _res, next)=>{
+    }), 'thisCompilation'), middleware_require = createRequire(import.meta.url), LAZY_COMPILATION_PREFIX = '/_rspack/lazy/trigger', noop = (_req, _res, next)=>{
     'function' == typeof next && next();
 }, lazyCompilationMiddleware = (compiler)=>{
     if (compiler instanceof MultiCompiler) {
@@ -6042,7 +6501,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
     if ('function' != typeof options.entry) for (let key of Object.keys(options.entry))F(options.entry[key], 'import', ()=>[
             './src'
         ]);
-    return F(options, 'devtool', ()=>!!development && 'eval'), D(options, 'watch', !1), D(options, 'lazyCompilation', !1), D(options, 'bail', !1), F(options, 'cache', ()=>development), applyIncrementalDefaults(options), applyExperimentsDefaults(options.experiments), applyOptimizationDefaults(options.optimization, {
+    return F(options, 'devtool', ()=>!!development && 'cheap-module-source-map'), D(options, 'watch', !1), D(options, 'lazyCompilation', !1), D(options, 'bail', !1), F(options, 'cache', ()=>development), applyIncrementalDefaults(options), applyExperimentsDefaults(options.experiments), applyOptimizationDefaults(options.optimization, {
         production,
         development
     }), applySnapshotDefaults(options.snapshot, {
@@ -6094,7 +6553,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
     D(generatorOptions, 'exportsOnly', !targetProperties || !1 === targetProperties.document), D(generatorOptions, 'esModule', !0);
 }, applyModuleDefaults = (module, { asyncWebAssembly, targetProperties, mode, uniqueName, deferImport })=>{
     assertNotNill(module.parser), assertNotNill(module.generator), F(module.parser, "asset", ()=>({})), assertNotNill(module.parser.asset), F(module.parser.asset, 'dataUrlCondition', ()=>({})), 'object' == typeof module.parser.asset.dataUrlCondition && D(module.parser.asset.dataUrlCondition, 'maxSize', 8096), F(module.parser, "javascript", ()=>({})), assertNotNill(module.parser.javascript), ((parserOptions, { deferImport })=>{
-        D(parserOptions, 'dynamicImportMode', 'lazy'), D(parserOptions, 'dynamicImportPrefetch', !1), D(parserOptions, 'dynamicImportPreload', !1), D(parserOptions, 'url', !0), D(parserOptions, 'exprContextCritical', !0), D(parserOptions, 'unknownContextCritical', !0), D(parserOptions, 'wrappedContextCritical', !1), D(parserOptions, 'wrappedContextRegExp', /.*/), D(parserOptions, 'strictExportPresence', !1), D(parserOptions, 'requireAsExpression', !1), D(parserOptions, 'requireAlias', !1), D(parserOptions, 'requireDynamic', !0), D(parserOptions, 'requireResolve', !0), D(parserOptions, 'commonjs', !0), D(parserOptions, 'importDynamic', !0), D(parserOptions, 'worker', [
+        D(parserOptions, 'dynamicImportMode', 'lazy'), D(parserOptions, 'dynamicImportPrefetch', !1), D(parserOptions, 'dynamicImportPreload', !1), D(parserOptions, 'url', !0), D(parserOptions, 'exprContextCritical', !0), D(parserOptions, 'unknownContextCritical', !0), D(parserOptions, 'wrappedContextCritical', !1), D(parserOptions, 'wrappedContextRegExp', /.*/), D(parserOptions, 'exportsPresence', 'error'), D(parserOptions, 'requireAsExpression', !0), D(parserOptions, 'requireAlias', !1), D(parserOptions, 'requireDynamic', !0), D(parserOptions, 'requireResolve', !0), D(parserOptions, 'commonjs', !0), D(parserOptions, 'importDynamic', !0), D(parserOptions, 'worker', [
             '...'
         ]), D(parserOptions, 'importMeta', !0), D(parserOptions, 'typeReexportsPresence', 'no-tolerant'), D(parserOptions, 'jsx', !1), D(parserOptions, 'deferImport', deferImport);
     })(module.parser.javascript, {
@@ -6366,7 +6825,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         return output.wasmLoading && enabledWasmLoadingTypes.add(output.wasmLoading), output.workerWasmLoading && enabledWasmLoadingTypes.add(output.workerWasmLoading), forEachEntry((desc)=>{
             desc.wasmLoading && enabledWasmLoadingTypes.add(desc.wasmLoading);
         }), Array.from(enabledWasmLoadingTypes);
-    }), D(output, 'bundlerInfo', {}), 'object' == typeof output.bundlerInfo && (D(output.bundlerInfo, 'version', "2.0.0-beta.0"), D(output.bundlerInfo, 'bundler', 'rspack'), D(output.bundlerInfo, 'force', !output.library));
+    }), D(output, 'bundlerInfo', {}), 'object' == typeof output.bundlerInfo && (D(output.bundlerInfo, 'version', "2.0.0-beta.1"), D(output.bundlerInfo, 'bundler', 'rspack'), D(output.bundlerInfo, 'force', !output.library));
 }, applyExternalsPresetsDefaults = (externalsPresets, { targetProperties, buildHttp, outputModule })=>{
     let isUniversal = (key)=>!!(outputModule && targetProperties && null === targetProperties[key]);
     D(externalsPresets, 'web', !buildHttp && targetProperties && (targetProperties.web || isUniversal('node'))), D(externalsPresets, 'node', targetProperties && (targetProperties.node || isUniversal('node'))), D(externalsPresets, 'electron', targetProperties && targetProperties.electron || isUniversal('electron')), D(externalsPresets, 'electronMain', targetProperties && !!targetProperties.electron && (targetProperties.electronMain || isUniversal('electronMain'))), D(externalsPresets, 'electronPreload', targetProperties && !!targetProperties.electron && (targetProperties.electronPreload || isUniversal('electronPreload'))), D(externalsPresets, 'electronRenderer', targetProperties && !!targetProperties.electron && (targetProperties.electronRenderer || isUniversal('electronRenderer'))), D(externalsPresets, 'nwjs', targetProperties && (targetProperties.nwjs || isUniversal('nwjs')));
@@ -6684,7 +7143,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                     type: 'filesystem',
                     directory: node_path.resolve(config.context || process.cwd(), cache.storage?.directory || 'node_modules/.cache/rspack')
                 },
-                portable: cache.portable
+                portable: cache.portable,
+                readonly: cache.readonly
             };
         }),
         stats: nestedConfig(config.stats, (stats)=>!1 === stats ? {
@@ -7618,7 +8078,7 @@ class MultiStats {
         obj.children = this.stats.map((stat, idx)=>{
             let obj = stat.toJson(childOptions.children[idx]), compilationName = stat.compilation.name;
             return obj.name = compilationName && makePathsRelative(childOptions.context, compilationName, stat.compilation.compiler.root), obj;
-        }), childOptions.version && (obj.rspackVersion = "2.0.0-beta.0", obj.version = "5.75.0"), childOptions.hash && (obj.hash = obj.children.map((j)=>j.hash).join(''));
+        }), childOptions.version && (obj.rspackVersion = "2.0.0-beta.1", obj.version = "5.75.0"), childOptions.hash && (obj.hash = obj.children.map((j)=>j.hash).join(''));
         let mapError = (j, obj)=>({
                 ...obj,
                 compilerPath: obj.compilerPath ? `${j.name}.${obj.compilerPath}` : j.name
@@ -8877,7 +9337,7 @@ let iterateConfig = (config, options, fn)=>{
             object.hash = context.getStatsCompilation(compilation).hash;
         },
         version: (object)=>{
-            object.version = "5.75.0", object.rspackVersion = "2.0.0-beta.0";
+            object.version = "5.75.0", object.rspackVersion = "2.0.0-beta.1";
         },
         env: (object, _compilation, _context, { _env })=>{
             object.env = _env;
@@ -10242,7 +10702,7 @@ function createCompiler(userOptions) {
 function isMultiRspackOptions(o) {
     return Array.isArray(o);
 }
-function rspack(options, callback) {
+function rspack_rspack(options, callback) {
     try {
         if (isMultiRspackOptions(options)) for (let option of options)validateRspackConfig(option);
         else validateRspackConfig(options);
@@ -10538,7 +10998,7 @@ class TraceHookPlugin {
         });
     }
 }
-let CORE_VERSION = "2.0.0-beta.0", VFILES_BY_COMPILER = new WeakMap();
+let CORE_VERSION = "2.0.0-beta.1", VFILES_BY_COMPILER = new WeakMap();
 class VirtualModulesPlugin {
     #staticModules;
     #compiler;
@@ -10862,7 +11322,7 @@ class Compiler {
             }
         });
         let compilerRspack = Object.assign(function(...params) {
-            return rspack(...params);
+            return rspack_rspack(...params);
         }, exports_namespaceObject, {
             RuntimeGlobals: createCompilerRuntimeGlobals(options)
         });
@@ -11423,6 +11883,29 @@ Help:
                         return queried.promise(getCompiler().__internal__get_compilation().chunks, getCompiler().__internal__get_compilation().modules);
                     };
                 }),
+                registerCompilationBeforeModuleIdsTaps: createTap(binding_default().RegisterJsTapKind.CompilationBeforeModuleIds, function() {
+                    return getCompiler().__internal__get_compilation().hooks.beforeModuleIds;
+                }, function(queried) {
+                    return function(arg) {
+                        let compilation = getCompiler().__internal__get_compilation(), assignments = new Map(), modulesByIdentifier = new Map();
+                        for (let module of compilation.modules)modulesByIdentifier.set(module.identifier(), module);
+                        let proxiedModules = arg.modules.map((m)=>new Proxy(modulesByIdentifier.get(m.identifier), {
+                                get (target, prop) {
+                                    if ('id' === prop) return assignments.get(m.identifier) ?? null;
+                                    if ('identifier' === prop) return m.identifier;
+                                    let value = Reflect.get(target, prop);
+                                    return 'function' == typeof value ? value.bind(target) : value;
+                                },
+                                set: (_target, prop, value)=>'id' === prop && null !== value && (assignments.set(m.identifier, value), !0)
+                            }));
+                        return queried.call(proxiedModules), {
+                            assignments: Object.fromEntries(Array.from(assignments.entries()).map(([k, v])=>[
+                                    k,
+                                    String(v)
+                                ]))
+                        };
+                    };
+                }),
                 registerCompilationChunkHashTaps: createTap(binding_default().RegisterJsTapKind.CompilationChunkHash, function() {
                     return getCompiler().__internal__get_compilation().hooks.chunkHash;
                 }, function(queried) {
@@ -11965,68 +12448,7 @@ class LoaderTargetPlugin {
         });
     }
 }
-let VERSION_PATTERN_REGEXP = /^([\d^=v<>~]|[*xX]$)/;
-function isRequiredVersion(str) {
-    return VERSION_PATTERN_REGEXP.test(str);
-}
-let MANIFEST_FILE_NAME = 'mf-manifest.json', STATS_FILE_NAME = 'mf-stats.json', JSON_EXT = '.json';
-function isPlainObject(value) {
-    return !!value && 'object' == typeof value && !Array.isArray(value);
-}
-class ModuleFederationManifestPlugin extends RspackBuiltinPlugin {
-    name = binding_namespaceObject.BuiltinPluginName.ModuleFederationManifestPlugin;
-    opts;
-    constructor(opts){
-        super(), this.opts = opts;
-    }
-    raw(compiler) {
-        var isDev;
-        let pkg, buildVersion, { fileName, filePath, disableAssetsAnalyze, remoteAliasMap, exposes, shared } = this.opts, { statsFileName, manifestFileName } = function(manifestOptions) {
-            if (!manifestOptions) return {
-                statsFileName: STATS_FILE_NAME,
-                manifestFileName: MANIFEST_FILE_NAME
-            };
-            let filePath = 'boolean' == typeof manifestOptions ? '' : manifestOptions.filePath || '', fileName = 'boolean' == typeof manifestOptions ? '' : manifestOptions.fileName || '', manifestFileName = fileName ? fileName.endsWith(JSON_EXT) ? fileName : `${fileName}${JSON_EXT}` : MANIFEST_FILE_NAME;
-            return {
-                statsFileName: join(filePath, fileName ? manifestFileName.replace(JSON_EXT, `-stats${JSON_EXT}`) : STATS_FILE_NAME),
-                manifestFileName: join(filePath, manifestFileName)
-            };
-        }(this.opts), rawOptions = {
-            name: this.opts.name,
-            globalName: this.opts.globalName,
-            fileName,
-            filePath,
-            manifestFileName,
-            statsFileName,
-            disableAssetsAnalyze,
-            remoteAliasMap,
-            exposes,
-            shared,
-            buildInfo: (isDev = 'development' === compiler.options.mode, pkg = function(root) {
-                let pkgPath = join(root ? external_node_path_resolve(root) : process.cwd(), 'package.json');
-                try {
-                    let content = readFileSync(pkgPath, 'utf-8'), parsed = function(input, guard) {
-                        try {
-                            let parsed = JSON.parse(input);
-                            if (guard(parsed)) return parsed;
-                        } catch  {}
-                    }(content, isPlainObject);
-                    if (parsed) {
-                        let filtered = {};
-                        for (let [key, value] of Object.entries(parsed))'string' == typeof value && (filtered[key] = value);
-                        if (Object.keys(filtered).length > 0) return filtered;
-                    }
-                } catch  {}
-                return {};
-            }(compiler.context || process.cwd()), buildVersion = isDev ? 'local' : pkg?.version, {
-                buildVersion: process.env.MF_BUILD_VERSION || buildVersion || 'UNKNOWN',
-                buildName: process.env.MF_BUILD_NAME || pkg?.name || 'UNKNOWN'
-            })
-        };
-        return createBuiltinPlugin(this.name, rawOptions);
-    }
-}
-let ModuleFederationRuntimePlugin = base_create(binding_namespaceObject.BuiltinPluginName.ModuleFederationRuntimePlugin, (options = {})=>options), parseOptions = (options, normalizeSimple, normalizeOptions)=>{
+let parseOptions = (options, normalizeSimple, normalizeOptions)=>{
     let items = [];
     var fn = (key, value)=>{
         items.push([
@@ -12043,63 +12465,7 @@ let ModuleFederationRuntimePlugin = base_create(binding_namespaceObject.BuiltinP
     else if ('object' == typeof options) object(options);
     else throw Error('Unexpected options format');
     return items;
-}, ModuleFederationPlugin_require = createRequire(import.meta.url);
-function getRemoteInfos(options) {
-    if (!options.remotes) return {};
-    let remoteType = options.remoteType || (options.library ? options.library.type : "script"), remotes = parseOptions(options.remotes, (item)=>({
-            external: Array.isArray(item) ? item : [
-                item
-            ],
-            shareScope: options.shareScope || 'default'
-        }), (item)=>({
-            external: Array.isArray(item.external) ? item.external : [
-                item.external
-            ],
-            shareScope: item.shareScope || options.shareScope || 'default'
-        })), remoteInfos = {};
-    for (let [key, config] of remotes)for (let external of config.external){
-        let [externalType, externalRequest] = function(external) {
-            let result = function(external) {
-                if (/^[a-z0-9-]+ /.test(external)) {
-                    let idx = external.indexOf(' ');
-                    return [
-                        external.slice(0, idx),
-                        external.slice(idx + 1)
-                    ];
-                }
-                return null;
-            }(external);
-            return null === result ? [
-                remoteType,
-                external
-            ] : result;
-        }(external);
-        if (remoteInfos[key] ??= [], "script" === externalType) {
-            let [url, global] = function(urlAndGlobal) {
-                let index = urlAndGlobal.indexOf('@');
-                return index <= 0 || index === urlAndGlobal.length - 1 ? null : [
-                    urlAndGlobal.substring(index + 1),
-                    urlAndGlobal.substring(0, index)
-                ];
-            }(externalRequest);
-            remoteInfos[key].push({
-                alias: key,
-                name: global,
-                entry: url,
-                externalType,
-                shareScope: config.shareScope
-            });
-        } else remoteInfos[key].push({
-            alias: key,
-            name: void 0,
-            entry: void 0,
-            externalType,
-            shareScope: config.shareScope
-        });
-    }
-    return remoteInfos;
-}
-let compilerSet = new WeakSet();
+}, compilerSet = new WeakSet();
 class ShareRuntimePlugin extends RspackBuiltinPlugin {
     enhanced;
     name = binding_namespaceObject.BuiltinPluginName.ShareRuntimePlugin;
@@ -12110,42 +12476,55 @@ class ShareRuntimePlugin extends RspackBuiltinPlugin {
         if (!compilerSet.has(compiler)) return compilerSet.add(compiler), createBuiltinPlugin(this.name, this.enhanced);
     }
 }
-class ConsumeSharedPlugin extends RspackBuiltinPlugin {
+let VERSION_PATTERN_REGEXP = /^([\d^=v<>~]|[*xX]$)/;
+function isRequiredVersion(str) {
+    return VERSION_PATTERN_REGEXP.test(str);
+}
+let encodeName = function(name, prefix = '', withExt = !1) {
+    return `${prefix}${name.replace(/@/g, 'scope_').replace(/-/g, '_').replace(/\//g, '__').replace(/\./g, '')}${withExt ? '.js' : ''}`;
+};
+function normalizeConsumeShareOptions(consumes, shareScope) {
+    return parseOptions(consumes, (item, key)=>{
+        if (Array.isArray(item)) throw Error('Unexpected array in options');
+        return item !== key && isRequiredVersion(item) ? {
+            import: key,
+            shareScope: shareScope || 'default',
+            shareKey: key,
+            requiredVersion: item,
+            strictVersion: !0,
+            packageName: void 0,
+            singleton: !1,
+            eager: !1,
+            treeShakingMode: void 0
+        } : {
+            import: key,
+            shareScope: shareScope || 'default',
+            shareKey: key,
+            requiredVersion: void 0,
+            packageName: void 0,
+            strictVersion: !1,
+            singleton: !1,
+            eager: !1,
+            treeShakingMode: void 0
+        };
+    }, (item, key)=>({
+            import: !1 === item.import ? void 0 : item.import || key,
+            shareScope: item.shareScope || shareScope || 'default',
+            shareKey: item.shareKey || key,
+            requiredVersion: item.requiredVersion,
+            strictVersion: 'boolean' == typeof item.strictVersion ? item.strictVersion : !1 !== item.import && !item.singleton,
+            packageName: item.packageName,
+            singleton: !!item.singleton,
+            eager: !!item.eager,
+            treeShakingMode: item.treeShakingMode
+        }));
+}
+class ConsumeSharedPlugin extends RspackBuiltinPlugin {
     name = binding_namespaceObject.BuiltinPluginName.ConsumeSharedPlugin;
     _options;
     constructor(options){
         super(), this._options = {
-            consumes: parseOptions(options.consumes, (item, key)=>{
-                if (Array.isArray(item)) throw Error('Unexpected array in options');
-                return item !== key && isRequiredVersion(item) ? {
-                    import: key,
-                    shareScope: options.shareScope || 'default',
-                    shareKey: key,
-                    requiredVersion: item,
-                    strictVersion: !0,
-                    packageName: void 0,
-                    singleton: !1,
-                    eager: !1
-                } : {
-                    import: key,
-                    shareScope: options.shareScope || 'default',
-                    shareKey: key,
-                    requiredVersion: void 0,
-                    packageName: void 0,
-                    strictVersion: !1,
-                    singleton: !1,
-                    eager: !1
-                };
-            }, (item, key)=>({
-                    import: !1 === item.import ? void 0 : item.import || key,
-                    shareScope: item.shareScope || options.shareScope || 'default',
-                    shareKey: item.shareKey || key,
-                    requiredVersion: item.requiredVersion,
-                    strictVersion: 'boolean' == typeof item.strictVersion ? item.strictVersion : !1 !== item.import && !item.singleton,
-                    packageName: item.packageName,
-                    singleton: !!item.singleton,
-                    eager: !!item.eager
-                })),
+            consumes: normalizeConsumeShareOptions(options.consumes, options.shareScope),
             enhanced: options.enhanced ?? !1
         };
     }
@@ -12166,28 +12545,30 @@ class ProvideSharedPlugin extends RspackBuiltinPlugin {
     _provides;
     _enhanced;
     constructor(options){
-        super(), this._provides = parseOptions(options.provides, (item)=>{
+        var options1, shareScope, enhanced;
+        super(), this._provides = (options1 = options.provides, shareScope = options.shareScope, enhanced = options.enhanced, parseOptions(options1, (item)=>{
             if (Array.isArray(item)) throw Error('Unexpected array of provides');
             return {
                 shareKey: item,
                 version: void 0,
-                shareScope: options.shareScope || 'default',
+                shareScope: shareScope || 'default',
                 eager: !1
             };
         }, (item)=>{
             let raw = {
                 shareKey: item.shareKey,
                 version: item.version,
-                shareScope: item.shareScope || options.shareScope || 'default',
+                shareScope: item.shareScope || shareScope || 'default',
                 eager: !!item.eager
             };
-            return options.enhanced ? {
+            return enhanced ? {
                 ...raw,
                 singleton: item.singleton,
                 requiredVersion: item.requiredVersion,
-                strictVersion: item.strictVersion
+                strictVersion: item.strictVersion,
+                treeShakingMode: item.treeShakingMode
             } : raw;
-        }), this._enhanced = options.enhanced;
+        })), this._enhanced = options.enhanced;
     }
     raw(compiler) {
         new ShareRuntimePlugin(this._enhanced ?? !1).apply(compiler);
@@ -12198,32 +12579,40 @@ class ProvideSharedPlugin extends RspackBuiltinPlugin {
         return createBuiltinPlugin(this.name, rawOptions);
     }
 }
+function normalizeSharedOptions(shared) {
+    return parseOptions(shared, (item, key)=>{
+        if ('string' != typeof item) throw Error('Unexpected array in shared');
+        return item !== key && isRequiredVersion(item) ? {
+            import: key,
+            requiredVersion: item
+        } : {
+            import: item
+        };
+    }, (item)=>item);
+}
+function createConsumeShareOptions(normalizedSharedOptions) {
+    return normalizedSharedOptions.map(([key, options])=>({
+            [key]: {
+                import: options.import,
+                shareKey: options.shareKey || key,
+                shareScope: options.shareScope,
+                requiredVersion: options.requiredVersion,
+                strictVersion: options.strictVersion,
+                singleton: options.singleton,
+                packageName: options.packageName,
+                eager: options.eager,
+                treeShakingMode: options.treeShaking?.mode
+            }
+        }));
+}
 class SharePlugin {
     _shareScope;
     _consumes;
     _provides;
     _enhanced;
+    _sharedOptions;
     constructor(options){
-        let sharedOptions = parseOptions(options.shared, (item, key)=>{
-            if ('string' != typeof item) throw Error('Unexpected array in shared');
-            return item !== key && isRequiredVersion(item) ? {
-                import: key,
-                requiredVersion: item
-            } : {
-                import: item
-            };
-        }, (item)=>item), consumes = sharedOptions.map(([key, options])=>({
-                [key]: {
-                    import: options.import,
-                    shareKey: options.shareKey || key,
-                    shareScope: options.shareScope,
-                    requiredVersion: options.requiredVersion,
-                    strictVersion: options.strictVersion,
-                    singleton: options.singleton,
-                    packageName: options.packageName,
-                    eager: options.eager
-                }
-            })), provides = sharedOptions.filter(([, options])=>!1 !== options.import).map(([key, options])=>({
+        let sharedOptions = normalizeSharedOptions(options.shared), consumes = createConsumeShareOptions(sharedOptions), provides = sharedOptions.filter(([, options])=>!1 !== options.import).map(([key, options])=>({
                 [options.import || key]: {
                     shareKey: options.shareKey || key,
                     shareScope: options.shareScope,
@@ -12231,10 +12620,11 @@ class SharePlugin {
                     eager: options.eager,
                     singleton: options.singleton,
                     requiredVersion: options.requiredVersion,
-                    strictVersion: options.strictVersion
+                    strictVersion: options.strictVersion,
+                    treeShakingMode: options.treeShaking?.mode
                 }
             }));
-        this._shareScope = options.shareScope, this._consumes = consumes, this._provides = provides, this._enhanced = options.enhanced ?? !1;
+        this._shareScope = options.shareScope, this._consumes = consumes, this._provides = provides, this._enhanced = options.enhanced ?? !1, this._sharedOptions = sharedOptions;
     }
     apply(compiler) {
         new ConsumeSharedPlugin({
@@ -12248,6 +12638,555 @@ class SharePlugin {
         }).apply(compiler);
     }
 }
+let MANIFEST_FILE_NAME = 'mf-manifest.json', STATS_FILE_NAME = 'mf-stats.json', JSON_EXT = '.json';
+function isPlainObject(value) {
+    return !!value && 'object' == typeof value && !Array.isArray(value);
+}
+function getFileName(manifestOptions) {
+    if (!manifestOptions) return {
+        statsFileName: '',
+        manifestFileName: ''
+    };
+    if ('boolean' == typeof manifestOptions) return {
+        statsFileName: STATS_FILE_NAME,
+        manifestFileName: MANIFEST_FILE_NAME
+    };
+    let filePath = 'boolean' == typeof manifestOptions ? '' : manifestOptions.filePath || '', fileName = 'boolean' == typeof manifestOptions ? '' : manifestOptions.fileName || '', manifestFileName = fileName ? fileName.endsWith(JSON_EXT) ? fileName : `${fileName}${JSON_EXT}` : MANIFEST_FILE_NAME;
+    return {
+        statsFileName: join(filePath, fileName ? manifestFileName.replace(JSON_EXT, `-stats${JSON_EXT}`) : STATS_FILE_NAME),
+        manifestFileName: join(filePath, manifestFileName)
+    };
+}
+class ModuleFederationManifestPlugin extends RspackBuiltinPlugin {
+    name = binding_namespaceObject.BuiltinPluginName.ModuleFederationManifestPlugin;
+    rawOpts;
+    constructor(opts){
+        super(), this.rawOpts = opts;
+    }
+    raw(compiler) {
+        var mfConfig, isDev, mfConfig1;
+        let manifestOptions, containerName, globalName, remoteAliasMap, manifestExposes, manifestShared, pkg, buildVersion, statsBuildInfo, opts = (manifestOptions = !0 === (mfConfig = this.rawOpts).manifest ? {} : {
+            ...mfConfig.manifest
+        }, containerName = mfConfig.name, globalName = function(library) {
+            if (!library) return;
+            let libName = library.name;
+            if (libName) {
+                if ('string' == typeof libName) return libName;
+                if (Array.isArray(libName)) return libName[0];
+                if ('object' == typeof libName) return libName.root?.[0] ?? libName.amd ?? libName.commonjs ?? void 0;
+            }
+        }(mfConfig.library) ?? containerName, remoteAliasMap = Object.entries(getRemoteInfos(mfConfig)).reduce((sum, cur)=>{
+            if (cur[1].length > 1) return sum;
+            let { entry, alias, name } = cur[1][0];
+            return entry && name && (sum[alias] = {
+                name,
+                entry
+            }), sum;
+        }, {}), manifestExposes = function(exposes) {
+            if (!exposes) return;
+            let result = parseOptions(exposes, (value)=>({
+                    import: Array.isArray(value) ? value : [
+                        value
+                    ],
+                    name: void 0
+                }), (value)=>({
+                    import: Array.isArray(value.import) ? value.import : [
+                        value.import
+                    ],
+                    name: value.name ?? void 0
+                })).map(([exposeKey, info])=>{
+                let exposeName = info.name ?? exposeKey.replace(/^\.\//, '');
+                return {
+                    path: exposeKey,
+                    name: exposeName
+                };
+            });
+            return result.length > 0 ? result : void 0;
+        }(mfConfig.exposes), void 0 === manifestOptions.exposes && manifestExposes && (manifestOptions.exposes = manifestExposes), manifestShared = function(shared) {
+            if (!shared) return;
+            let result = parseOptions(shared, (item, key)=>{
+                if ('string' != typeof item) throw Error('Unexpected array in shared');
+                return item !== key && isRequiredVersion(item) ? {
+                    import: key,
+                    requiredVersion: item
+                } : {
+                    import: item
+                };
+            }, (item)=>item).map(([key, config])=>{
+                let name = config.shareKey || key;
+                return {
+                    name,
+                    version: 'string' == typeof config.version ? config.version : void 0,
+                    requiredVersion: 'string' == typeof config.requiredVersion ? config.requiredVersion : void 0,
+                    singleton: config.singleton
+                };
+            });
+            return result.length > 0 ? result : void 0;
+        }(mfConfig.shared), void 0 === manifestOptions.shared && manifestShared && (manifestOptions.shared = manifestShared), {
+            ...manifestOptions,
+            remoteAliasMap,
+            globalName,
+            name: containerName
+        }), { fileName, filePath, disableAssetsAnalyze, remoteAliasMap: remoteAliasMap1, exposes, shared } = opts, { statsFileName, manifestFileName } = getFileName(opts), rawOptions = {
+            name: opts.name,
+            globalName: opts.globalName,
+            fileName,
+            filePath,
+            manifestFileName,
+            statsFileName,
+            disableAssetsAnalyze,
+            remoteAliasMap: remoteAliasMap1,
+            exposes,
+            shared,
+            buildInfo: (isDev = 'development' === compiler.options.mode, mfConfig1 = this.rawOpts, pkg = function(root) {
+                let pkgPath = join(root ? external_node_path_resolve(root) : process.cwd(), 'package.json');
+                try {
+                    let content = readFileSync(pkgPath, 'utf-8'), parsed = function(input, guard) {
+                        try {
+                            let parsed = JSON.parse(input);
+                            if (guard(parsed)) return parsed;
+                        } catch  {}
+                    }(content, isPlainObject);
+                    if (parsed) {
+                        let filtered = {};
+                        for (let [key, value] of Object.entries(parsed))'string' == typeof value && (filtered[key] = value);
+                        if (Object.keys(filtered).length > 0) return filtered;
+                    }
+                } catch  {}
+                return {};
+            }(compiler.options.context || process.cwd()), buildVersion = isDev ? 'local' : pkg?.version, statsBuildInfo = {
+                buildVersion: process.env.MF_BUILD_VERSION || buildVersion || 'UNKNOWN',
+                buildName: process.env.MF_BUILD_NAME || pkg?.name || 'UNKNOWN'
+            }, Object.values(normalizeSharedOptions(mfConfig1.shared || {})).some((config)=>config[1].treeShaking) && (statsBuildInfo.target = Array.isArray(compiler.options.target) ? compiler.options.target : [], statsBuildInfo.plugins = mfConfig1.treeShakingSharedPlugins || [], statsBuildInfo.excludePlugins = mfConfig1.treeShakingSharedExcludePlugins || []), statsBuildInfo)
+        };
+        return createBuiltinPlugin(this.name, rawOptions);
+    }
+}
+let SHARE_ENTRY_ASSET = 'collect-shared-entries.json';
+class CollectSharedEntryPlugin extends RspackBuiltinPlugin {
+    name = binding_namespaceObject.BuiltinPluginName.CollectSharedEntryPlugin;
+    sharedOptions;
+    _collectedEntries;
+    constructor(options){
+        super();
+        let { sharedOptions } = options;
+        this.sharedOptions = sharedOptions, this._collectedEntries = {};
+    }
+    getData() {
+        return this._collectedEntries;
+    }
+    getFilename() {
+        return SHARE_ENTRY_ASSET;
+    }
+    apply(compiler) {
+        super.apply(compiler), compiler.hooks.thisCompilation.tap('Collect shared entry', (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: 'CollectSharedEntry',
+                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE
+            }, ()=>{
+                compilation.getAssets().forEach((asset)=>{
+                    asset.name === SHARE_ENTRY_ASSET && (this._collectedEntries = JSON.parse(asset.source.source().toString())), compilation.deleteAsset(asset.name);
+                });
+            });
+        });
+    }
+    raw() {
+        let rawOptions = {
+            consumes: normalizeConsumeShareOptions(createConsumeShareOptions(this.sharedOptions)).map(([key, v])=>({
+                    key,
+                    ...v
+                })),
+            filename: this.getFilename()
+        };
+        return createBuiltinPlugin(this.name, rawOptions);
+    }
+}
+function assert(condition, msg) {
+    if (!condition) throw Error(msg);
+}
+class SharedContainerPlugin extends RspackBuiltinPlugin {
+    name = binding_namespaceObject.BuiltinPluginName.SharedContainerPlugin;
+    filename = '';
+    _options;
+    _shareName;
+    _globalName;
+    constructor(options){
+        super();
+        let { shareName, library, request, independentShareFileName, mfName } = options, version = options.version || '0.0.0';
+        this._globalName = encodeName(`${mfName}_${shareName}_${version}`);
+        let fileName = independentShareFileName || `${version}/share-entry.js`;
+        this._shareName = shareName, this._options = {
+            name: shareName,
+            request: request,
+            library: (library ? {
+                ...library,
+                name: this._globalName
+            } : void 0) || {
+                type: 'global',
+                name: this._globalName
+            },
+            version,
+            fileName
+        };
+    }
+    getData() {
+        return [
+            this._options.fileName,
+            this._globalName,
+            this._options.version
+        ];
+    }
+    raw(compiler) {
+        let { library } = this._options;
+        return compiler.options.output.enabledLibraryTypes.includes(library.type) || compiler.options.output.enabledLibraryTypes.push(library.type), createBuiltinPlugin(this.name, this._options);
+    }
+    apply(compiler) {
+        super.apply(compiler);
+        let shareName = this._shareName;
+        compiler.hooks.thisCompilation.tap(this.name, (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: 'getShareContainerFile'
+            }, ()=>{
+                assert(compilation.entrypoints.get(shareName), `Can not get shared ${shareName} entryPoint!`);
+                let remoteEntryNameChunk = compilation.namedChunks.get(shareName);
+                assert(remoteEntryNameChunk, `Can not get shared ${shareName} chunk!`);
+                let files = Array.from(remoteEntryNameChunk.files).filter((f)=>!f.includes('.hot-update') && !f.endsWith('.css'));
+                assert(files.length > 0, `no files found for shared ${shareName} chunk`), assert(1 === files.length, `shared ${shareName} chunk should not have multiple files!, current files: ${files.join(',')}`), this.filename = files[0];
+            });
+        });
+    }
+}
+class SharedUsedExportsOptimizerPlugin extends RspackBuiltinPlugin {
+    name = binding_namespaceObject.BuiltinPluginName.SharedUsedExportsOptimizerPlugin;
+    sharedOptions;
+    injectTreeShakingUsedExports;
+    manifestOptions;
+    constructor(sharedOptions, injectTreeShakingUsedExports, manifestOptions){
+        super(), this.sharedOptions = sharedOptions, this.injectTreeShakingUsedExports = injectTreeShakingUsedExports ?? !0, this.manifestOptions = manifestOptions ?? {};
+    }
+    buildOptions() {
+        let shared = this.sharedOptions.map(([shareKey, config])=>({
+                shareKey,
+                treeShaking: !!config.treeShaking,
+                usedExports: config.treeShaking?.usedExports
+            })), { manifestFileName, statsFileName } = getFileName(this.manifestOptions);
+        return {
+            shared,
+            injectTreeShakingUsedExports: this.injectTreeShakingUsedExports,
+            manifestFileName,
+            statsFileName
+        };
+    }
+    raw() {
+        if (this.sharedOptions.length) return createBuiltinPlugin(this.name, this.buildOptions());
+    }
+}
+let VIRTUAL_ENTRY = './virtual-entry.js', VIRTUAL_ENTRY_NAME = 'virtual-entry';
+class VirtualEntryPlugin {
+    sharedOptions;
+    collectShared = !1;
+    constructor(sharedOptions, collectShared){
+        this.sharedOptions = sharedOptions, this.collectShared = collectShared;
+    }
+    createEntry() {
+        let { sharedOptions, collectShared } = this;
+        return sharedOptions.reduce((acc, cur, index)=>acc + `import shared_${index} from '${cur[0]}';\n` + (collectShared ? `console.log(shared_${index});\n` : ''), '');
+    }
+    static entry() {
+        return {
+            [VIRTUAL_ENTRY_NAME]: VIRTUAL_ENTRY
+        };
+    }
+    apply(compiler) {
+        new compiler.rspack.experiments.VirtualModulesPlugin({
+            [VIRTUAL_ENTRY]: this.createEntry()
+        }).apply(compiler), compiler.hooks.thisCompilation.tap('RemoveVirtualEntryAsset', (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: 'RemoveVirtualEntryAsset',
+                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE
+            }, ()=>{
+                try {
+                    let chunk = compilation.namedChunks.get(VIRTUAL_ENTRY_NAME);
+                    chunk?.files.forEach((f)=>{
+                        compilation.deleteAsset(f);
+                    });
+                } catch (_e) {
+                    console.error('Failed to remove virtual entry file!');
+                }
+            });
+        });
+    }
+}
+let resolveOutputDir = (outputDir, shareName)=>shareName ? join(outputDir, encodeName(shareName)) : outputDir;
+class IndependentSharedPlugin {
+    mfName;
+    shared;
+    library;
+    sharedOptions;
+    outputDir;
+    plugins;
+    treeShaking;
+    manifest;
+    buildAssets = {};
+    injectTreeShakingUsedExports;
+    treeShakingSharedExcludePlugins;
+    name = 'IndependentSharedPlugin';
+    constructor(options){
+        let { outputDir, plugins, treeShaking, shared, name, manifest, injectTreeShakingUsedExports, library, treeShakingSharedExcludePlugins } = options;
+        this.shared = shared, this.mfName = name, this.outputDir = outputDir || 'independent-packages', this.plugins = plugins || [], this.treeShaking = treeShaking, this.manifest = manifest, this.injectTreeShakingUsedExports = injectTreeShakingUsedExports ?? !0, this.library = library, this.treeShakingSharedExcludePlugins = treeShakingSharedExcludePlugins || [], this.sharedOptions = parseOptions(shared, (item, key)=>{
+            if ('string' != typeof item) throw Error(`Unexpected array in shared configuration for key "${key}"`);
+            return item !== key && isRequiredVersion(item) ? {
+                import: key,
+                requiredVersion: item
+            } : {
+                import: item
+            };
+        }, (item)=>item);
+    }
+    apply(compiler) {
+        let { manifest } = this, runCount = 0;
+        compiler.hooks.beforeRun.tapPromise('IndependentSharedPlugin', async ()=>{
+            !runCount && (await this.createIndependentCompilers(compiler), runCount++);
+        }), compiler.hooks.watchRun.tapPromise('IndependentSharedPlugin', async ()=>{
+            !runCount && (await this.createIndependentCompilers(compiler), runCount++);
+        }), manifest && compiler.hooks.compilation.tap('IndependentSharedPlugin', (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: 'injectBuildAssets',
+                stage: compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER
+            }, ()=>{
+                let { statsFileName, manifestFileName } = getFileName(manifest), injectBuildAssetsIntoStatsOrManifest = (filename)=>{
+                    let stats = compilation.getAsset(filename);
+                    if (!stats) return;
+                    let statsContent = JSON.parse(stats.source.source().toString()), { shared } = statsContent;
+                    Object.entries(this.buildAssets).forEach(([key, item])=>{
+                        let targetShared = shared.find((s)=>s.name === key);
+                        targetShared && item.forEach(([entry, version, globalName])=>{
+                            version === targetShared.version && (targetShared.fallback = entry, targetShared.fallbackName = globalName);
+                        });
+                    }), compilation.updateAsset(filename, new compiler.webpack.sources.RawSource(JSON.stringify(statsContent)));
+                };
+                injectBuildAssetsIntoStatsOrManifest(statsFileName), injectBuildAssetsIntoStatsOrManifest(manifestFileName);
+            });
+        });
+    }
+    async createIndependentCompilers(parentCompiler) {
+        let { sharedOptions, buildAssets, outputDir } = this;
+        console.log('Start building shared fallback resources ...');
+        let shareRequestsMap = await this.createIndependentCompiler(parentCompiler);
+        await Promise.all(sharedOptions.map(async ([shareName, shareConfig])=>{
+            if (!shareConfig.treeShaking || !1 === shareConfig.import) return;
+            let shareRequests = shareRequestsMap[shareName].requests;
+            await Promise.all(shareRequests.map(async ([request, version])=>{
+                let sharedConfig = sharedOptions.find(([name])=>name === shareName)?.[1], [shareFileName, globalName, sharedVersion] = await this.createIndependentCompiler(parentCompiler, {
+                    shareRequestsMap,
+                    currentShare: {
+                        shareName,
+                        version,
+                        request,
+                        independentShareFileName: sharedConfig?.treeShaking?.filename
+                    }
+                });
+                'string' == typeof shareFileName && (buildAssets[shareName] ||= [], buildAssets[shareName].push([
+                    join(resolveOutputDir(outputDir, shareName), shareFileName),
+                    sharedVersion,
+                    globalName
+                ]));
+            }));
+        })), console.log('All shared fallback have been compiled successfully!');
+    }
+    async createIndependentCompiler(parentCompiler, extraOptions) {
+        let extraPlugin, { mfName, plugins, outputDir, sharedOptions, treeShaking, library, treeShakingSharedExcludePlugins } = this, outputDirWithShareName = resolveOutputDir(outputDir, extraOptions?.currentShare?.shareName || ''), parentConfig = parentCompiler.options, finalPlugins = [], rspack = parentCompiler.rspack;
+        extraPlugin = extraOptions ? new SharedContainerPlugin({
+            mfName: `${mfName}_${treeShaking ? 't' : 'f'}`,
+            library,
+            ...extraOptions.currentShare
+        }) : new CollectSharedEntryPlugin({
+            sharedOptions,
+            shareScope: 'default'
+        }), (parentConfig.plugins || []).forEach((plugin)=>{
+            void 0 !== plugin && 'string' != typeof plugin && ((plugin, excludedPlugins = [])=>{
+                if (!plugin) return !0;
+                let pluginName = plugin.name || plugin.constructor?.name;
+                return !pluginName || ![
+                    'TreeShakingSharedPlugin',
+                    'IndependentSharedPlugin',
+                    'ModuleFederationPlugin',
+                    'SharedUsedExportsOptimizerPlugin',
+                    'HtmlWebpackPlugin',
+                    'HtmlRspackPlugin',
+                    'RsbuildHtmlPlugin',
+                    ...excludedPlugins
+                ].includes(pluginName);
+            })(plugin, treeShakingSharedExcludePlugins) && finalPlugins.push(plugin);
+        }), plugins.forEach((plugin)=>{
+            finalPlugins.push(plugin);
+        }), finalPlugins.push(extraPlugin), finalPlugins.push(new ConsumeSharedPlugin({
+            consumes: sharedOptions.filter(([key, options])=>extraOptions?.currentShare.shareName !== (options.shareKey || key)).map(([key, options])=>({
+                    [key]: {
+                        import: !extraOptions && options.import,
+                        shareKey: options.shareKey || key,
+                        shareScope: options.shareScope,
+                        requiredVersion: options.requiredVersion,
+                        strictVersion: options.strictVersion,
+                        singleton: options.singleton,
+                        packageName: options.packageName,
+                        eager: options.eager
+                    }
+                })),
+            enhanced: !0
+        })), treeShaking && finalPlugins.push(new SharedUsedExportsOptimizerPlugin(sharedOptions, this.injectTreeShakingUsedExports)), finalPlugins.push(new VirtualEntryPlugin(sharedOptions, !extraOptions));
+        let fullOutputDir = external_node_path_resolve(parentCompiler.outputPath, outputDirWithShareName), compilerConfig = {
+            ...parentConfig,
+            module: {
+                ...parentConfig.module,
+                rules: [
+                    {
+                        test: /virtual-entry\.js$/,
+                        type: "javascript/auto",
+                        resolve: {
+                            fullySpecified: !1
+                        },
+                        use: {
+                            loader: 'builtin:swc-loader'
+                        }
+                    },
+                    ...parentConfig.module?.rules || []
+                ]
+            },
+            mode: parentConfig.mode || 'development',
+            entry: VirtualEntryPlugin.entry,
+            output: {
+                path: fullOutputDir,
+                clean: !0,
+                publicPath: parentConfig.output?.publicPath || 'auto'
+            },
+            plugins: finalPlugins,
+            optimization: {
+                ...parentConfig.optimization,
+                splitChunks: !1
+            }
+        }, compiler = rspack.rspack(compilerConfig);
+        compiler.inputFileSystem = parentCompiler.inputFileSystem, compiler.outputFileSystem = parentCompiler.outputFileSystem, compiler.intermediateFileSystem = parentCompiler.intermediateFileSystem;
+        let { currentShare } = extraOptions || {};
+        return new Promise((resolve, reject)=>{
+            compiler.run((err, stats)=>{
+                if (err || stats?.hasErrors()) {
+                    let target = currentShare ? currentShare.shareName : 'Collect deps';
+                    console.error(`${target} Compile failed:`, err || stats.toJson().errors.map((e)=>e.message).join('\n')), reject(err || Error(`${target} Compile failed`));
+                    return;
+                }
+                currentShare && console.log(`${currentShare.shareName} Compile success`), resolve(extraPlugin.getData());
+            });
+        });
+    }
+}
+let TreeShakingSharedPlugin_require = createRequire(import.meta.url);
+class TreeShakingSharedPlugin {
+    mfConfig;
+    outputDir;
+    secondary;
+    _independentSharePlugin;
+    name = 'TreeShakingSharedPlugin';
+    constructor(options){
+        let { mfConfig, secondary } = options;
+        this.mfConfig = mfConfig, this.outputDir = mfConfig.treeShakingSharedDir || 'independent-packages', this.secondary = !!secondary;
+    }
+    apply(compiler) {
+        let { mfConfig, outputDir, secondary } = this, { name, shared, library, treeShakingSharedPlugins } = mfConfig;
+        if (!shared) return;
+        let sharedOptions = normalizeSharedOptions(shared);
+        sharedOptions.length && sharedOptions.some(([_, config])=>config.treeShaking && !1 !== config.import) && (secondary || new SharedUsedExportsOptimizerPlugin(sharedOptions, mfConfig.injectTreeShakingUsedExports, mfConfig.manifest).apply(compiler), this._independentSharePlugin = new IndependentSharedPlugin({
+            name: name,
+            shared: shared,
+            outputDir,
+            plugins: treeShakingSharedPlugins?.map((p)=>new (TreeShakingSharedPlugin_require(p))()) || [],
+            treeShaking: secondary,
+            library,
+            manifest: mfConfig.manifest,
+            treeShakingSharedExcludePlugins: mfConfig.treeShakingSharedExcludePlugins
+        }), this._independentSharePlugin.apply(compiler));
+    }
+    get buildAssets() {
+        return this._independentSharePlugin?.buildAssets || {};
+    }
+}
+let ModuleFederationRuntimePlugin = base_create(binding_namespaceObject.BuiltinPluginName.ModuleFederationRuntimePlugin, (options = {})=>options), ModuleFederationPlugin_require = createRequire(import.meta.url);
+function getRemoteInfos(options) {
+    if (!options.remotes) return {};
+    let remoteType = options.remoteType || (options.library ? options.library.type : "script"), remotes = parseOptions(options.remotes, (item)=>({
+            external: Array.isArray(item) ? item : [
+                item
+            ],
+            shareScope: options.shareScope || 'default'
+        }), (item)=>({
+            external: Array.isArray(item.external) ? item.external : [
+                item.external
+            ],
+            shareScope: item.shareScope || options.shareScope || 'default'
+        })), remoteInfos = {};
+    for (let [key, config] of remotes)for (let external of config.external){
+        let [externalType, externalRequest] = function(external) {
+            let result = function(external) {
+                if (/^[a-z0-9-]+ /.test(external)) {
+                    let idx = external.indexOf(' ');
+                    return [
+                        external.slice(0, idx),
+                        external.slice(idx + 1)
+                    ];
+                }
+                return null;
+            }(external);
+            return null === result ? [
+                remoteType,
+                external
+            ] : result;
+        }(external);
+        if (remoteInfos[key] ??= [], "script" === externalType) {
+            let [url, global] = function(urlAndGlobal) {
+                let index = urlAndGlobal.indexOf('@');
+                return index <= 0 || index === urlAndGlobal.length - 1 ? null : [
+                    urlAndGlobal.substring(index + 1),
+                    urlAndGlobal.substring(0, index)
+                ];
+            }(externalRequest);
+            remoteInfos[key].push({
+                alias: key,
+                name: global,
+                entry: url,
+                externalType,
+                shareScope: config.shareScope
+            });
+        } else remoteInfos[key].push({
+            alias: key,
+            name: void 0,
+            entry: void 0,
+            externalType,
+            shareScope: config.shareScope
+        });
+    }
+    return remoteInfos;
+}
+function getDefaultEntryRuntime(paths, options, compiler, treeShakingShareFallbacks) {
+    let runtimePlugins = options.runtimePlugins ?? [], remoteInfos = getRemoteInfos(options), runtimePluginImports = [], runtimePluginVars = [], libraryType = options.library?.type || 'var';
+    for(let i = 0; i < runtimePlugins.length; i++){
+        let runtimePluginVar = `__module_federation_runtime_plugin_${i}__`, pluginSpec = runtimePlugins[i], pluginPath = Array.isArray(pluginSpec) ? pluginSpec[0] : pluginSpec, pluginParams = Array.isArray(pluginSpec) ? pluginSpec[1] : void 0;
+        runtimePluginImports.push(`import ${runtimePluginVar} from ${JSON.stringify(pluginPath)}`);
+        let paramsCode = void 0 === pluginParams ? 'undefined' : JSON.stringify(pluginParams);
+        runtimePluginVars.push(`{ plugin: ${runtimePluginVar}, params: ${paramsCode} }`);
+    }
+    let content = [
+        `import __module_federation_bundler_runtime__ from ${JSON.stringify(paths.bundlerRuntime)}`,
+        ...runtimePluginImports,
+        `const __module_federation_runtime_plugins__ = [${runtimePluginVars.join(', ')}].filter(({ plugin }) => plugin).map(({ plugin, params }) => plugin(params))`,
+        `const __module_federation_remote_infos__ = ${JSON.stringify(remoteInfos)}`,
+        `const __module_federation_container_name__ = ${JSON.stringify(options.name ?? compiler.options.output.uniqueName)}`,
+        `const __module_federation_share_strategy__ = ${JSON.stringify(options.shareStrategy ?? 'version-first')}`,
+        `const __module_federation_share_fallbacks__ = ${JSON.stringify(treeShakingShareFallbacks)}`,
+        `const __module_federation_library_type__ = ${JSON.stringify(libraryType)}`,
+        compiler.webpack.Template.getFunctionContent(ModuleFederationPlugin_require('./moduleFederationDefaultRuntime.js').default)
+    ].join(';');
+    return `@module-federation/runtime/rspack.js!=!data:text/javascript,${content}`;
+}
 class ContainerPlugin extends RspackBuiltinPlugin {
     name = binding_namespaceObject.BuiltinPluginName.ContainerPlugin;
     _options;
@@ -12256,7 +13195,7 @@ class ContainerPlugin extends RspackBuiltinPlugin {
             name: options.name,
             shareScope: options.shareScope || 'default',
             library: options.library || {
-                type: 'var',
+                type: 'global',
                 name: options.name
             },
             runtime: options.runtime,
@@ -12343,7 +13282,7 @@ async function transform(source, options) {
     let _options = JSON.stringify(options || {});
     return binding_default().transform(source, _options);
 }
-let exports_rspackVersion = "2.0.0-beta.0", exports_version = "5.75.0", exports_WebpackError = Error, exports_config = {
+let exports_rspackVersion = "2.0.0-beta.1", exports_version = "5.75.0", exports_WebpackError = Error, exports_config = {
     getNormalizedRspackOptions: getNormalizedRspackOptions,
     applyRspackOptionsDefaults: applyRspackOptionsDefaults,
     getNormalizedWebpackOptions: getNormalizedRspackOptions,
@@ -12386,10 +13325,12 @@ let exports_rspackVersion = "2.0.0-beta.0", exports_version = "5.75.0", exports_
     ContainerReferencePlugin: ContainerReferencePlugin,
     ModuleFederationPlugin: class {
         _options;
+        _treeShakingSharedPlugin;
         constructor(_options){
             this._options = _options;
         }
         apply(compiler) {
+            var options;
             let { webpack } = compiler, paths = function(options, compiler) {
                 let runtimeToolsPath;
                 if (options.implementation) runtimeToolsPath = options.implementation;
@@ -12422,32 +13363,38 @@ let exports_rspackVersion = "2.0.0-beta.0", exports_version = "5.75.0", exports_
                 '@module-federation/runtime-tools': paths.runtimeTools,
                 '@module-federation/runtime': paths.runtime,
                 ...compiler.options.resolve.alias
-            };
-            let entryRuntime = function(paths, options, compiler) {
-                let runtimePlugins = options.runtimePlugins ?? [], remoteInfos = getRemoteInfos(options), runtimePluginImports = [], runtimePluginVars = [];
-                for(let i = 0; i < runtimePlugins.length; i++){
-                    let runtimePluginVar = `__module_federation_runtime_plugin_${i}__`, pluginSpec = runtimePlugins[i], pluginPath = Array.isArray(pluginSpec) ? pluginSpec[0] : pluginSpec, pluginParams = Array.isArray(pluginSpec) ? pluginSpec[1] : void 0;
-                    runtimePluginImports.push(`import ${runtimePluginVar} from ${JSON.stringify(pluginPath)}`);
-                    let paramsCode = void 0 === pluginParams ? 'undefined' : JSON.stringify(pluginParams);
-                    runtimePluginVars.push(`{ plugin: ${runtimePluginVar}, params: ${paramsCode} }`);
-                }
-                let content = [
-                    `import __module_federation_bundler_runtime__ from ${JSON.stringify(paths.bundlerRuntime)}`,
-                    ...runtimePluginImports,
-                    `const __module_federation_runtime_plugins__ = [${runtimePluginVars.join(', ')}].filter(({ plugin }) => plugin).map(({ plugin, params }) => plugin(params))`,
-                    `const __module_federation_remote_infos__ = ${JSON.stringify(remoteInfos)}`,
-                    `const __module_federation_container_name__ = ${JSON.stringify(options.name ?? compiler.options.output.uniqueName)}`,
-                    `const __module_federation_share_strategy__ = ${JSON.stringify(options.shareStrategy ?? 'version-first')}`,
-                    compiler.webpack.Template.getFunctionContent(ModuleFederationPlugin_require('./moduleFederationDefaultRuntime.js').default)
-                ].join(';');
-                return `@module-federation/runtime/rspack.js!=!data:text/javascript,${content}`;
-            }(paths, this._options, compiler);
-            new ModuleFederationRuntimePlugin({
-                entryRuntime,
-                experiments: {
-                    asyncStartup: this._options.experiments?.asyncStartup ?? !1
-                }
-            }).apply(compiler);
+            }, ((options = this._options).shared ? parseOptions(options.shared, (item, key)=>{
+                if ('string' != typeof item) throw Error('Unexpected array in shared');
+                return item !== key && isRequiredVersion(item) ? {
+                    import: key,
+                    requiredVersion: item
+                } : {
+                    import: item
+                };
+            }, (item)=>item) : []).filter(([, config])=>config.treeShaking).length > 0 && (this._treeShakingSharedPlugin = new TreeShakingSharedPlugin({
+                mfConfig: this._options,
+                secondary: !1
+            }), this._treeShakingSharedPlugin.apply(compiler));
+            let runtimeExperiments = {
+                asyncStartup: this._options.experiments?.asyncStartup ?? !1
+            }, runtimePluginApplied = !1;
+            compiler.hooks.beforeRun.tap({
+                name: 'ModuleFederationPlugin',
+                stage: 100
+            }, ()=>{
+                runtimePluginApplied || (runtimePluginApplied = !0, new ModuleFederationRuntimePlugin({
+                    entryRuntime: getDefaultEntryRuntime(paths, this._options, compiler, this._treeShakingSharedPlugin?.buildAssets),
+                    experiments: runtimeExperiments
+                }).apply(compiler));
+            }), compiler.hooks.watchRun.tap({
+                name: 'ModuleFederationPlugin',
+                stage: 100
+            }, ()=>{
+                runtimePluginApplied || (runtimePluginApplied = !0, new ModuleFederationRuntimePlugin({
+                    entryRuntime: getDefaultEntryRuntime(paths, this._options, compiler, this._treeShakingSharedPlugin?.buildAssets || {}),
+                    experiments: runtimeExperiments
+                }).apply(compiler));
+            });
             let v1Options = {
                 name: this._options.name,
                 exposes: this._options.exposes,
@@ -12460,74 +13407,7 @@ let exports_rspackVersion = "2.0.0-beta.0", exports_version = "5.75.0", exports_
                 shared: this._options.shared,
                 enhanced: !0
             };
-            if (new webpack.container.ModuleFederationPluginV1(v1Options).apply(compiler), this._options.manifest) {
-                let manifestOptions = !0 === this._options.manifest ? {} : {
-                    ...this._options.manifest
-                }, containerName = manifestOptions.name ?? this._options.name, globalName = manifestOptions.globalName ?? function(library) {
-                    if (!library) return;
-                    let libName = library.name;
-                    if (libName) {
-                        if ('string' == typeof libName) return libName;
-                        if (Array.isArray(libName)) return libName[0];
-                        if ('object' == typeof libName) return libName.root?.[0] ?? libName.amd ?? libName.commonjs ?? void 0;
-                    }
-                }(this._options.library) ?? containerName, remoteAliasMap = Object.entries(getRemoteInfos(this._options)).reduce((sum, cur)=>{
-                    if (cur[1].length > 1) return sum;
-                    let { entry, alias, name } = cur[1][0];
-                    return entry && name && (sum[alias] = {
-                        name,
-                        entry
-                    }), sum;
-                }, {}), manifestExposes = function(exposes) {
-                    if (!exposes) return;
-                    let result = parseOptions(exposes, (value)=>({
-                            import: Array.isArray(value) ? value : [
-                                value
-                            ],
-                            name: void 0
-                        }), (value)=>({
-                            import: Array.isArray(value.import) ? value.import : [
-                                value.import
-                            ],
-                            name: value.name ?? void 0
-                        })).map(([exposeKey, info])=>{
-                        let exposeName = info.name ?? exposeKey.replace(/^\.\//, '');
-                        return {
-                            path: exposeKey,
-                            name: exposeName
-                        };
-                    });
-                    return result.length > 0 ? result : void 0;
-                }(this._options.exposes);
-                void 0 === manifestOptions.exposes && manifestExposes && (manifestOptions.exposes = manifestExposes);
-                let manifestShared = function(shared) {
-                    if (!shared) return;
-                    let result = parseOptions(shared, (item, key)=>{
-                        if ('string' != typeof item) throw Error('Unexpected array in shared');
-                        return item !== key && isRequiredVersion(item) ? {
-                            import: key,
-                            requiredVersion: item
-                        } : {
-                            import: item
-                        };
-                    }, (item)=>item).map(([key, config])=>{
-                        let name = config.shareKey || key;
-                        return {
-                            name,
-                            version: 'string' == typeof config.version ? config.version : void 0,
-                            requiredVersion: 'string' == typeof config.requiredVersion ? config.requiredVersion : void 0,
-                            singleton: config.singleton
-                        };
-                    });
-                    return result.length > 0 ? result : void 0;
-                }(this._options.shared);
-                void 0 === manifestOptions.shared && manifestShared && (manifestOptions.shared = manifestShared), new ModuleFederationManifestPlugin({
-                    ...manifestOptions,
-                    name: containerName,
-                    globalName,
-                    remoteAliasMap
-                }).apply(compiler);
-            }
+            new webpack.container.ModuleFederationPluginV1(v1Options).apply(compiler), this._options.manifest && new ModuleFederationManifestPlugin(this._options).apply(compiler);
         }
     },
     ModuleFederationPluginV1: class {
@@ -12564,6 +13444,7 @@ let exports_rspackVersion = "2.0.0-beta.0", exports_version = "5.75.0", exports_
     }
 }, sharing = {
     ProvideSharedPlugin: ProvideSharedPlugin,
+    TreeShakingSharedPlugin: TreeShakingSharedPlugin,
     ConsumeSharedPlugin: ConsumeSharedPlugin,
     SharePlugin: SharePlugin
 }, exports_experiments = {
@@ -12629,7 +13510,7 @@ let exports_rspackVersion = "2.0.0-beta.0", exports_version = "5.75.0", exports_
             ssr: 'server-side-rendering'
         }
     }
-}, src_fn = Object.assign(rspack, exports_namespaceObject);
+}, src_fn = Object.assign(rspack_rspack, exports_namespaceObject);
 src_fn.rspack = src_fn, src_fn.webpack = src_fn;
 let src_rspack_0 = src_fn;
 var AsyncDependenciesBlock = binding_namespaceObject.AsyncDependenciesBlock, ConcatenatedModule = binding_namespaceObject.ConcatenatedModule, ContextModule = binding_namespaceObject.ContextModule, Dependency = binding_namespaceObject.Dependency, EntryDependency = binding_namespaceObject.EntryDependency, ExternalModule = binding_namespaceObject.ExternalModule, Module = binding_namespaceObject.Module, NormalModule = binding_namespaceObject.NormalModule;