@rsdoctor/core 2.0.0-alpha.2 → 2.0.0-beta.0

package/dist/26.js

@@ -5,7 +5,7 @@ import fs_extra from "fs-extra";
 import fs_0 from "fs";
 import path_0, { dirname, isAbsolute, resolve as external_path_resolve } from "path";
 import node_fs from "node:fs";
-import connect from "connect";
+import { connect } from "connect-next";
 import http from "http";
 import os from "os";
 import "get-port";
@@ -23983,8 +23983,8 @@ async function reportLoader(ctx, start, startHRTime, isPitch, sync, code, err, r
         sourcesContent: data.sourcesContent,
         mappings: data.mappings,
         file: loaderData[0].resource.path
-    }, sdk = getSDK(ctx._compilation?.name);
-    return sdk?.reportLoader && !('parent' in sdk && sdk.parent) ? (sdk.reportLoader(loaderData), sdk.reportSourceMap(sourceMapData)) : await Promise.all([
+    }, compilation = ctx._compilation, sdk = getSDK(compilation?.compiler?.compilerPath || compilation?.name);
+    return sdk?.reportLoader ? (sdk.reportLoader(loaderData), sdk.reportSourceMap(sourceMapData)) : await Promise.all([
         Fetch.postJSON(`${host}${SDK.ServerAPI.API.ReportLoader}`, loaderData, 8888).catch((err)=>{
             rsdoctorLogger.debug(`${err.message}`, '[RspackPlugin.ReportLoader][error]');
         }),
@@ -24070,7 +24070,16 @@ function getDefaultOutput() {
         compressData: void 0
     };
 }
-function normalizeUserConfig(config = {}) {
+let normalizeReportType = (reportCodeType, mode)=>{
+    let convertedReportCodeType = 'object' == typeof reportCodeType ? function(reportCodeType) {
+        if (reportCodeType) {
+            if (reportCodeType.noCode) return 'noCode';
+            else if (reportCodeType.noAssetsAndModuleSource) return 'noAssetsAndModuleSource';
+            else if (reportCodeType.noModuleSource) return 'noModuleSource';
+        }
+    }(reportCodeType) : reportCodeType;
+    return 'noCode' === convertedReportCodeType || mode === SDK.IMode[SDK.IMode.brief] ? SDK.ToDataType.NoCode : mode === SDK.IMode[SDK.IMode.lite] || 'noAssetsAndModuleSource' === convertedReportCodeType ? SDK.ToDataType.NoSourceAndAssets : 'noModuleSource' === convertedReportCodeType ? SDK.ToDataType.NoSource : SDK.ToDataType.Normal;
+}, normalizeRspackUserOptions = function(config = {}) {
     var mode, mode1, finalMode, value, value1;
     let gzipLevel, finalBrief, finalNormalOptions, userOutput = config.output, defaultOutput = getDefaultOutput(), outputConfig = 'json' === process.env.RSDOCTOR_OUTPUT ? {
         reportDir: userOutput?.reportDir,
@@ -24083,7 +24092,7 @@ function normalizeUserConfig(config = {}) {
         }
     } : userOutput ?? defaultOutput, { linter = {}, features = {}, loaderInterceptorOptions = {}, disableClientServer: userDisableClientServer = !1, sdkInstance, innerClientPath = '', output = outputConfig, supports: userSupports = {}, port, server: userServer = {}, printLog = {
         serverUrls: !0
-    }, mode: mode2, brief } = {
+    }, mode: mode2, brief, multiCompiler = !0 } = {
         ...config,
         output: outputConfig
     }, supports = {
@@ -24099,7 +24108,7 @@ function normalizeUserConfig(config = {}) {
     let server = {
         ...userServer
     };
-    assert(void 0 === server.port || 'number' == typeof server.port), void 0 === server.port && void 0 !== port && (server.port = port);
+    assert(void 0 === server.port || 'number' == typeof server.port), assert('boolean' == typeof multiCompiler || 'object' == typeof multiCompiler && null !== multiCompiler), void 0 === server.port && void 0 !== port && (server.port = port);
     let finalMode1 = ('mode' in output && 'string' == typeof (mode = output.mode) && [
         'brief',
         'normal',
@@ -24176,20 +24185,14 @@ function normalizeUserConfig(config = {}) {
         supports,
         port,
         server,
-        printLog
+        printLog,
+        multiCompiler: {
+            enabled: !1 !== multiCompiler,
+            group: 'object' == typeof multiCompiler ? multiCompiler.group : void 0
+        }
     };
     return void 0 !== output.compressData && rsdoctorLogger.info(external_rslog_color.yellow("The 'compressData' configuration will be deprecated in a future version.")), res;
-}
-let normalizeReportType = (reportCodeType, mode)=>{
-    let convertedReportCodeType = 'object' == typeof reportCodeType ? function(reportCodeType) {
-        if (reportCodeType) {
-            if (reportCodeType.noCode) return 'noCode';
-            else if (reportCodeType.noAssetsAndModuleSource) return 'noAssetsAndModuleSource';
-            else if (reportCodeType.noModuleSource) return 'noModuleSource';
-        }
-    }(reportCodeType) : reportCodeType;
-    return 'noCode' === convertedReportCodeType || mode === SDK.IMode[SDK.IMode.brief] ? SDK.ToDataType.NoCode : mode === SDK.IMode[SDK.IMode.lite] || 'noAssetsAndModuleSource' === convertedReportCodeType ? SDK.ToDataType.NoSourceAndAssets : 'noModuleSource' === convertedReportCodeType ? SDK.ToDataType.NoSource : SDK.ToDataType.Normal;
-}, normalizeRspackUserOptions = normalizeUserConfig, execAsync = promisify(external_node_child_process_exec), supportedChromiumBrowsers = [
+}, execAsync = promisify(external_node_child_process_exec), supportedChromiumBrowsers = [
     'Google Chrome Canary',
     'Google Chrome Dev',
     'Google Chrome Beta',
@@ -24322,7 +24325,9 @@ class InternalLoaderPlugin extends InternalBasePlugin {
     apply(compiler) {
         logger_time('InternalLoaderPlugin.apply');
         try {
-            compiler.hooks.afterPlugins.tap(this.tapPostOptions, this.afterPlugins.bind(this, compiler)), compiler.hooks.compilation.tap(this.tapPreOptions, (compilation)=>this.compilation(compiler, compilation));
+            compiler.isChild() ? this.sdk.addClientRoutes([
+                Manifest.RsdoctorManifestClientRoutes.Loaders
+            ]) : compiler.hooks.afterPlugins.tap(this.tapPostOptions, this.afterPlugins.bind(this, compiler)), compiler.hooks.compilation.tap(this.tapPreOptions, (compilation)=>this.compilation(compiler, compilation));
         } finally{
             logger_timeEnd('InternalLoaderPlugin.apply');
         }
@@ -24330,7 +24335,7 @@ class InternalLoaderPlugin extends InternalBasePlugin {
     compilation(compiler, compilation) {
         logger_time('InternalLoaderPlugin.compilation');
         try {
-            if (compiler.isChild()) return;
+            if (compilation.compiler && compilation.compiler !== compiler) return;
             let wrapper = (callback)=>(loaderContext, module)=>{
                     let originLoaders = (module?.loaders || loaderContext?.loaders || []).map((loader)=>{
                         let rawOptions = loader.options, opts = 'object' == typeof rawOptions && null !== rawOptions ? rawOptions : {};
@@ -24406,7 +24411,6 @@ class InternalLoaderPlugin extends InternalBasePlugin {
         super(...args), this.name = 'loader', this.internalLoaderPath = loader_require.resolve('@rsdoctor/core/proxy-loader'), this.afterPlugins = (compiler)=>{
             logger_time('InternalLoaderPlugin.afterPlugins');
             try {
-                if (compiler.isChild()) return;
                 compiler.options.module.rules = this.getInterceptRules(compiler, compiler.options.module.rules), this.sdk.addClientRoutes([
                     Manifest.RsdoctorManifestClientRoutes.Loaders
                 ]);
@@ -24420,7 +24424,7 @@ class InternalPluginsPlugin extends InternalBasePlugin {
     apply(compiler) {
         logger_time('InternalPluginsPlugin.apply');
         try {
-            compiler.hooks.afterPlugins.tap(this.tapPostOptions, this.afterPlugins.bind(this, compiler)), compiler.hooks.compilation.tap(this.tapPostOptions, this.compilation);
+            compiler.isChild() ? this.afterPlugins(compiler) : compiler.hooks.afterPlugins.tap(this.tapPostOptions, this.afterPlugins.bind(this, compiler)), compiler.hooks.compilation.tap(this.tapPostOptions, (compilation)=>this.compilation(compiler, compilation));
         } finally{
             logger_timeEnd('InternalPluginsPlugin.apply');
         }
@@ -24429,17 +24433,16 @@ class InternalPluginsPlugin extends InternalBasePlugin {
         super(...args), this.name = 'plugins', this.afterPlugins = (compiler)=>{
             logger_time('InternalPluginsPlugin.afterPlugins');
             try {
-                if (compiler.isChild()) return;
                 interceptCompilerHooks(compiler, (name, hook)=>interceptPluginHook(this.sdk, name, hook)), this.sdk.addClientRoutes([
                     Manifest.RsdoctorManifestClientRoutes.Plugins
                 ]);
             } finally{
                 logger_timeEnd('InternalPluginsPlugin.afterPlugins');
             }
-        }, this.compilation = (compilation)=>{
+        }, this.compilation = (compiler, compilation)=>{
             logger_time('InternalPluginsPlugin.compilation');
             try {
-                if (compilation.compiler.isChild()) return;
+                if (compilation.compiler && compilation.compiler !== compiler) return;
                 interceptCompilationHooks(compilation, (name, hook)=>interceptPluginHook(this.sdk, name, hook));
             } finally{
                 logger_timeEnd('InternalPluginsPlugin.compilation');
@@ -24451,7 +24454,7 @@ class InternalErrorReporterPlugin extends InternalBasePlugin {
     apply(compiler) {
         logger_time('InternalErrorReporterPlugin.apply');
         try {
-            compiler.hooks.done.tapPromise(this.tapPreOptions, this.done);
+            compiler.isChild() ? compiler.hooks.afterCompile.tapPromise(this.tapPreOptions, this.afterCompile) : compiler.hooks.done.tapPromise(this.tapPreOptions, this.done);
         } finally{
             logger_timeEnd('InternalErrorReporterPlugin.apply');
         }
@@ -24500,6 +24503,11 @@ class InternalErrorReporterPlugin extends InternalBasePlugin {
             } finally{
                 logger_timeEnd('InternalErrorReporterPlugin.done');
             }
+        }, this.afterCompile = async (compilation)=>{
+            await Promise.all([
+                this.reportErrors(compilation.errors || []),
+                this.reportWarnings(compilation.warnings || [])
+            ]);
         };
     }
 }
@@ -24507,7 +24515,7 @@ class InternalSummaryPlugin extends InternalBasePlugin {
     apply(compiler) {
         logger_time('InternalSummaryPlugin.apply');
         try {
-            compiler.hooks.beforeCompile.tapPromise(this.tapPostOptions, this.beforeCompile), compiler.hooks.afterCompile.tapPromise(this.tapPreOptions, this.afterCompile), compiler.hooks.done.tapPromise(this.tapPostOptions, this.done.bind(this, compiler));
+            compiler.hooks.beforeCompile.tapPromise(this.tapPostOptions, this.beforeCompile.bind(this, compiler)), compiler.hooks.afterCompile.tapPromise(this.tapPreOptions, this.afterCompile.bind(this, compiler)), compiler.isChild() || compiler.hooks.done.tapPromise(this.tapPostOptions, this.done.bind(this, compiler));
         } finally{
             logger_timeEnd('InternalSummaryPlugin.apply');
         }
@@ -24534,20 +24542,20 @@ class InternalSummaryPlugin extends InternalBasePlugin {
         });
     }
     constructor(...args){
-        super(...args), this.name = 'summary', this.times = new Map(), this.preTimes = new Map(), this.postTimes = new Map(), this.beforeCompile = async ()=>{
+        super(...args), this.name = 'summary', this.times = new Map(), this.preTimes = new Map(), this.postTimes = new Map(), this.createdAt = Date.now(), this.beforeCompile = async (compiler)=>{
             logger_time('InternalSummaryPlugin.beforeCompile');
             try {
                 if (!this.times.has(Summary.SummaryCostsDataName.Bootstrap)) {
-                    let costs = Math.floor(1000 * process.uptime()), startAt = Date.now() - costs;
+                    let startAt = compiler.isChild() ? this.createdAt : Date.now() - Math.floor(1000 * process.uptime());
                     this.report(Summary.SummaryCostsDataName.Bootstrap, startAt), this.mark(Summary.SummaryCostsDataName.Bootstrap, 'post');
                 }
             } finally{
                 logger_timeEnd('InternalSummaryPlugin.beforeCompile');
             }
-        }, this.afterCompile = async (compilation)=>{
+        }, this.afterCompile = async (compiler, compilation)=>{
             logger_time('InternalSummaryPlugin.afterCompile');
             try {
-                if (!this.times.has(Summary.SummaryCostsDataName.Compile) && !compilation.compiler.isChild()) {
+                if (!this.times.has(Summary.SummaryCostsDataName.Compile) && (!compilation.compiler || compilation.compiler === compiler)) {
                     let start = this.postTimes.get(Summary.SummaryCostsDataName.Bootstrap);
                     this.report(Summary.SummaryCostsDataName.Compile, start), this.mark(Summary.SummaryCostsDataName.Compile, 'post');
                 }
@@ -24582,7 +24590,9 @@ class InternalBundlePlugin extends InternalBasePlugin {
     apply(compiler) {
         logger_time('InternalBundlePlugin.apply');
         try {
-            this.scheduler.ensureModulesChunksGraphApplied(compiler), this.changeDevtoolModuleFilename(compiler), compiler.hooks.compilation.tap(this.tapPostOptions, this.thisCompilation), compiler.hooks.done.tapPromise(this.tapPreOptions, this.done.bind(this));
+            this.scheduler.ensureModulesChunksGraphApplied(compiler), this.changeDevtoolModuleFilename(compiler), compiler.hooks.compilation.tap(this.tapPostOptions, (compilation)=>{
+                compilation.compiler && compilation.compiler !== compiler || this.thisCompilation(compilation);
+            }), compiler.isChild() ? compiler.hooks.afterCompile.tapPromise(this.tapPreOptions, this.done.bind(this)) : compiler.hooks.done.tapPromise(this.tapPreOptions, this.done.bind(this));
         } finally{
             logger_timeEnd('InternalBundlePlugin.apply');
         }
@@ -24636,8 +24646,8 @@ async function collectSourceMaps(map, assetLinesCodeList, _compilation, _this, s
         let sourceMapDir1, consumer = await new SourceMapConsumer(map);
         sourceMapPath ? sourceMapDir1 = dirname(sourceMapPath) : _compilation.options.output?.path && (sourceMapDir1 = 'string' == typeof _compilation.options.output.path ? _compilation.options.output.path : void 0);
         let sourceRoot1 = map.sourceRoot, getRealSourcePath = (context = _this.sdk.root || process.cwd(), cache = _this._realSourcePathCache, sourceMapDir = sourceMapDir1, sourceRoot = sourceRoot1 ?? void 0, cache = cache || new Map(), (source, sourceMapFilenameRegex)=>{
+            let resolved;
             if (cache.has(source)) return cache.get(source);
-            let resolved = UNASSIGNED;
             if (source.startsWith('file://')) resolved = external_path_resolve(context, source.replace(/^file:\/\//, ''));
             else if (source.startsWith('webpack://')) if (sourceMapFilenameRegex) {
                 let match = source.match(sourceMapFilenameRegex), filePath = match?.[1], baseDir = namespace && source.startsWith(`webpack://${namespace}`) || namespace && source.startsWith(`file://${namespace}`) ? process.cwd() : context;
@@ -24773,6 +24783,7 @@ let hasConsole = !1, ensureModulesChunksGraphFn = (compiler, _this)=>{
         chunkGraph: !1,
         moduleGraph: !1
     }, rsdoctorLogger.debug('[RspackNativePlugin] Apply hooks'), compiler.hooks.compilation.tap('RsdoctorRspackPlugin', (compilation)=>{
+        if (compilation.compiler && compilation.compiler !== compiler) return;
         state.chunkGraph = !1, state.moduleGraph = !1;
         let hooks = RsdoctorRspackPlugin.getCompilationHooks(compilation), cached = {}, dependOn = {
             chunkGraphData: [],
@@ -24924,13 +24935,13 @@ let hasConsole = !1, ensureModulesChunksGraphFn = (compiler, _this)=>{
             rsdoctorLogger.debug('[RspackNativePlugin] Called assets hook'), tryConsumeData('assetPatchData', rawAssetPatch);
         });
     }), state);
-    _this._realSourcePathCache || (_this._realSourcePathCache = new Map()), compiler.hooks.done.tapPromise(internalPluginTapPreOptions('moduleGraph'), async ()=>{
+    _this._realSourcePathCache || (_this._realSourcePathCache = new Map()), ('function' == typeof compiler.isChild && compiler.isChild() ? compiler.hooks.afterCompile : compiler.hooks.done).tapPromise(internalPluginTapPreOptions('moduleGraph'), async ()=>{
         await doneHandler(_this, compiler, nativeGraphState);
     }), compiler.hooks.compilation.tap({
         ...pluginTapPostOptions,
         name: 'RsdoctorSourceMapCollector'
     }, (compilation)=>{
-        compilation.hooks.processAssets && compilation.hooks.processAssets.tapPromise({
+        (!compilation.compiler || compilation.compiler === compiler) && compilation.hooks.processAssets && compilation.hooks.processAssets.tapPromise({
             name: 'RsdoctorSourceMapCollector',
             stage: 2400
         }, async ()=>{
@@ -26074,7 +26085,7 @@ class InternalRulesPlugin extends InternalBasePlugin {
     apply(compiler) {
         logger_time('InternalRulesPlugin.apply');
         try {
-            compiler.hooks.done.tapPromise(this.tapPreOptions, this.done);
+            compiler.isChild() ? compiler.hooks.afterCompile.tapPromise(this.tapPreOptions, this.lint.bind(this)) : compiler.hooks.done.tapPromise(this.tapPreOptions, this.done);
         } finally{
             logger_timeEnd('InternalRulesPlugin.apply');
         }
@@ -26160,4 +26171,4 @@ class InternalResolverPlugin extends InternalBasePlugin {
         };
     }
 }
-export { DevToolError, FileSharding, InternalBundlePlugin, InternalErrorReporterPlugin, InternalLoaderPlugin, InternalPluginsPlugin, InternalResolverPlugin, InternalRulesPlugin, InternalSummaryPlugin, Linter as LinterType, ProbeLoaderPlugin, createServer, defaultHost, defaultPort, defineRule, ensureModulesChunksGraphFn, fs_extra, getCPUInfo, getMemoryInfo, getNodeVersion, getNpmVersion, getOriginLoaderModule, getPnpmVersion, getPortSync, getRspackNativePlugin, getYarnVersion, handleBriefModeReport, linter_Linter as Linter, normalizeRspackUserOptions, normalizeUserConfig, processCompilerConfig, reportLoader, rule_Rule as LinterRule, rules_rules as rules, shouldSkipLoader };
+export { DevToolError, FileSharding, InternalBundlePlugin, InternalErrorReporterPlugin, InternalLoaderPlugin, InternalPluginsPlugin, InternalResolverPlugin, InternalRulesPlugin, InternalSummaryPlugin, Linter as LinterType, ProbeLoaderPlugin, createServer, defaultHost, defaultPort, defineRule, ensureModulesChunksGraphFn, fs_extra, getCPUInfo, getMemoryInfo, getNodeVersion, getNpmVersion, getOriginLoaderModule, getPnpmVersion, getPortSync, getRspackNativePlugin, getYarnVersion, handleBriefModeReport, linter_Linter as Linter, normalizeRspackUserOptions, processCompilerConfig, reportLoader, rule_Rule as LinterRule, rules_rules as rules, shouldSkipLoader };

package/dist/630.js

@@ -1225,18 +1225,29 @@ function getModuleLocation(node) {
     };
 }
 function setSDK(t) {
-    globalThis.__rsdoctor_sdks__ || (globalThis.__rsdoctor_sdks__ = []), globalThis.__rsdoctor_sdks__.push(t), globalThis.__rsdoctor_sdk__ = t;
+    registerSDK(t, !0);
 }
-function getSDK(builderName) {
+function registerSDK(t, asDefault = !1) {
+    globalThis.__rsdoctor_sdks__ || (globalThis.__rsdoctor_sdks__ = []);
+    let sameNameIndex = globalThis.__rsdoctor_sdks__.findIndex((sdk)=>sdk.name === t.name);
+    sameNameIndex >= 0 ? globalThis.__rsdoctor_sdks__[sameNameIndex] = t : globalThis.__rsdoctor_sdks__.includes(t) || globalThis.__rsdoctor_sdks__.push(t), asDefault && (globalThis.__rsdoctor_sdk__ = t);
+}
+function findMatchingSDK(sdks, compilerId) {
+    let exactMatch = sdks.find((item)=>item.name === compilerId || 'compilerPath' in item && item.compilerPath === compilerId);
+    if (exactMatch) return exactMatch;
+    let compilerName = compilerId.split('|', 1)[0];
+    if (compilerName && compilerName !== compilerId) return sdks.find((item)=>item.name === compilerName);
+}
+function getSDK(compilerId) {
     let sdks = globalThis.__rsdoctor_sdks__ || [], sdk = globalThis.__rsdoctor_sdk__;
-    if (sdk && sdk.name !== builderName && (sdk = builderName && sdks.find((s)=>s.name === builderName) || sdk), sdk && builderName && 'parent' in sdk) {
+    if (compilerId && (sdk = findMatchingSDK(sdks, compilerId) || sdk), sdk && compilerId && 'parent' in sdk) {
         let parent = sdk.parent;
-        return parent?.slaves.find((_sdk)=>_sdk.name === builderName) || sdk;
+        return parent && findMatchingSDK(parent.slaves, compilerId) || sdk;
     }
     return sdk;
 }
 export default function(...args) {
-    let time = Date.now(), code = args[0], _options = this.getOptions(), sdk = getSDK(_options.builderName), loaderData = {
+    let time = Date.now(), code = args[0], _options = this.getOptions(), compilation = this._compilation, sdk = getSDK(compilation?.compiler?.compilerPath || _options.builderName), loaderData = {
         resource: {
             path: this._module?.layer ? `${this.resourcePath}[${this._module.layer}]` : this.resourcePath,
             query: parseQuery(this.resourceQuery),
@@ -1266,4 +1277,4 @@ export default function(...args) {
     };
     sdk?.reportLoaderStartOrEnd(loaderData), this.callback(null, ...args);
 };
-export { addProbeLoader2Rules, color, createLoaderContextTrap, extractLoaderName, filesize, getDocument, getLoaderNameMatch, getSDK, interceptCompilationHooks, interceptCompilerHooks, isESMLoader, loadLoaderModule, logger_time, mapEachRules, parseBundle, parseQuery, parser, rsdoctorLogger as logger, setSDK, stringify, timeEnd };
+export { addProbeLoader2Rules, color, createLoaderContextTrap, extractLoaderName, filesize, getDocument, getLoaderNameMatch, getSDK, interceptCompilationHooks, interceptCompilerHooks, isESMLoader, loadLoaderModule, logger_time, mapEachRules, parseBundle, parseQuery, parser, registerSDK, rsdoctorLogger as logger, setSDK, stringify, timeEnd };

package/dist/build-utils/build/server.d.ts

@@ -1,4 +1,3 @@
-import connect from 'connect';
 import http from 'http';
 import { Thirdparty } from '@rsdoctor/shared/types';
 export declare const defaultHost = "127.0.0.1";
@@ -6,7 +5,7 @@ export declare const defaultPort: number;
 export declare function getPort(expectPort: number, host?: string): Promise<number>;
 export declare const createGetPortSyncFunctionString: (expectPort: number, host?: string) => string;
 export declare function getPortSync(expectPort: number, host?: string): number | never;
-export declare function createApp(): connect.Server;
+export declare function createApp(): Thirdparty.connect.Server;
 export declare function createServer(port: number, host?: string): Promise<{
     app: Thirdparty.connect.Server;
     server: http.Server;

package/dist/index.js

@@ -1,7 +1,5 @@
-let globalController;
-import { createRequire as external_node_module_createRequire } from "node:module";
-import { __webpack_require__ } from "./rslib-runtime.js";
-import node_fs, { existsSync } from "node:fs";
+import { createRequire as __rspack_createRequire } from "node:module";
+import node_fs from "node:fs";
 import fs_extra from "fs-extra";
 import path_0 from "path";
 import { createRequire } from "module";
@@ -26,10 +24,18 @@ import raw_body from "raw-body";
 import { createBrotliDecompress, createGunzip, createInflate } from "node:zlib";
 import node_process from "node:process";
 import { AsyncSeriesHook } from "@rspack/lite-tapable";
-import { setSDK, logger as rsdoctorLogger, logger_time, timeEnd, color, stringify } from "./630.js";
-import { InternalResolverPlugin, getYarnVersion, InternalPluginsPlugin, normalizeUserConfig, getRspackNativePlugin, InternalSummaryPlugin, InternalBundlePlugin, getNpmVersion, ensureModulesChunksGraphFn, getNodeVersion, fs_extra as external_fs_extra_fs_extra, handleBriefModeReport, processCompilerConfig, InternalLoaderPlugin, getCPUInfo, defaultPort, getPnpmVersion, FileSharding, createServer, getMemoryInfo, normalizeRspackUserOptions, defaultHost, InternalErrorReporterPlugin, getPortSync, InternalRulesPlugin, DevToolError, ProbeLoaderPlugin } from "./26.js";
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { setSDK, logger as rsdoctorLogger, logger_time, timeEnd, color, stringify, registerSDK } from "./630.js";
+import { InternalResolverPlugin, getYarnVersion, InternalPluginsPlugin, getRspackNativePlugin, InternalSummaryPlugin, ensureModulesChunksGraphFn, getNpmVersion, InternalBundlePlugin, getNodeVersion, fs_extra as external_fs_extra_fs_extra, handleBriefModeReport, processCompilerConfig, InternalLoaderPlugin, getCPUInfo, defaultPort, getPnpmVersion, FileSharding, createServer, getMemoryInfo, normalizeRspackUserOptions, defaultHost, InternalErrorReporterPlugin, getPortSync, InternalRulesPlugin, DevToolError, ProbeLoaderPlugin } from "./26.js";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
-var date, __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url)), apis_namespaceObject = {};
+var date, __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
+let __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
+__webpack_require__.add({
+    "launch-editor" (module) {
+        module.exports = __rspack_createRequire_require("launch-editor");
+    }
+});
+var apis_namespaceObject = {};
 __webpack_require__.r(apis_namespaceObject), __webpack_require__.d(apis_namespaceObject, {
     AlertsAPI: ()=>AlertsAPI,
     BundleDiffAPI: ()=>BundleDiffAPI,
@@ -1002,7 +1008,7 @@ class RsdoctorServer {
                 return;
             }
             try {
-                let launch = server_require('launch-editor'), responded = !1, safeEnd = (code, body)=>{
+                let launch = __webpack_require__("launch-editor"), responded = !1, safeEnd = (code, body)=>{
                     responded || (responded = !0, res.statusCode = code, res.end(body));
                 };
                 launch(file, editor, (_fileName, errorMessage)=>{
@@ -1532,157 +1538,268 @@ class RsdoctorSlaveServer extends RsdoctorServer {
 }
 let primary_id = 1;
 class RsdoctorPrimarySDK extends RsdoctorSDK {
-    constructor({ name, stage, controller, extraConfig, type }){
+    constructor({ name, displayName, compilerPath, parentCompilerPath, isChild, stage, controller, extraConfig, type }){
         super({
             name,
             root: controller.root,
             config: extraConfig
-        });
+        }), this.reportFileName = '';
         let lastSdk = controller.getLastSdk(), port = lastSdk ? lastSdk.server.port + 1 : extraConfig?.server?.port ?? this.server.port;
-        this.id = primary_id++, this.stage = 'number' == typeof stage ? stage : 1, this.extraConfig = extraConfig, this.parent = controller, this.server = new RsdoctorSlaveServer(this, port, {
+        this.id = primary_id++, this.stage = 'number' == typeof stage ? stage : 1, this.displayName = displayName || name, this.compilerPath = compilerPath || '', this.parentCompilerPath = parentCompilerPath, this.isChild = !!isChild, this.extraConfig = extraConfig, this.parent = controller, lastSdk && (this.server = new RsdoctorSlaveServer(this, port, {
             cors: extraConfig?.server?.cors
-        }), this.type = type, this.setName(name), this.clearSwitch();
-    }
-    clearSwitch() {
-        this.uploadPieces = new Promise((resolve)=>{
-            this.finishUploadPieceSwitch = resolve;
-        });
+        })), this.type = type, this.setName(name);
     }
     get isMaster() {
         return this.parent.master === this;
     }
     async writePieces() {
-        let { name, parent, isMaster, outputDir, finishUploadPieceSwitch } = this;
-        this.setOutputDir(isMaster ? outputDir : path_0.join(parent.master.outputDir, '.slaves', name.replace(/\s+/g, '-'))), await super.writePieces(this.getStoreData()), finishUploadPieceSwitch?.();
+        this.setOutputDir(this.parent.getCompilerOutputDir(this)), await super.writePieces(this.getStoreData());
     }
     async writeManifest() {
-        let { parent, cloudData, dependencies } = this;
-        dependencies?.length || await Promise.all(this.parent.slaves.filter((item)=>!item.dependencies?.length).map((item)=>item.uploadPieces)), cloudData && (cloudData.name = this.name, cloudData.series = parent.getSeriesData());
+        let { parent, cloudData } = this;
+        cloudData && parent.isMultiple && (cloudData.name = this.name, cloudData.series = parent.getSeriesData());
         let result = await super.writeManifest();
-        return this.clearSwitch(), result;
+        return await parent.refreshManifestSeries(), result;
+    }
+    async refreshManifestSeries() {
+        this.parent.isMultiple && this.cloudData && this.diskManifestPath && (this.cloudData.name = this.name, this.cloudData.series = this.parent.getSeriesData(), await super.writeManifest());
     }
     getSeriesData(serverUrl = !1) {
         return this.parent.getSeriesData(serverUrl);
     }
     setName(name) {
-        this._name = this.parent.hasName(name) ? `${name}-${primary_id}` : name;
+        let baseName = name || `compiler-${this.id}`;
+        if (!this.parent.hasName(baseName, this)) {
+            this._name = baseName;
+            return;
+        }
+        let suffix = 2;
+        for(; this.parent.hasName(`${baseName}-${suffix}`, this);)suffix += 1;
+        this._name = `${baseName}-${suffix}`;
     }
     getManifestData() {
         let data = super.getManifestData();
-        return data.name = this.name, data.series = this.getSeriesData(!0), data;
+        return this.parent.isMultiple && (data.name = this.name, data.series = this.getSeriesData(!0)), data;
+    }
+    addRsdoctorDataToHTML(storeData, htmlContent) {
+        let result = super.addRsdoctorDataToHTML(storeData, htmlContent);
+        if (!this.parent.isMultiple) return result;
+        let metadata = `<script>window.${Constants.WINDOW_RSDOCTOR_TAG}.name=${JSON.stringify(this.name)};window.${Constants.WINDOW_RSDOCTOR_TAG}.series=${JSON.stringify(this.parent.getBriefSeriesData(this))}</script>`;
+        return result.replace('</body>', `${metadata}</body>`);
     }
 }
 class RsdoctorSDKController {
     constructor(root = process.cwd()){
-        this.slaves = [], this.root = '', this.root = root;
+        this.slaves = [], this.activeSlaves = new Set(), this.outputDir = '', this.refreshManifestTask = Promise.resolve(), this.root = '', this.root = root;
     }
     get master() {
-        return this.slaves[0];
+        return this.getActiveSlaves()[0];
+    }
+    get isMultiple() {
+        return this.activeSlaves.size > 1;
     }
     getLastSdk() {
         return this.slaves[this.slaves.length - 1];
     }
-    hasName(name) {
-        return !!this.slaves.find((item)=>item.name === name);
+    hasName(name, exclude) {
+        return !!this.slaves.find((item)=>item !== exclude && item.name === name);
+    }
+    registerSlave(slave) {
+        this.activeSlaves.add(slave);
+    }
+    setOutputDir(slave, outputDir) {
+        slave === this.master && slave !== this.outputOwner && (this.outputDir = outputDir, this.outputOwner = slave, slave.setOutputDir(outputDir));
+    }
+    getCompilerOutputDir(slave) {
+        if (slave === this.master) return this.outputDir || slave.outputDir;
+        let rootOutputDir = this.outputDir || this.master?.outputDir || slave.outputDir;
+        if (slave.isChild) return node_path.join(rootOutputDir, '.slaves', slave.name.replace(/\s+/g, '-'));
+        let name = slave.name.replace(/[^a-zA-Z0-9_$-]+/g, '-').replace(/^-+|-+$/g, '') || `compiler-${slave.id}`;
+        return node_path.join(rootOutputDir, 'compilers', name);
     }
     getSeriesData(serverUrl = !1) {
-        return this.slaves.map((item)=>{
+        return this.getActiveSlaves().map((item)=>{
             let data = {
                 name: item.name,
-                path: item.diskManifestPath,
-                stage: item.stage
+                displayName: item.displayName,
+                path: item.reportFileName ? node_path.join(this.getCompilerOutputDir(item), item.reportFileName) : item.diskManifestPath || node_path.resolve(this.getCompilerOutputDir(item), Constants.RsdoctorOutputManifest),
+                stage: item.stage,
+                compilerPath: item.compilerPath,
+                parentCompilerPath: item.parentCompilerPath,
+                isChild: item.isChild
             };
             return serverUrl && (data.origin = item.server.origin), data;
         });
     }
-    createSlave({ name, stage, extraConfig, type }) {
+    getBriefSeriesData(current) {
+        let currentOutputDir = this.getCompilerOutputDir(current);
+        return this.getActiveSlaves().map((item)=>({
+                name: item.name,
+                path: node_path.relative(currentOutputDir, node_path.join(this.getCompilerOutputDir(item), item.reportFileName || 'rsdoctor-report.html')).split(node_path.sep).map((segment)=>encodeURIComponent(segment)).join('/'),
+                stage: item.stage
+            }));
+    }
+    createSlave({ name, displayName, compilerPath, parentCompilerPath, isChild, stage, extraConfig, type }) {
         let slave = new RsdoctorPrimarySDK({
             name,
-            stage,
+            displayName,
+            compilerPath,
+            parentCompilerPath,
+            isChild,
+            stage: 'number' == typeof stage ? stage : this.slaves.length,
             controller: this,
             extraConfig,
             type
         });
         return this.slaves.push(slave), this.slaves.sort((a, b)=>a.stage - b.stage), slave;
     }
+    refreshManifestSeries() {
+        return this.isMultiple ? (this.refreshManifestTask = this.refreshManifestTask.then(async ()=>{
+            for (let slave of this.getActiveSlaves())await slave.refreshManifestSeries();
+        }), this.refreshManifestTask) : Promise.resolve();
+    }
+    getActiveSlaves() {
+        return this.slaves.filter((item)=>this.activeSlaves.has(item));
+    }
 }
-let packageJson = external_node_module_createRequire(import.meta.url)(existsSync(new URL('../package.json', import.meta.url)) ? '../package.json' : '../../package.json'), pluginTapName = 'RsdoctorRspackPlugin', pluginTapPostOptions = {
+var package_namespaceObject = JSON.parse('{"name":"@rsdoctor/core","version":"2.0.0-beta.0","repository":{"type":"git","url":"https://github.com/web-infra-dev/rsdoctor","directory":"packages/core"},"license":"MIT","engines":{"node":">=22.18.0"},"main":"dist/index.js","types":"dist/index.d.ts","files":["dist","static"],"type":"module","exports":{".":{"types":"./dist/index.d.ts","default":"./dist/index.js"},"./proxy-loader":{"types":"./dist/proxy-loader.d.ts","default":"./dist/proxy-loader.js"}},"typesVersions":{"*":{".":["./dist/index.d.ts"],"proxy-loader":["./dist/proxy-loader.d.ts"]}},"scripts":{"dev":"npm run start","build":"rslib build","start":"rslib build -w","test":"rstest run"},"dependencies":{"@babel/code-frame":"7.26.2","@rspack/lite-tapable":"catalog:","@rsdoctor/shared":"workspace:*","@types/estree":"catalog:","acorn":"^8.10.0","acorn-import-attributes":"^1.9.5","acorn-walk":"8.3.5","browserslist-load-config":"^1.0.3","caniuse-lite":"^1.0.30001809","connect-next":"catalog:","envinfo":"7.21.0","fs-extra":"catalog:","get-port":"5.1.1","lines-and-columns":"2.0.4","open":"^11.0.0","raw-body":"3.0.2","rslog":"^2.1.3","semver":"^7.8.5","source-map":"catalog:","@rsdoctor/client":"workspace:*","cors":"2.8.6","launch-editor":"^2.14.1","sirv":"catalog:","ws":"8.21.3"},"devDependencies":{"@rsbuild/plugin-check-syntax":"catalog:","@rspack/core":"catalog:","@scripts/test-helper":"workspace:*","@types/babel__code-frame":"7.27.0","@types/envinfo":"7.8.4","@types/fs-extra":"catalog:","@types/node":"catalog:","@types/semver":"^7.8.0","babel-loader":"10.1.1","filesize":"catalog:","json-stream-stringify":"3.0.1","string-loader":"0.0.1","ts-loader":"^9.6.2","tslib":"catalog:","typescript":"catalog:","@types/cors":"2.8.19","@types/ws":"^8.18.1"},"peerDependencies":{"@rspack/core":"^2.0.0"},"peerDependenciesMeta":{"@rspack/core":{"optional":true}},"publishConfig":{"access":"public","registry":"https://registry.npmjs.org/"}}');
+let pluginTapName = 'RsdoctorRspackPlugin', pluginTapPostOptions = {
     name: pluginTapName,
     stage: 999
-}, hasGreeted = !1;
+}, pendingSessions = new Map(), hasGreeted = !1;
+class RsdoctorCompilerContext {
+    constructor(sdk, options){
+        this.sdk = sdk, this.options = options, this.name = pluginTapName, this.isRsdoctorPlugin = !0, this.modulesGraph = new ModuleGraph(), this.applied = !1;
+    }
+    apply() {}
+    ensureModulesChunksGraphApplied(compiler) {
+        ensureModulesChunksGraphFn(compiler, this);
+    }
+}
 class RsdoctorRspackPlugin {
     constructor(options){
-        this.name = pluginTapName, this.browserIsOpened = !1, this.afterPlugins = (compiler)=>{
+        if (this.name = pluginTapName, this.isRsdoctorPlugin = !0, this.compilerContexts = new WeakMap(), this.childPlugins = new Map(), this.appliedCompilerCount = 0, this.afterPlugins = (compiler, context = this.getCompilerContext(compiler))=>{
             logger_time('RsdoctorRspackPlugin.afterPlugins');
             try {
-                this.getRspackConfig(compiler);
+                this.getRspackConfig(compiler, context);
             } finally{
                 timeEnd('RsdoctorRspackPlugin.afterPlugins');
             }
-        }, this.done = async (compiler)=>{
+        }, this.done = async (compiler, context = this.getCompilerContext(compiler))=>{
             logger_time('RsdoctorRspackPlugin.done');
             try {
-                rsdoctorLogger.debug('[RsdoctorRspackPlugin] bootstrap(start) in done()'), await this.sdk.bootstrap(), rsdoctorLogger.debug('[RsdoctorRspackPlugin] bootstrap(end) in done()'), this.sdk.addClientRoutes([
+                rsdoctorLogger.debug('[RsdoctorRspackPlugin] bootstrap(start) in done()'), await context.bootstrapTask, rsdoctorLogger.debug('[RsdoctorRspackPlugin] bootstrap(end) in done()'), context.sdk.addClientRoutes([
                     Manifest.RsdoctorManifestClientRoutes.Overall
-                ]), this.outsideInstance && 'parent' in this.sdk && this.sdk.parent.master.setOutputDir(path_0.resolve(this.options.output.reportDir || compiler.outputPath, this.options.output.mode === SDK.IMode[SDK.IMode.brief] ? '' : `./${Constants.RsdoctorOutputFolder}`)), this.sdk.setOutputDir(path_0.resolve(this.options.output.reportDir || compiler.outputPath, this.options.output.mode === SDK.IMode[SDK.IMode.brief] ? '' : `./${Constants.RsdoctorOutputFolder}`)), await this.sdk.writeStore(), this.options.disableClientServer || (this.options.output.mode === SDK.IMode[SDK.IMode.brief] ? await handleBriefModeReport(this.sdk, this.options, this.options.disableClientServer) : await this.sdk.server.openClientPage('homepage')), (this.options.disableClientServer || this.options.output.mode === SDK.IMode[SDK.IMode.brief] && Array.isArray(this.options.output.options?.type) && 1 === this.options.output.options.type.length && 'json' === this.options.output.options.type[0]) && await this.sdk.dispose();
+                ]), context.sdk instanceof RsdoctorPrimarySDK ? context.sdk.setOutputDir(context.sdk.parent.getCompilerOutputDir(context.sdk)) : context.sdk.setOutputDir(this.getOutputDir(compiler)), await context.sdk.writeStore();
+                let isPrimaryCompiler = !(context.sdk instanceof RsdoctorPrimarySDK) || context.sdk.isMaster;
+                !this.options.disableClientServer && isPrimaryCompiler && (this.options.output.mode === SDK.IMode[SDK.IMode.brief] ? await handleBriefModeReport(context.sdk, this.options, this.options.disableClientServer) : await context.sdk.server.openClientPage('homepage')), this.shouldDisposeSDK() && await context.sdk.dispose();
             } finally{
                 timeEnd('RsdoctorRspackPlugin.done');
             }
-        }, this.options = normalizeRspackUserOptions(Object.assign(options || {}, {
+        }, this.childDone = async (compiler, context)=>{
+            await context.bootstrapTask, context.sdk.addClientRoutes([
+                Manifest.RsdoctorManifestClientRoutes.Overall
+            ]), context.sdk instanceof RsdoctorPrimarySDK ? context.sdk.setOutputDir(context.sdk.parent.getCompilerOutputDir(context.sdk)) : context.sdk.setOutputDir(this.getOutputDir(compiler)), await context.sdk.writeStore(), this.shouldDisposeSDK() && await context.sdk.dispose();
+        }, this.childOptions = {
+            ...options,
             supports: {
                 ...options?.supports
             }
-        }));
-        let { port, server, output, innerClientPath, printLog, sdkInstance } = this.options;
-        this.sdk = this.options.sdkInstance ?? new RsdoctorSDK({
-            port,
-            name: pluginTapName,
-            root: process.cwd(),
-            type: output.reportCodeType,
-            config: {
-                innerClientPath,
-                printLog,
-                server,
-                mode: output.mode ? output.mode : void 0,
-                brief: output.mode === SDK.IMode[SDK.IMode.brief] && output.options || void 0,
-                features: {
-                    treeShaking: this.options.features.treeShaking
-                }
+        }, this.options = normalizeRspackUserOptions(this.childOptions), this.outsideInstance = !!this.options.sdkInstance, this.defaultName = options?.name || pluginTapName, this.defaultStage = options?.stage, this.options.sdkInstance) {
+            this.options.sdkInstance instanceof RsdoctorPrimarySDK && (this.controller = this.options.sdkInstance.parent), this.primaryContext = new RsdoctorCompilerContext(this.options.sdkInstance, this.options);
+            return;
+        }
+        this.sessionLease = function(options) {
+            if (!options.multiCompiler.enabled) return {
+                controller: new RsdoctorSDKController(),
+                release () {}
+            };
+            let key = function(options) {
+                let root = process.cwd(), { group } = options.multiCompiler;
+                return group ? [
+                    'group',
+                    root,
+                    group
+                ].join('\0') : [
+                    'auto',
+                    root,
+                    options.output.mode,
+                    options.output.reportDir,
+                    options.server.port ?? options.port ?? ''
+                ].join('\0');
+            }(options), session = pendingSessions.get(key);
+            if (!session) {
+                let controller = new RsdoctorSDKController(), timer = setTimeout(()=>{
+                    pendingSessions.get(key)?.controller === controller && pendingSessions.delete(key);
+                }, 0);
+                timer.unref?.(), session = {
+                    controller,
+                    timer
+                }, pendingSessions.set(key, session);
             }
-        }), this.outsideInstance = !!sdkInstance, this.modulesGraph = new ModuleGraph(), this.isRsdoctorPlugin = !0;
+            let { controller } = session;
+            return {
+                controller,
+                release () {
+                    let current = pendingSessions.get(key);
+                    current?.controller === controller && (clearTimeout(current.timer), pendingSessions.delete(key));
+                }
+            };
+        }(this.options), this.controller = this.sessionLease.controller, this.primaryContext = this.createCompilerContext(this.defaultStage);
+    }
+    get sdk() {
+        return this.primaryContext.sdk;
+    }
+    get modulesGraph() {
+        return this.primaryContext.modulesGraph;
+    }
+    get _bootstrapTask() {
+        return this.primaryContext.bootstrapTask;
+    }
+    getCompilerSDK(name) {
+        return this.sdk.name === name ? this.sdk : this.sdk instanceof RsdoctorPrimarySDK ? this.sdk.parent.slaves.find((sdk)=>sdk.name === name) : void 0;
     }
     apply(compiler) {
-        logger_time('RsdoctorRspackPlugin.apply');
-        try {
-            hasGreeted || compiler.isChild() || (hasGreeted = !0, rsdoctorLogger.greet(`
-        \nRsdoctor v${packageJson.version}\n`)), this._bootstrapTask || (this._bootstrapTask = this.sdk.bootstrap()), compiler.options.name && this.sdk.setName(compiler.options.name), setSDK(this.sdk), compiler.hooks.afterPlugins.tap(pluginTapPostOptions, this.afterPlugins.bind(this, compiler)), compiler.hooks.done.tapPromise({
-                ...pluginTapPostOptions,
-                stage: pluginTapPostOptions.stage + 100
-            }, this.done.bind(this, compiler)), new InternalSummaryPlugin(this).apply(compiler), this.options.features.loader && (new ProbeLoaderPlugin().apply(compiler), this.sdk.addClientRoutes([
-                Manifest.RsdoctorManifestClientRoutes.Loaders
-            ]), Loader.isVue(compiler) || new InternalLoaderPlugin(this).apply(compiler)), this.options.features.plugins && new InternalPluginsPlugin(this).apply(compiler), this.options.features.bundle && new InternalBundlePlugin(this).apply(compiler), this.options.features.resolver && new InternalResolverPlugin(this).apply(compiler), new InternalRulesPlugin(this).apply(compiler), new InternalErrorReporterPlugin(this).apply(compiler);
-            let RsdoctorRspackNativePlugin = getRspackNativePlugin(compiler);
-            rsdoctorLogger.debug('[RspackNativePlugin] Enabled'), new RsdoctorRspackNativePlugin({
-                moduleGraphFeatures: !0,
-                chunkGraphFeatures: !0,
-                sourceMapFeatures: {
-                    cheap: !1,
-                    module: !1
-                }
-            }).apply(compiler);
-        } finally{
-            timeEnd('RsdoctorRspackPlugin.apply');
+        let context = this.getCompilerContext(compiler);
+        if (!context.applied) {
+            context.applied = !0, logger_time('RsdoctorRspackPlugin.apply');
+            try {
+                hasGreeted || compiler.isChild() || (hasGreeted = !0, rsdoctorLogger.greet(`
+        \nRsdoctor v${package_namespaceObject.version}\n`)), this.releasePendingSessionOnRun(compiler), context.bootstrapTask || (context.bootstrapTask = context.sdk.bootstrap());
+                let compilerName = compiler.name || compiler.options.name || (1 === this.appliedCompilerCount ? this.defaultName : `${this.defaultName}-${this.appliedCompilerCount}`);
+                compiler.isChild() || context.sdk.setName(compilerName), context.sdk instanceof RsdoctorPrimarySDK && (compiler.isChild() || (context.sdk.displayName = compiler.name || compiler.options.name || (1 === this.appliedCompilerCount ? 'Main compiler' : compilerName)), 'dependencies' in compiler.options && (context.sdk.dependencies = compiler.options.dependencies), context.sdk.parent.registerSlave(context.sdk), context.sdk.parent.setOutputDir(context.sdk, this.getOutputDir(compiler)), this.options.output.mode === SDK.IMode[SDK.IMode.brief] && (context.sdk.reportFileName = this.getBriefReportFileName())), compiler.isChild() ? registerSDK(context.sdk) : setSDK(context.sdk), this.applyChildCompilerSupport(compiler, context), compiler.isChild() ? (this.getRspackConfig(compiler, context), compiler.hooks.afterCompile.tapPromise({
+                    ...pluginTapPostOptions,
+                    stage: pluginTapPostOptions.stage + 100
+                }, ()=>this.childDone(compiler, context))) : (compiler.hooks.afterPlugins.tap(pluginTapPostOptions, ()=>this.afterPlugins(compiler, context)), compiler.hooks.done.tapPromise({
+                    ...pluginTapPostOptions,
+                    stage: pluginTapPostOptions.stage + 100
+                }, ()=>this.done(compiler, context))), new InternalSummaryPlugin(context).apply(compiler), this.options.features.loader && (compiler.isChild() || new ProbeLoaderPlugin().apply(compiler), context.sdk.addClientRoutes([
+                    Manifest.RsdoctorManifestClientRoutes.Loaders
+                ]), Loader.isVue(compiler) || new InternalLoaderPlugin(context).apply(compiler)), this.options.features.plugins && new InternalPluginsPlugin(context).apply(compiler), this.options.features.bundle && new InternalBundlePlugin(context).apply(compiler), this.options.features.resolver && new InternalResolverPlugin(context).apply(compiler), new InternalRulesPlugin(context).apply(compiler), new InternalErrorReporterPlugin(context).apply(compiler);
+                let RsdoctorRspackNativePlugin = getRspackNativePlugin(compiler);
+                rsdoctorLogger.debug('[RspackNativePlugin] Enabled'), new RsdoctorRspackNativePlugin({
+                    moduleGraphFeatures: !0,
+                    chunkGraphFeatures: !0,
+                    sourceMapFeatures: {
+                        cheap: !1,
+                        module: !1
+                    }
+                }).apply(compiler);
+            } finally{
+                timeEnd('RsdoctorRspackPlugin.apply');
+            }
         }
     }
     ensureModulesChunksGraphApplied(compiler) {
-        ensureModulesChunksGraphFn(compiler, this);
+        this.getCompilerContext(compiler).ensureModulesChunksGraphApplied(compiler);
     }
-    getRspackConfig(compiler) {
+    getRspackConfig(compiler, context = this.getCompilerContext(compiler)) {
         logger_time('RsdoctorRspackPlugin.getRspackConfig');
         try {
-            if (compiler.isChild()) return;
-            let configuration = processCompilerConfig(compiler.options), { rspackVersion } = compiler.rspack;
-            this.sdk.reportConfiguration({
+            let configuration = processCompilerConfig(compiler.options);
+            compiler.isChild() && compiler.name && (configuration.name = compiler.name);
+            let { rspackVersion } = compiler.rspack;
+            context.sdk.reportConfiguration({
                 name: 'rspack',
                 version: rspackVersion || 'unknown',
                 config: configuration,
@@ -1692,32 +1809,98 @@ class RsdoctorRspackPlugin {
             timeEnd('RsdoctorRspackPlugin.getRspackConfig');
         }
     }
-}
-class RsdoctorRspackMultiplePlugin extends RsdoctorRspackPlugin {
-    constructor(options = {}){
-        let controller = (()=>{
-            if (globalController) return globalController;
-            let controller = new RsdoctorSDKController();
-            return globalController = controller, controller;
-        })(), normallizedOptions = normalizeUserConfig(options), instance = controller.createSlave({
-            name: options.name || 'Builder',
-            stage: options.stage,
+    createCompilerContext(stage) {
+        let controller = this.controller, { output, innerClientPath, printLog, server, features } = this.options;
+        return new RsdoctorCompilerContext(controller.createSlave({
+            name: this.defaultName,
+            stage,
             extraConfig: {
-                innerClientPath: normallizedOptions.innerClientPath,
-                printLog: normallizedOptions.printLog,
-                server: normallizedOptions.server,
-                mode: normallizedOptions.output.mode ? normallizedOptions.output.mode : void 0,
-                brief: normallizedOptions.output.mode === SDK.IMode[SDK.IMode.brief] && normallizedOptions.output.options || void 0
+                innerClientPath,
+                printLog,
+                server,
+                mode: output.mode || void 0,
+                brief: output.mode === SDK.IMode[SDK.IMode.brief] && output.options || void 0,
+                features: {
+                    treeShaking: features.treeShaking
+                }
             },
-            type: normallizedOptions.output.reportCodeType
+            type: output.reportCodeType
+        }), this.options);
+    }
+    getCompilerContext(compiler) {
+        let context, existing = this.compilerContexts.get(compiler);
+        if (existing) return existing;
+        if (0 === this.appliedCompilerCount) context = this.primaryContext;
+        else {
+            if (!this.controller) throw Error('[RsdoctorRspackPlugin] A fixed sdkInstance cannot be shared by multiple compilers. Create one plugin instance per compiler with a separate sdkInstance.');
+            if (!this.options.multiCompiler.enabled) throw Error('[RsdoctorRspackPlugin] This plugin instance was applied to multiple compilers while multiCompiler is disabled.');
+            context = this.createCompilerContext();
+        }
+        return this.appliedCompilerCount += 1, this.compilerContexts.set(compiler, context), context;
+    }
+    getOutputDir(compiler) {
+        return node_path.resolve(this.options.output.reportDir || compiler.options.output?.path || compiler.outputPath, this.options.output.mode === SDK.IMode[SDK.IMode.brief] ? '' : `./${Constants.RsdoctorOutputFolder}`);
+    }
+    getBriefReportFileName() {
+        let options = this.options.output.options;
+        return options.type?.includes('html') ? options.htmlOptions?.reportHtmlName || 'rsdoctor-report.html' : options.jsonOptions?.fileName || 'rsdoctor-data.json';
+    }
+    applyChildCompilerSupport(compiler, context) {
+        compiler.hooks.thisCompilation.tap({
+            name: `${pluginTapName}:childCompiler`,
+            stage: -999
+        }, (compilation)=>{
+            compilation.hooks.childCompiler.tap(`${pluginTapName}:childCompiler`, (childCompiler, compilerName, compilerIndex)=>{
+                this.registerChildCompiler(compiler, childCompiler, compilerName, compilerIndex, context);
+            });
         });
-        super({
-            ...options,
-            sdkInstance: instance
-        }), this.controller = controller;
     }
-    apply(compiler) {
-        'dependencies' in compiler.options && (this.sdk.dependencies = compiler.options.dependencies), super.apply(compiler);
+    registerChildCompiler(parentCompiler, childCompiler, compilerName, compilerIndex, parentContext) {
+        if (!(parentContext.sdk instanceof RsdoctorPrimarySDK)) return;
+        let parentSDK = parentContext.sdk, controller = parentSDK.parent, compilerPath = childCompiler.compilerPath || `${parentCompiler.compilerPath}${compilerName}|${compilerIndex}|`, childKey = `${parentSDK.id}:${compilerPath}`, registeredChild = this.childPlugins.get(childKey);
+        if (registeredChild?.compiler === childCompiler) return;
+        controller.setOutputDir(parentSDK, this.getOutputDir(parentCompiler));
+        let childSDK = (()=>{
+            if (registeredChild) return registeredChild.sdk;
+            let safeCompilerPath = compilerPath.replace(/[^a-zA-Z0-9._-]+/g, '-') || `${compilerName}-${compilerIndex}`, displayName = childCompiler.name || compilerName || `Child compiler ${compilerIndex}`, sdk = controller.createSlave({
+                name: `child-${safeCompilerPath}`,
+                displayName,
+                compilerPath,
+                parentCompilerPath: parentCompiler.compilerPath || '',
+                isChild: !0,
+                stage: parentSDK.stage + (controller.slaves.length + 1) / 1000,
+                extraConfig: parentSDK.extraConfig,
+                type: parentSDK.type
+            });
+            return sdk.dependencies = [
+                parentSDK.name
+            ], sdk;
+        })();
+        this.removeInheritedRsdoctorTaps(childCompiler);
+        let childPlugin = new RsdoctorRspackPlugin({
+            ...this.childOptions,
+            sdkInstance: childSDK
+        });
+        this.childPlugins.set(childKey, {
+            compiler: childCompiler,
+            sdk: childSDK
+        }), childPlugin.apply(childCompiler);
+    }
+    removeInheritedRsdoctorTaps(compiler) {
+        for (let hook of Object.values(compiler.hooks))Array.isArray(hook.taps) && (hook.taps = hook.taps.filter((tap)=>tap.name !== pluginTapName && !tap.name.startsWith(`${pluginTapName}:`)));
+    }
+    shouldDisposeSDK() {
+        return this.options.disableClientServer || this.options.output.mode === SDK.IMode[SDK.IMode.brief] && Array.isArray(this.options.output.options?.type) && 1 === this.options.output.options.type.length && 'json' === this.options.output.options.type[0];
+    }
+    releasePendingSessionOnRun(compiler) {
+        if (!this.sessionLease) return;
+        let release = this.sessionLease.release;
+        compiler.hooks.beforeRun.tap(pluginTapName, release), compiler.hooks.watchRun.tap(pluginTapName, release);
+    }
+}
+class RsdoctorRspackMultiplePlugin extends RsdoctorRspackPlugin {
+    constructor(options = {}){
+        super(options);
     }
 }
 export { Linter, LinterRule, LinterType, defineRule, rules } from "./26.js";

package/dist/inner-plugins/plugins/errors.d.ts

@@ -5,6 +5,7 @@ export declare class InternalErrorReporterPlugin<T extends Plugin.BaseCompiler>
     readonly name = "error-reporter";
     apply(compiler: T): void;
     done: (stats: Plugin.BaseStats) => Promise<void>;
+    afterCompile: (compilation: Plugin.BaseCompilation) => Promise<void>;
     handleBundlerError(err: Plugin.BuildError, category: Rule.RuleMessageCategory, level: keyof typeof Err.ErrorLevel): DevToolError;
     reportWarnings(warnings: Plugin.BuildError[]): Promise<void>;
     reportErrors(errors: Plugin.BuildWarning[]): Promise<void>;

package/dist/inner-plugins/plugins/plugins.d.ts

@@ -4,5 +4,5 @@ export declare class InternalPluginsPlugin<T extends Plugin.BaseCompiler> extend
     readonly name = "plugins";
     apply(compiler: Plugin.BaseCompiler): void;
     afterPlugins: (compiler: Plugin.BaseCompiler) => void;
-    compilation: (compilation: Plugin.BaseCompilation) => void;
+    compilation: (compiler: Plugin.BaseCompiler, compilation: Plugin.BaseCompilation) => void;
 }

package/dist/inner-plugins/plugins/summary.d.ts

@@ -5,10 +5,11 @@ export declare class InternalSummaryPlugin<T extends Plugin.BaseCompiler> extend
     private times;
     private preTimes;
     private postTimes;
+    private readonly createdAt;
     apply(compiler: T): void;
     private mark;
-    beforeCompile: () => Promise<void>;
-    afterCompile: (compilation: Plugin.BaseCompilation) => Promise<void>;
+    beforeCompile: (compiler: T) => Promise<void>;
+    afterCompile: (compiler: T, compilation: Plugin.BaseCompilation) => Promise<void>;
     done: (compiler: T) => Promise<void>;
     private report;
 }

package/dist/inner-plugins/utils/sdk.d.ts

@@ -4,4 +4,5 @@ declare global {
     var __rsdoctor_sdk__: SDK.RsdoctorBuilderSDKInstance | undefined;
 }
 export declare function setSDK(t: SDK.RsdoctorBuilderSDKInstance): void;
-export declare function getSDK(builderName?: string): SDK.RsdoctorBuilderSDKInstance | undefined;
+export declare function registerSDK(t: SDK.RsdoctorBuilderSDKInstance, asDefault?: boolean): void;
+export declare function getSDK(compilerId?: string): SDK.RsdoctorBuilderSDKInstance | undefined;

package/dist/rspack-plugin/multiple.d.ts

@@ -1,8 +1,10 @@
+import type { Linter } from '@rsdoctor/shared/types';
 import type { RsdoctorMultiplePluginOptions } from '../types/index.js';
-import { type Linter, type Plugin } from '@rsdoctor/shared/types';
 import { RsdoctorRspackPlugin } from './plugin.js';
+/**
+ * @deprecated Use {@link RsdoctorRspackPlugin}. Multi-compiler builds are now
+ * detected and isolated automatically.
+ */
 export declare class RsdoctorRspackMultiplePlugin<Rules extends Linter.ExtendRuleData[]> extends RsdoctorRspackPlugin<Rules> {
-    private controller;
     constructor(options?: RsdoctorMultiplePluginOptions<Rules>);
-    apply(compiler: Plugin.BaseCompilerType<'rspack'>): void;
 }

package/dist/rspack-plugin/plugin.d.ts

@@ -1,25 +1,51 @@
-import type { RsdoctorRspackPluginInstance, RsdoctorRspackPluginOptions, RsdoctorRspackPluginOptionsNormalized } from '../types/index.js';
 import { RsdoctorPrimarySDK } from '../sdk/index.js';
+import type { RsdoctorRspackPluginInstance, RsdoctorRspackPluginOptions, RsdoctorRspackPluginOptionsNormalized } from '../types/index.js';
 import { Linter, Plugin, SDK } from '@rsdoctor/shared/types';
+declare class RsdoctorCompilerContext implements RsdoctorRspackPluginInstance<Linter.ExtendRuleData[]> {
+    readonly sdk: SDK.RsdoctorBuilderSDKInstance;
+    readonly options: RsdoctorRspackPluginOptionsNormalized<Linter.ExtendRuleData[]>;
+    readonly name = "RsdoctorRspackPlugin";
+    readonly isRsdoctorPlugin = true;
+    readonly modulesGraph: SDK.ModuleGraphInstance;
+    bootstrapTask?: Promise<unknown>;
+    applied: boolean;
+    constructor(sdk: SDK.RsdoctorBuilderSDKInstance, options: RsdoctorRspackPluginOptionsNormalized<Linter.ExtendRuleData[]>);
+    apply(): void;
+    ensureModulesChunksGraphApplied(compiler: Plugin.BaseCompilerType<'rspack'>): void;
+}
 export declare class RsdoctorRspackPlugin<Rules extends Linter.ExtendRuleData[]> implements RsdoctorRspackPluginInstance<Rules> {
     readonly name = "RsdoctorRspackPlugin";
-    readonly sdk: SDK.RsdoctorBuilderSDKInstance | RsdoctorPrimarySDK;
-    readonly isRsdoctorPlugin: boolean;
-    _bootstrapTask: Promise<unknown>;
-    protected browserIsOpened: boolean;
-    modulesGraph: SDK.ModuleGraphInstance;
-    options: RsdoctorRspackPluginOptionsNormalized<Rules>;
-    outsideInstance: boolean;
+    readonly isRsdoctorPlugin = true;
+    readonly options: RsdoctorRspackPluginOptionsNormalized<Rules>;
+    readonly outsideInstance: boolean;
+    private readonly childOptions;
+    private readonly defaultName;
+    private readonly defaultStage?;
+    private readonly controller?;
+    private readonly sessionLease?;
+    private readonly primaryContext;
+    private readonly compilerContexts;
+    private readonly childPlugins;
+    private appliedCompilerCount;
     constructor(options?: RsdoctorRspackPluginOptions<Rules>);
+    get sdk(): SDK.RsdoctorBuilderSDKInstance;
+    get modulesGraph(): SDK.ModuleGraphInstance;
+    get _bootstrapTask(): Promise<unknown>;
+    getCompilerSDK(name: string): SDK.RsdoctorBuilderSDKInstance | RsdoctorPrimarySDK | undefined;
     apply(compiler: unknown): unknown;
-    /**
-     * @description Generate ModuleGraph and ChunkGraph from the Rspack native plugin.
-     * @param {Compiler} compiler
-     * @return {*}
-     * @memberof RsdoctorRspackPlugin
-     */
     ensureModulesChunksGraphApplied(compiler: Plugin.BaseCompilerType<'rspack'>): void;
-    afterPlugins: (compiler: Plugin.BaseCompilerType<'rspack'>) => void;
-    done: (compiler: Plugin.BaseCompilerType<'rspack'>) => Promise<void>;
-    getRspackConfig(compiler: Plugin.BaseCompilerType<'rspack'>): void;
+    afterPlugins: (compiler: Plugin.BaseCompilerType<'rspack'>, context?: RsdoctorCompilerContext) => void;
+    done: (compiler: Plugin.BaseCompilerType<'rspack'>, context?: RsdoctorCompilerContext) => Promise<void>;
+    getRspackConfig(compiler: Plugin.BaseCompilerType<'rspack'>, context?: RsdoctorCompilerContext): void;
+    private createCompilerContext;
+    private getCompilerContext;
+    private getOutputDir;
+    private getBriefReportFileName;
+    private applyChildCompilerSupport;
+    private registerChildCompiler;
+    private removeInheritedRsdoctorTaps;
+    private childDone;
+    private shouldDisposeSDK;
+    private releasePendingSessionOnRun;
 }
+export {};

package/dist/rspack-plugin/session.d.ts

@@ -0,0 +1,20 @@
+import { RsdoctorSDKController } from '../sdk/index.js';
+export interface RsdoctorBuildSessionOptions {
+    multiCompiler: {
+        enabled: boolean;
+        group?: string;
+    };
+    output: {
+        mode: string;
+        reportDir: string;
+    };
+    server: {
+        port?: number;
+    };
+    port?: number;
+}
+export interface RsdoctorBuildSessionLease {
+    controller: RsdoctorSDKController;
+    release(): void;
+}
+export declare function acquireBuildSession(options: RsdoctorBuildSessionOptions): RsdoctorBuildSessionLease;

package/dist/sdk/multiple/controller.d.ts

@@ -2,11 +2,22 @@ import { Manifest } from '@rsdoctor/shared/types';
 import { RsdoctorPrimarySDK } from './primary.js';
 export declare class RsdoctorSDKController {
     readonly slaves: RsdoctorPrimarySDK[];
+    private readonly activeSlaves;
+    private outputDir;
+    private outputOwner?;
+    private refreshManifestTask;
     root: string;
     constructor(root?: string);
     get master(): RsdoctorPrimarySDK;
+    get isMultiple(): boolean;
     getLastSdk(): RsdoctorPrimarySDK;
-    hasName(name: string): boolean;
+    hasName(name: string, exclude?: RsdoctorPrimarySDK): boolean;
+    registerSlave(slave: RsdoctorPrimarySDK): void;
+    setOutputDir(slave: RsdoctorPrimarySDK, outputDir: string): void;
+    getCompilerOutputDir(slave: RsdoctorPrimarySDK): string;
     getSeriesData(serverUrl?: boolean): Manifest.RsdoctorManifestSeriesData[];
-    createSlave({ name, stage, extraConfig, type, }: Omit<ConstructorParameters<typeof RsdoctorPrimarySDK>[0], 'controller'>): RsdoctorPrimarySDK;
+    getBriefSeriesData(current: RsdoctorPrimarySDK): Manifest.RsdoctorManifestSeriesData[];
+    createSlave({ name, displayName, compilerPath, parentCompilerPath, isChild, stage, extraConfig, type, }: Omit<ConstructorParameters<typeof RsdoctorPrimarySDK>[0], 'controller'>): RsdoctorPrimarySDK;
+    refreshManifestSeries(): Promise<void>;
+    private getActiveSlaves;
 }

package/dist/sdk/multiple/primary.d.ts

@@ -3,6 +3,10 @@ import { RsdoctorSDK } from '../sdk/index.js';
 import type { RsdoctorSDKController } from './controller.js';
 interface RsdoctorSlaveSDKOptions {
     name: string;
+    displayName?: string;
+    compilerPath?: string;
+    parentCompilerPath?: string;
+    isChild?: boolean;
     /**
      * use to sort for display in the client page.
      * the smaller the front.
@@ -17,16 +21,20 @@ export declare class RsdoctorPrimarySDK extends RsdoctorSDK implements SDK.Rsdoc
     id: number;
     parent: RsdoctorSDKController;
     readonly stage: number;
+    displayName: string;
+    readonly compilerPath: string;
+    readonly parentCompilerPath?: string;
+    readonly isChild: boolean;
     dependencies: Array<string> | undefined;
-    private uploadPieces;
-    private finishUploadPieceSwitch;
-    constructor({ name, stage, controller, extraConfig, type, }: RsdoctorSlaveSDKOptions);
-    private clearSwitch;
+    reportFileName: string;
+    constructor({ name, displayName, compilerPath, parentCompilerPath, isChild, stage, controller, extraConfig, type, }: RsdoctorSlaveSDKOptions);
     get isMaster(): boolean;
     protected writePieces(): Promise<void>;
     protected writeManifest(): Promise<string>;
+    refreshManifestSeries(): Promise<void>;
     getSeriesData(serverUrl?: boolean): Manifest.RsdoctorManifestSeriesData[];
     setName(name: string): void;
     getManifestData(): Manifest.RsdoctorManifestWithShardingFiles;
+    addRsdoctorDataToHTML(storeData: SDK.BuilderStoreData, htmlContent: string): string;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsdoctor/core",
-  "version": "2.0.0-alpha.2",
+  "version": "2.0.0-beta.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/web-infra-dev/rsdoctor",
@@ -45,8 +45,8 @@
     "acorn-import-attributes": "^1.9.5",
     "acorn-walk": "8.3.5",
     "browserslist-load-config": "^1.0.3",
-    "caniuse-lite": "^1.0.30001792",
-    "connect": "3.7.0",
+    "caniuse-lite": "^1.0.30001809",
+    "connect-next": "4.0.3",
     "envinfo": "7.21.0",
     "fs-extra": "^11.1.1",
     "get-port": "5.1.1",
@@ -59,19 +59,18 @@
     "cors": "2.8.6",
     "launch-editor": "^2.14.1",
     "sirv": "3.0.2",
-    "ws": "8.21.1",
-    "@rsdoctor/shared": "2.0.0-alpha.2",
-    "@rsdoctor/client": "2.0.0-alpha.2"
+    "ws": "8.21.3",
+    "@rsdoctor/shared": "2.0.0-beta.0",
+    "@rsdoctor/client": "2.0.0-beta.0"
   },
   "devDependencies": {
     "@rsbuild/plugin-check-syntax": "^1.6.1",
-    "@rspack/core": "^2.1.7",
+    "@rspack/core": "^2.1.8",
     "@types/babel__code-frame": "7.27.0",
-    "@types/connect": "3.4.38",
     "@types/envinfo": "7.8.4",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^24.12.3",
-    "@types/semver": "^7.7.1",
+    "@types/semver": "^7.8.0",
     "babel-loader": "10.1.1",
     "filesize": "^11.0.22",
     "json-stream-stringify": "3.0.1",