@rsdoctor/core 2.0.0-alpha.1 → 2.0.0-alpha.2

package/dist/index.js

@@ -1,7 +1,1725 @@
-import "node:module";
-import * as __rspack_external__inner_plugins_index_js_64c09f4a from "./inner-plugins/index.js";
-export * from "./build-utils/index.js";
-export * from "./types/index.js";
-export { RsdoctorRspackPlugin } from "./rspack-plugin/plugin.js";
-export { RsdoctorRspackMultiplePlugin } from "./rspack-plugin/multiple.js";
-export { __rspack_external__inner_plugins_index_js_64c09f4a as InnerPlugins };
+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 fs_extra from "fs-extra";
+import path_0 from "path";
+import { createRequire } from "module";
+import { Client, Constants, Manifest, SDK } from "@rsdoctor/shared/types";
+import { SourceMapConsumer } from "source-map";
+import { ChunkGraph, ModuleGraph, PackageGraph } from "@rsdoctor/shared/graph";
+import sirv from "sirv";
+import { Algorithm, Bundle, Data, Loader, Lodash, decycle } from "@rsdoctor/shared/common-browser";
+import fs from "fs";
+import os_0 from "os";
+import assert from "assert";
+import cors from "cors";
+import { PassThrough } from "stream";
+import ws, { WebSocketServer } from "ws";
+import { isIP } from "node:net";
+import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
+import { exec } from "node:child_process";
+import node_path, { join, dirname as __rspack_dirname } from "node:path";
+import { promisify } from "node:util";
+import { randomBytes } from "crypto";
+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 { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+var date, __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url)), apis_namespaceObject = {};
+__webpack_require__.r(apis_namespaceObject), __webpack_require__.d(apis_namespaceObject, {
+    AlertsAPI: ()=>AlertsAPI,
+    BundleDiffAPI: ()=>BundleDiffAPI,
+    DataAPI: ()=>DataAPI,
+    FileSystemAPI: ()=>FileSystemAPI,
+    GraphAPI: ()=>GraphAPI,
+    LoaderAPI: ()=>LoaderAPI,
+    PluginAPI: ()=>PluginAPI,
+    ProjectAPI: ()=>ProjectAPI,
+    RendererAPI: ()=>RendererAPI,
+    ResolverAPI: ()=>ResolverAPI
+});
+class SocketAPILoader {
+    constructor(options){
+        this.options = options, this.dataLoader = new Data.APIDataLoader(this);
+    }
+    async loadManifest() {
+        return this.options.sdk.getManifestData();
+    }
+    async loadData(key) {
+        let data = this.options.sdk.getStoreData(), res = data[key];
+        return key.includes('.') && (res = key.split('.').reduce((t, k)=>t[k], data)), res;
+    }
+    get loadAPIData() {
+        return this.dataLoader.loadAPI;
+    }
+}
+let DEFAULT_ALLOWED_CORS_ORIGINS = /^https?:\/\/(?:(?:[^:]+\.)?localhost|127\.0\.0\.1|\[::1\])(?::\d+)?$/, LOCAL_HOSTNAMES = /^(?:localhost|[^:]+\.localhost)$/;
+function getHostnameFromHost(host) {
+    if (host.startsWith('[')) {
+        let endIndex = host.indexOf(']');
+        return -1 === endIndex ? '' : host.slice(1, endIndex);
+    }
+    return host.split(':')[0];
+}
+function isAllowedRequestHost(host) {
+    if ('string' != typeof host) return !1;
+    let hostname = getHostnameFromHost(host).toLowerCase();
+    return LOCAL_HOSTNAMES.test(hostname) || 0 !== isIP(hostname);
+}
+class Socket {
+    constructor(options){
+        this.options = options, this.clients = new Set(), this.map = new Map(), this.clientSubscriptions = new Map(), this.loader = new SocketAPILoader({
+            sdk: options.sdk
+        });
+    }
+    bootstrap() {
+        this.server = new WebSocketServer({
+            server: this.options.server,
+            verifyClient: ({ req })=>{
+                var url, token;
+                return isAllowedRequestHost(req.headers.host || req.headers[':authority']) && (url = req.url, token = this.options.token, !!url && new URL(url, 'http://localhost').searchParams.get('token') === token);
+            }
+        }), this.server.on('connection', (client)=>{
+            this.attachClient(client);
+        });
+    }
+    attachClient(client) {
+        this.clients.add(client), 'function' == typeof client.on && (client.on('message', (message)=>{
+            this.handleClientMessage(message.toString(), client);
+        }), client.on('close', ()=>{
+            this.clients.delete(client), this.removeClientSubscriptions(client);
+        }));
+    }
+    async handleClientMessage(raw, client) {
+        let message;
+        try {
+            message = JSON.parse(raw);
+        } catch  {
+            return;
+        }
+        if (message.api && Object.values(SDK.ServerAPI.API).includes(message.api)) {
+            if ('request' === message.type) return void await this.handleAPIRequestMessage(message, client);
+            if ('subscribe' === message.type) return void this.saveRequestToMap(message.api, message.body ?? null, client);
+            'unsubscribe' === message.type && this.removeRequestFromMap(message.api, message.body ?? null, client);
+        }
+    }
+    async handleAPIRequestMessage(message, client) {
+        if (message.id && client && client.readyState === ws.OPEN) try {
+            let response = await this.getAPIResponse(message.api, message.body);
+            client.send(JSON.stringify({
+                type: 'response',
+                id: message.id,
+                payload: response.res
+            }));
+        } catch (err) {
+            client.send(JSON.stringify({
+                type: 'response',
+                id: message.id,
+                error: err instanceof Error ? err.message : String(err)
+            }));
+        }
+    }
+    getSubscriptions() {
+        return [
+            ...this.map.values()
+        ].map(({ api, body })=>({
+                api,
+                body
+            }));
+    }
+    saveRequestToMap(api, body = null, client) {
+        let key = this.getSubscriptionKey(api, body);
+        if (client) {
+            this.clientSubscriptions.has(client) || this.clientSubscriptions.set(client, new Set());
+            let subscriptions = this.clientSubscriptions.get(client);
+            if (subscriptions.has(key)) return;
+            subscriptions.add(key);
+        }
+        let record = this.map.get(key);
+        if (record) {
+            record.count += 1;
+            return;
+        }
+        this.map.set(key, {
+            api,
+            body,
+            count: 1
+        });
+    }
+    removeRequestFromMap(api, body = null, client) {
+        let key = this.getSubscriptionKey(api, body);
+        if (client) {
+            let subscriptions = this.clientSubscriptions.get(client);
+            if (!subscriptions?.has(key)) return;
+            subscriptions.delete(key), 0 === subscriptions.size && this.clientSubscriptions.delete(client);
+        }
+        this.removeSubscriptionKey(key);
+    }
+    removeClientSubscriptions(client) {
+        let subscriptions = this.clientSubscriptions.get(client);
+        subscriptions && (subscriptions.forEach((key)=>this.removeSubscriptionKey(key)), this.clientSubscriptions.delete(client));
+    }
+    removeSubscriptionKey(key) {
+        let record = this.map.get(key);
+        record && (record.count -= 1, record.count <= 0 && this.map.delete(key));
+    }
+    getSubscriptionKey(api, body) {
+        return `${api}:${JSON.stringify(body ?? null)}`;
+    }
+    async getAPIResponse(api, body) {
+        let data = await this.loader.loadAPIData(api, body);
+        return {
+            req: {
+                api,
+                body
+            },
+            res: data
+        };
+    }
+    async broadcast() {
+        clearImmediate(this.timer), this.timer = setImmediate(async ()=>{
+            let promises = [];
+            this.map.forEach(({ api, body })=>{
+                promises.push((async ()=>{
+                    let res = await this.getAPIResponse(api, body);
+                    this.sendAPIData(api, res);
+                })());
+            }), await Promise.all(promises);
+        });
+    }
+    sendAPIData(api, payload) {
+        let message = JSON.stringify({
+            api,
+            payload
+        });
+        this.clients.forEach((client)=>{
+            client.readyState === ws.OPEN && client.send(message);
+        });
+    }
+    dispose() {
+        this.clients.forEach((client)=>{
+            client.close();
+        }), this.clients.clear(), this.server?.close();
+    }
+}
+let normalizeAPIKey = (key)=>key && 'object' == typeof key && 'name' in key ? key.name : key;
+class Router {
+    static{
+        this.routes = {
+            get: new Map(),
+            post: new Map()
+        };
+    }
+    static get(pathname) {
+        return (target, propertyKey, descriptor)=>{
+            let routes = Router.routes.get, constructor = target.constructor;
+            return routes.has(constructor) || routes.set(constructor, []), routes.get(constructor).push([
+                normalizeAPIKey(propertyKey),
+                pathname
+            ]), descriptor;
+        };
+    }
+    static post(pathname) {
+        return (target, propertyKey, descriptor)=>{
+            let routes = Router.routes.post, constructor = target.constructor;
+            return routes.has(constructor) || routes.set(constructor, []), routes.get(constructor).push([
+                normalizeAPIKey(propertyKey),
+                pathname
+            ]), descriptor;
+        };
+    }
+    constructor(options){
+        this.options = options;
+    }
+    async setup() {
+        let { apis, sdk, server } = this.options;
+        apis.forEach((API)=>{
+            let obj = new API(sdk, server);
+            Router.routes.get.get(API)?.forEach(([key, pathname])=>{
+                server.get(pathname, this.wrapAPIFunction(obj, key));
+            }), Router.routes.post.get(API)?.forEach(([key, pathname])=>{
+                server.post(pathname, this.wrapAPIFunction(obj, key));
+            });
+        });
+    }
+    wrapAPIFunction(api, key) {
+        let { sdk, server } = this.options;
+        return async (req, res)=>{
+            let ctx = {
+                req,
+                res,
+                sdk,
+                server
+            }, trap = new Proxy(api, {
+                get: (target, key, receiver)=>'ctx' === key ? ctx : Reflect.get(target, key, receiver),
+                set: (target, key, value, receiver)=>Reflect.set(target, key, value, receiver),
+                defineProperty: (target, p, attrs)=>Reflect.defineProperty(target, p, attrs)
+            }), fn = api[key], result = await fn.call(trap, trap);
+            return 'string' == typeof result ? Buffer.from(result, 'utf-8') : result && 'object' == typeof result ? Buffer.from(JSON.stringify(result), 'utf-8') : result;
+        };
+    }
+}
+class BaseAPI {
+    constructor(sdk, server){
+        this.ctx = {
+            sdk,
+            server
+        }, this.dataLoader = new Data.APIDataLoader(this);
+    }
+    async loadManifest() {
+        return this.ctx.sdk.getManifestData();
+    }
+    async loadData(key) {
+        let data = this.ctx.sdk.getStoreData(), res = data[key];
+        return key.includes('.') && (res = key.split('.').reduce((t, k)=>t[k], data)), res;
+    }
+}
+function _ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+class AlertsAPI extends BaseAPI {
+    async getPackageRelationAlertDetails() {
+        let { req } = this.ctx, { id, target } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetPackageRelationAlertDetails, {
+            id,
+            target
+        });
+    }
+}
+function bundle_diff_ts_decorate(decorators, target, key, desc) {
+    var d, c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)(d = decorators[i]) && (r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r);
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function bundle_diff_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+!function(decorators, target, key, desc) {
+    var d, c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)(d = decorators[i]) && (r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r);
+    c > 3 && r && Object.defineProperty(target, key, r);
+}([
+    Router.post(SDK.ServerAPI.API.GetPackageRelationAlertDetails),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", []),
+    _ts_metadata("design:returntype", Promise)
+], AlertsAPI.prototype, "getPackageRelationAlertDetails", null);
+class BundleDiffAPI extends BaseAPI {
+    async getBundleDiffSummary() {
+        let { sdk } = this.ctx, { root, hash, errors, chunkGraph, moduleGraph, packageGraph, configs, moduleCodeMap, cloudManifestUrl } = sdk.getStoreData(), outputFilename = '';
+        return 'string' == typeof configs?.[0]?.config?.output?.filename && (outputFilename = configs?.[0]?.config?.output?.filename), {
+            root,
+            hash,
+            errors,
+            chunkGraph,
+            moduleGraph,
+            packageGraph,
+            outputFilename,
+            moduleCodeMap,
+            cloudManifestUrl
+        };
+    }
+    async bundleDiffManifest() {
+        let { sdk } = this.ctx;
+        return sdk.getStoreData();
+    }
+}
+function data_ts_decorate(decorators, target, key, desc) {
+    var d, c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)(d = decorators[i]) && (r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r);
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function data_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+bundle_diff_ts_decorate([
+    Router.get(SDK.ServerAPI.API.GetBundleDiffSummary),
+    Router.post(SDK.ServerAPI.API.GetBundleDiffSummary),
+    bundle_diff_ts_metadata("design:type", Function),
+    bundle_diff_ts_metadata("design:paramtypes", []),
+    bundle_diff_ts_metadata("design:returntype", Promise)
+], BundleDiffAPI.prototype, "getBundleDiffSummary", null), bundle_diff_ts_decorate([
+    Router.get(SDK.ServerAPI.API.BundleDiffManifest),
+    bundle_diff_ts_metadata("design:type", Function),
+    bundle_diff_ts_metadata("design:paramtypes", []),
+    bundle_diff_ts_metadata("design:returntype", Promise)
+], BundleDiffAPI.prototype, "bundleDiffManifest", null);
+class DataAPI extends BaseAPI {
+    async loadDataByKey() {
+        let { req } = this.ctx, { url } = req, { key } = req.body;
+        return !key && url && (key = new URL(url, 'http://127.0.0.1').pathname.replace(/^\//, '')), await this.loadData(key);
+    }
+    async sendMessageToClient() {
+        let { req, server } = this.ctx, { api, data } = req.body;
+        await server.sendAPIDataToClient(api, data);
+    }
+}
+function fs_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+data_ts_decorate([
+    Router.post(SDK.ServerAPI.API.LoadDataByKey),
+    data_ts_metadata("design:type", Function),
+    data_ts_metadata("design:paramtypes", []),
+    data_ts_metadata("design:returntype", Promise)
+], DataAPI.prototype, "loadDataByKey", null), data_ts_decorate([
+    Router.post(SDK.ServerAPI.API.SendAPIDataToClient),
+    data_ts_metadata("design:type", Function),
+    data_ts_metadata("design:paramtypes", []),
+    data_ts_metadata("design:returntype", Promise)
+], DataAPI.prototype, "sendMessageToClient", null);
+class FileSystemAPI extends BaseAPI {
+    async applyErrorFix() {
+        let { body } = this.ctx.req;
+        return await this.ctx.sdk.applyErrorFix(body.id), 'success';
+    }
+}
+function loader_ts_decorate(decorators, target, key, desc) {
+    var d, c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)(d = decorators[i]) && (r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r);
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function loader_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+!function(decorators, target, key, desc) {
+    var d, c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)(d = decorators[i]) && (r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r);
+    c > 3 && r && Object.defineProperty(target, key, r);
+}([
+    Router.post(SDK.ServerAPI.API.ApplyErrorFix),
+    fs_ts_metadata("design:type", Function),
+    fs_ts_metadata("design:paramtypes", []),
+    fs_ts_metadata("design:returntype", Promise)
+], FileSystemAPI.prototype, "applyErrorFix", null);
+class LoaderAPI extends BaseAPI {
+    async reportLoader() {
+        let { req, sdk } = this.ctx, { body } = req;
+        return sdk.reportLoader(body), 'ok';
+    }
+    async reportSourceMap() {
+        let { req: { body }, sdk } = this.ctx;
+        return sdk.reportSourceMap(body), 'ok';
+    }
+    async getLoaderNames() {
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderNames);
+    }
+    async getLoaderChartData() {
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderChartData);
+    }
+    async getLoaderFileTree() {
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderFileTree);
+    }
+    async getLoaderFileDetails() {
+        let { req } = this.ctx, { path } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderFileDetails, {
+            path
+        });
+    }
+    async getLoaderFolderStatistics() {
+        let { req } = this.ctx, { folder } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderFolderStatistics, {
+            folder
+        });
+    }
+    async getLoaderFileFirstInput() {
+        let { req } = this.ctx, { file } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderFileFirstInput, {
+            file
+        });
+    }
+    async getLoaderFileInputAndOutput() {
+        let { req } = this.ctx, { file, loader, loaderIndex } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetLoaderFileInputAndOutput, {
+            file,
+            loader,
+            loaderIndex
+        });
+    }
+}
+function graph_ts_decorate(decorators, target, key, desc) {
+    var d, c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)(d = decorators[i]) && (r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r);
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function graph_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+loader_ts_decorate([
+    Router.post(SDK.ServerAPI.API.ReportLoader),
+    loader_ts_metadata("design:type", Function),
+    loader_ts_metadata("design:paramtypes", []),
+    loader_ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "reportLoader", null), loader_ts_decorate([
+    Router.post(SDK.ServerAPI.API.ReportSourceMap),
+    loader_ts_metadata("design:type", Function),
+    loader_ts_metadata("design:paramtypes", []),
+    loader_ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "reportSourceMap", null), loader_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetLoaderNames),
+    loader_ts_metadata("design:type", Function),
+    loader_ts_metadata("design:paramtypes", []),
+    loader_ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "getLoaderNames", null), loader_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetLoaderChartData),
+    loader_ts_metadata("design:type", Function),
+    loader_ts_metadata("design:paramtypes", []),
+    loader_ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "getLoaderChartData", null), loader_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetLoaderFileTree),
+    loader_ts_metadata("design:type", Function),
+    loader_ts_metadata("design:paramtypes", []),
+    loader_ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "getLoaderFileTree", null), loader_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetLoaderFileDetails),
+    loader_ts_metadata("design:type", Function),
+    loader_ts_metadata("design:paramtypes", []),
+    loader_ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "getLoaderFileDetails", null), loader_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetLoaderFolderStatistics),
+    loader_ts_metadata("design:type", Function),
+    loader_ts_metadata("design:paramtypes", []),
+    loader_ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "getLoaderFolderStatistics", null), loader_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetLoaderFileFirstInput),
+    loader_ts_metadata("design:type", Function),
+    loader_ts_metadata("design:paramtypes", []),
+    loader_ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "getLoaderFileFirstInput", null), loader_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetLoaderFileInputAndOutput),
+    loader_ts_metadata("design:type", Function),
+    loader_ts_metadata("design:paramtypes", []),
+    loader_ts_metadata("design:returntype", Promise)
+], LoaderAPI.prototype, "getLoaderFileInputAndOutput", null);
+class GraphAPI extends BaseAPI {
+    async getAssetsSummary() {
+        let { req } = this.ctx, { withFileContent } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetAssetsSummary, {
+            withFileContent
+        });
+    }
+    async getModuleGraphForAsset() {
+        let { req } = this.ctx, { assetPath } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetAssetDetails, {
+            assetPath
+        });
+    }
+    async getChunksByModuleId() {
+        let { req } = this.ctx, { moduleId } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetChunksByModuleId, {
+            moduleId
+        });
+    }
+    async getModuleDetails() {
+        let { req } = this.ctx, { moduleId } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetModuleDetails, {
+            moduleId
+        });
+    }
+    async getDependencyByResolvedRequest() {
+        let { req } = this.ctx, { moduleIds = [] } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetModulesByModuleIds, {
+            moduleIds
+        });
+    }
+    async getModuleCodeByModuleId() {
+        let { req } = this.ctx, { moduleId } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetModuleCodeByModuleId, {
+            moduleId
+        });
+    }
+    async getModuleCodeByModuleIds() {
+        let { req } = this.ctx, { moduleIds } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetModuleCodeByModuleIds, {
+            moduleIds
+        });
+    }
+    async getEntryModulesSummary() {
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetEntryPoints);
+    }
+}
+function plugin_ts_decorate(decorators, target, key, desc) {
+    var d, c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)(d = decorators[i]) && (r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r);
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function plugin_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+graph_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetAssetsSummary),
+    graph_ts_metadata("design:type", Function),
+    graph_ts_metadata("design:paramtypes", []),
+    graph_ts_metadata("design:returntype", Promise)
+], GraphAPI.prototype, "getAssetsSummary", null), graph_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetAssetDetails),
+    graph_ts_metadata("design:type", Function),
+    graph_ts_metadata("design:paramtypes", []),
+    graph_ts_metadata("design:returntype", Promise)
+], GraphAPI.prototype, "getModuleGraphForAsset", null), graph_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetChunksByModuleId),
+    graph_ts_metadata("design:type", Function),
+    graph_ts_metadata("design:paramtypes", []),
+    graph_ts_metadata("design:returntype", Promise)
+], GraphAPI.prototype, "getChunksByModuleId", null), graph_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetModuleDetails),
+    graph_ts_metadata("design:type", Function),
+    graph_ts_metadata("design:paramtypes", []),
+    graph_ts_metadata("design:returntype", Promise)
+], GraphAPI.prototype, "getModuleDetails", null), graph_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetModulesByModuleIds),
+    graph_ts_metadata("design:type", Function),
+    graph_ts_metadata("design:paramtypes", []),
+    graph_ts_metadata("design:returntype", Promise)
+], GraphAPI.prototype, "getDependencyByResolvedRequest", null), graph_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetModuleCodeByModuleId),
+    graph_ts_metadata("design:type", Function),
+    graph_ts_metadata("design:paramtypes", []),
+    graph_ts_metadata("design:returntype", Promise)
+], GraphAPI.prototype, "getModuleCodeByModuleId", null), graph_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetModuleCodeByModuleIds),
+    graph_ts_metadata("design:type", Function),
+    graph_ts_metadata("design:paramtypes", []),
+    graph_ts_metadata("design:returntype", Promise)
+], GraphAPI.prototype, "getModuleCodeByModuleIds", null), graph_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetEntryPoints),
+    graph_ts_metadata("design:type", Function),
+    graph_ts_metadata("design:paramtypes", []),
+    graph_ts_metadata("design:returntype", Promise)
+], GraphAPI.prototype, "getEntryModulesSummary", null);
+class PluginAPI extends BaseAPI {
+    async getPluginSummary() {
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetPluginSummary);
+    }
+    async getPluginData() {
+        let { req } = this.ctx, { hooks = [], tapNames = [] } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetPluginData, {
+            hooks,
+            tapNames
+        });
+    }
+}
+function project_ts_decorate(decorators, target, key, desc) {
+    var d, c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)(d = decorators[i]) && (r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r);
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function project_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+plugin_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetPluginSummary),
+    plugin_ts_metadata("design:type", Function),
+    plugin_ts_metadata("design:paramtypes", []),
+    plugin_ts_metadata("design:returntype", Promise)
+], PluginAPI.prototype, "getPluginSummary", null), plugin_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetPluginData),
+    plugin_ts_metadata("design:type", Function),
+    plugin_ts_metadata("design:paramtypes", []),
+    plugin_ts_metadata("design:returntype", Promise)
+], PluginAPI.prototype, "getPluginData", null);
+class ProjectAPI extends BaseAPI {
+    async env() {
+        let { server } = this.ctx;
+        return {
+            ip: function() {
+                for (let iface of Object.values(os_0.networkInterfaces()))for (let alias of iface)if ('IPv4' === alias.family && !alias.internal) return alias.address;
+                return '127.0.0.1';
+            }(),
+            port: server.port
+        };
+    }
+    async manifest() {
+        let { sdk } = this.ctx;
+        return JSON.stringify(sdk.getManifestData());
+    }
+    async getProjectInfo() {
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetProjectInfo);
+    }
+    async getClientRoutes() {
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetClientRoutes);
+    }
+}
+function renderer_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+project_ts_decorate([
+    Router.get(SDK.ServerAPI.API.Env),
+    project_ts_metadata("design:type", Function),
+    project_ts_metadata("design:paramtypes", []),
+    project_ts_metadata("design:returntype", Promise)
+], ProjectAPI.prototype, "env", null), project_ts_decorate([
+    Router.get(SDK.ServerAPI.API.Manifest),
+    project_ts_metadata("design:type", Function),
+    project_ts_metadata("design:paramtypes", []),
+    project_ts_metadata("design:returntype", Promise)
+], ProjectAPI.prototype, "manifest", null), project_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetProjectInfo),
+    project_ts_metadata("design:type", Function),
+    project_ts_metadata("design:paramtypes", []),
+    project_ts_metadata("design:returntype", Promise)
+], ProjectAPI.prototype, "getProjectInfo", null), project_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetClientRoutes),
+    project_ts_metadata("design:type", Function),
+    project_ts_metadata("design:paramtypes", []),
+    project_ts_metadata("design:returntype", Promise)
+], ProjectAPI.prototype, "getClientRoutes", null);
+let renderer_require = createRequire(import.meta.url);
+class RendererAPI extends BaseAPI {
+    async entryHtml() {
+        let { server, res } = this.ctx, clientHtmlPath = server.innerClientPath ? server.innerClientPath : renderer_require.resolve('@rsdoctor/client'), clientHtml = node_fs.readFileSync(clientHtmlPath, 'utf-8');
+        return res.setHeader('Content-Type', 'text/html'), res.setHeader('Cache-Control', 'no-store'), clientHtml;
+    }
+}
+function resolver_ts_decorate(decorators, target, key, desc) {
+    var d, c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)(d = decorators[i]) && (r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r);
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function resolver_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+!function(decorators, target, key, desc) {
+    var d, c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)(d = decorators[i]) && (r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r);
+    c > 3 && r && Object.defineProperty(target, key, r);
+}([
+    Router.get(SDK.ServerAPI.API.EntryHtml),
+    renderer_ts_metadata("design:type", Function),
+    renderer_ts_metadata("design:paramtypes", []),
+    renderer_ts_metadata("design:returntype", Promise)
+], RendererAPI.prototype, "entryHtml", null);
+class ResolverAPI extends BaseAPI {
+    async getResolverFileTree() {
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetResolverFileTree);
+    }
+    async getResolverFileDetails() {
+        let { req } = this.ctx, { filepath } = req.body;
+        return this.dataLoader.loadAPI(SDK.ServerAPI.API.GetResolverFileDetails, {
+            filepath
+        });
+    }
+}
+resolver_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetResolverFileTree),
+    resolver_ts_metadata("design:type", Function),
+    resolver_ts_metadata("design:paramtypes", []),
+    resolver_ts_metadata("design:returntype", Promise)
+], ResolverAPI.prototype, "getResolverFileTree", null), resolver_ts_decorate([
+    Router.post(SDK.ServerAPI.API.GetResolverFileDetails),
+    resolver_ts_metadata("design:type", Function),
+    resolver_ts_metadata("design:paramtypes", []),
+    resolver_ts_metadata("design:returntype", Promise)
+], ResolverAPI.prototype, "getResolverFileDetails", null);
+let execAsync = promisify(exec), supportedChromiumBrowsers = [
+    'Google Chrome Canary',
+    'Google Chrome Dev',
+    'Google Chrome Beta',
+    'Google Chrome',
+    'Microsoft Edge',
+    'Brave Browser',
+    'Vivaldi',
+    'Chromium'
+], getTargetBrowser = async ()=>{
+    let targetBrowser = process.env.BROWSER;
+    if (!targetBrowser || !supportedChromiumBrowsers.includes(targetBrowser)) {
+        let { stdout: ps } = await execAsync('ps cax');
+        targetBrowser = supportedChromiumBrowsers.find((b)=>ps.includes(b));
+    }
+    return targetBrowser;
+}, openWithDefaultBrowser = async (url)=>{
+    try {
+        let { default: open } = await import("open");
+        return await open(url), !0;
+    } catch (err) {
+        return rsdoctorLogger.error('Failed to open Rsdoctor URL.'), rsdoctorLogger.error(err), !1;
+    }
+};
+async function openBrowser(url, needEncodeURI = !0) {
+    if ('darwin' === process.platform) try {
+        let targetBrowser = await getTargetBrowser();
+        if (targetBrowser) return await execAsync(`osascript openChrome.applescript "${needEncodeURI ? encodeURI(url) : url}" "${targetBrowser}"`, {
+            cwd: join(__rspack_import_meta_dirname__, '../static')
+        }), !0;
+        rsdoctorLogger.debug('Failed to find the target browser.');
+    } catch (err) {
+        rsdoctorLogger.debug("Failed to open Rsdoctor URL with apple script."), rsdoctorLogger.debug(err);
+    }
+    return openWithDefaultBrowser(url);
+}
+function createHttpError(status, message, type) {
+    return Object.assign(Error(message), {
+        status,
+        statusCode: status,
+        type
+    });
+}
+function getContentType(req) {
+    let contentType = req.headers['content-type'];
+    if ('string' == typeof contentType) return contentType;
+}
+function normalizeReadError(error, charset) {
+    return error instanceof Error && 'status' in error && 'number' == typeof error.status ? charset && 'type' in error && 'encoding.unsupported' === error.type ? createHttpError(415, `unsupported charset "${charset.toUpperCase()}"`, 'charset.unsupported') : error : createHttpError(400, error instanceof Error ? error.message : 'failed to read request body', 'request.invalid');
+}
+let server_require = createRequire(import.meta.url), OPEN_IN_EDITOR_EDITORS = new Set(SDK.OPEN_IN_EDITOR_EDITORS), LARGE_JSON_BODY_ROUTES = new Set([
+    SDK.ServerAPI.API.ReportLoader,
+    SDK.ServerAPI.API.ReportSourceMap
+]);
+class RsdoctorServer {
+    constructor(sdk, port = defaultPort, config){
+        this.sdk = sdk, this.disposed = !0, this._socketToken = randomBytes(16).toString('hex'), this.get = (route, cb)=>{
+            let { app } = this;
+            return app.use(route, this.wrapNextHandleFunction('GET', cb)), app;
+        }, this.post = (route, cb)=>{
+            let { app } = this;
+            return app.use(route, this.wrapNextHandleFunction('POST', cb)), app;
+        }, this.dispose = async (exitCode)=>{
+            if (this.disposed) {
+                void 0 !== exitCode && process.exit(exitCode);
+                return;
+            }
+            this.disposed = !0, this._server && await this._server.close(), this._socket && this._socket.dispose(), void 0 !== exitCode && process.exit(exitCode);
+        }, assert('number' == typeof port), this.port = port, this._router = new Router({
+            sdk,
+            server: this,
+            apis: Object.values(apis_namespaceObject)
+        }), this._innerClientPath = config?.innerClientPath || '', this._printServerUrl = config?.printServerUrl ?? !0, this._cors = config?.cors;
+    }
+    get app() {
+        return this._server.app;
+    }
+    get host() {
+        return defaultHost;
+    }
+    get origin() {
+        return `http://${this.host}:${this.port}`;
+    }
+    get socketUrl() {
+        return {
+            port: this.port,
+            socketUrl: `ws://localhost:${this.port}?token=${this._socketToken}`,
+            token: this._socketToken
+        };
+    }
+    get innerClientPath() {
+        return this._innerClientPath;
+    }
+    async createInnerServer() {
+        let lastError, expectedPort = this.port;
+        for(let retry = 0; retry < 10; retry++){
+            let port = getPortSync(expectedPort, this.host);
+            try {
+                return {
+                    port,
+                    server: await createServer(port, this.host)
+                };
+            } catch (error) {
+                if ('EADDRINUSE' !== error.code) throw error;
+                lastError = error, expectedPort = port + 1;
+            }
+        }
+        throw lastError;
+    }
+    resolveCorsOptions() {
+        return !1 !== this._cors && (!0 === this._cors ? {} : void 0 === this._cors ? {
+            origin: DEFAULT_ALLOWED_CORS_ORIGINS
+        } : {
+            ...this._cors,
+            origin: void 0 === this._cors.origin ? DEFAULT_ALLOWED_CORS_ORIGINS : this._cors.origin
+        });
+    }
+    async bootstrap() {
+        if (!this.disposed) return;
+        let { port, server } = await this.createInnerServer(), corsOptions = this.resolveCorsOptions();
+        this.port = port, this._server = server, this._socket = new Socket({
+            sdk: this.sdk,
+            server: this._server.server,
+            port: this.port,
+            token: this._socketToken
+        }), await this._socket.bootstrap(), function(port, builderName) {
+            let homeDir = os_0.homedir(), rsdoctorDir = path_0.join(homeDir, '.cache/rsdoctor'), mcpPortFilePath = path_0.join(rsdoctorDir, 'mcp.json');
+            fs.existsSync(rsdoctorDir) || fs.mkdirSync(rsdoctorDir, {
+                recursive: !0
+            });
+            let mcpJson = {
+                portList: {},
+                port: 0
+            };
+            if (fs.existsSync(mcpPortFilePath)) try {
+                mcpJson = JSON.parse(fs.readFileSync(mcpPortFilePath, 'utf8'));
+            } catch (error) {
+                rsdoctorLogger.debug('Failed to parse mcp.json', error);
+            }
+            mcpJson.portList || (mcpJson.portList = {}), mcpJson.portList[builderName || 'builder'] = port, mcpJson.port = port, fs.writeFileSync(mcpPortFilePath, JSON.stringify(mcpJson, null, 2), 'utf8');
+        }(this.port, this.sdk.name), rsdoctorLogger.debug(`Successfully wrote mcp.json for ${color.cyan(this.sdk.name)} builder`), this.disposed = !1, this.app.use((req, res, next)=>{
+            if (!isAllowedRequestHost(req.headers.host || req.headers[':authority'])) {
+                res.statusCode = 403, res.end();
+                return;
+            }
+            next();
+        }), !1 !== corsOptions && corsOptions.origin === DEFAULT_ALLOWED_CORS_ORIGINS && this.app.use((req, res, next)=>{
+            let host = req.headers.host || req.headers[':authority'];
+            if (!function(origin, host) {
+                if (void 0 === origin) return !0;
+                if ('string' != typeof origin || 'string' != typeof host || !(void 0 === origin || 'string' == typeof origin && DEFAULT_ALLOWED_CORS_ORIGINS.test(origin))) return !1;
+                let originHostname = function(origin) {
+                    try {
+                        let hostname = new URL(origin).hostname.toLowerCase();
+                        return hostname.startsWith('[') && hostname.endsWith(']') ? hostname.slice(1, -1) : hostname;
+                    } catch  {
+                        return '';
+                    }
+                }(origin), hostHostname = getHostnameFromHost(host).toLowerCase();
+                return !originHostname.endsWith('.localhost') || originHostname === hostHostname;
+            }(req.headers.origin, host)) {
+                res.statusCode = 403, res.end();
+                return;
+            }
+            next();
+        }), !1 !== corsOptions && this.app.use(cors(corsOptions)), this.app.use(function(options = {}) {
+            return (req, _res, next)=>{
+                let content, limit, contentType, contentType1, match;
+                if ('body' in req || (req.body = void 0), !(void 0 !== req.headers['transfer-encoding'] || !Number.isNaN(Number(req.headers['content-length']))) || !(contentType = getContentType(req)) || 'application/json' !== contentType.split(';', 1)[0].trim().toLowerCase()) return void next();
+                let charset = (contentType1 = getContentType(req), match = contentType1?.match(/(?:^|;)\s*charset\s*=\s*(?:"([^"]+)"|([^;\s]+))/i), (match?.[1] || match?.[2] || 'utf-8').toLowerCase());
+                if (!charset.startsWith('utf-')) {
+                    req.resume(), next(createHttpError(415, `unsupported charset "${charset.toUpperCase()}"`, 'charset.unsupported'));
+                    return;
+                }
+                try {
+                    content = function(req) {
+                        let stream, contentEncoding = req.headers['content-encoding'], encoding = 'string' == typeof contentEncoding ? contentEncoding.toLowerCase() : 'identity';
+                        if ('identity' === encoding) return {
+                            stream: req,
+                            length: req.headers['content-length']
+                        };
+                        switch(encoding){
+                            case 'gzip':
+                                stream = createGunzip();
+                                break;
+                            case 'deflate':
+                                stream = createInflate();
+                                break;
+                            case 'br':
+                                stream = createBrotliDecompress();
+                                break;
+                            default:
+                                throw createHttpError(415, `unsupported content encoding "${encoding}"`, 'encoding.unsupported');
+                        }
+                        let cleanup = ()=>{
+                            req.removeListener('aborted', onAborted), req.removeListener('close', onClose), req.removeListener('error', onError), stream.removeListener('close', cleanup);
+                        }, destroy = (error)=>{
+                            stream.destroyed || stream.destroy(error);
+                        }, onAborted = ()=>{
+                            destroy(createHttpError(400, 'request aborted', 'request.aborted'));
+                        }, onClose = ()=>{
+                            !1 === req.complete && onAborted();
+                        }, onError = (error)=>{
+                            destroy(error);
+                        };
+                        return req.once('aborted', onAborted), req.once('close', onClose), req.once('error', onError), stream.once('close', cleanup), req.pipe(stream), {
+                            stream,
+                            cleanup,
+                            decompressor: stream
+                        };
+                    }(req);
+                } catch (error) {
+                    req.resume(), next(normalizeReadError(error));
+                    return;
+                }
+                let handleError = (error)=>{
+                    content.cleanup?.(), content.decompressor && (req.unpipe(content.decompressor), content.decompressor.destroy()), req.resume(), next(normalizeReadError(error, charset));
+                };
+                try {
+                    limit = 'function' == typeof options.limit ? options.limit(req) : options.limit;
+                } catch (error) {
+                    handleError(error);
+                    return;
+                }
+                raw_body(content.stream, {
+                    encoding: charset,
+                    length: content.length,
+                    limit
+                }).then((body)=>{
+                    try {
+                        req.body = function(body) {
+                            let value;
+                            if (0 === body.length) return {};
+                            try {
+                                value = JSON.parse(body);
+                            } catch (error) {
+                                throw createHttpError(400, error.message, 'entity.parse.failed');
+                            }
+                            if (null === value || 'object' != typeof value) throw createHttpError(400, 'JSON body must be an object or array', 'entity.parse.failed');
+                            return value;
+                        }(body);
+                    } catch (error) {
+                        handleError(error);
+                        return;
+                    }
+                    content.cleanup?.(), next();
+                }, handleError);
+            };
+        }({
+            limit: (req)=>{
+                let pathname = new URL(req.url || '/', 'http://localhost').pathname;
+                return LARGE_JSON_BODY_ROUTES.has(pathname) ? '500mb' : '10mb';
+            }
+        })), await this._router.setup();
+        let clientHtmlPath = this._innerClientPath ? this._innerClientPath : server_require.resolve('@rsdoctor/client'), clientDistPath = path_0.resolve(clientHtmlPath, '..');
+        this.app.use(sirv(clientDistPath, {
+            dev: !0
+        })), this.app.use('/__open-in-editor', (req, res, next)=>{
+            if ('GET' !== req.method && 'HEAD' !== req.method) return next();
+            let url = new URL(req.url || '', "http://localhost"), file = url.searchParams.get('file'), editor = url.searchParams.get('editor');
+            if (!function(token, expectedToken) {
+                if ('string' != typeof token || !expectedToken) return !1;
+                let tokenBuffer = Buffer.from(token), expectedTokenBuffer = Buffer.from(expectedToken);
+                return tokenBuffer.length === expectedTokenBuffer.length && timingSafeEqual(tokenBuffer, expectedTokenBuffer);
+            }(url.searchParams.get('token'), this._socketToken)) {
+                res.statusCode = 403, res.end();
+                return;
+            }
+            if (!file) {
+                res.statusCode = 400, res.end('Missing file parameter');
+                return;
+            }
+            if (!('string' == typeof editor && OPEN_IN_EDITOR_EDITORS.has(editor))) {
+                res.statusCode = 400, res.end('Unsupported editor parameter');
+                return;
+            }
+            try {
+                let launch = server_require('launch-editor'), responded = !1, safeEnd = (code, body)=>{
+                    responded || (responded = !0, res.statusCode = code, res.end(body));
+                };
+                launch(file, editor, (_fileName, errorMessage)=>{
+                    errorMessage && safeEnd(500, errorMessage);
+                }), setTimeout(()=>{
+                    safeEnd(200, '');
+                }, 200);
+            } catch (err) {
+                res.writableEnded || (res.statusCode = 500, res.end(err.message));
+            }
+        }), process.once('exit', ()=>this.dispose()), process.once('SIGINT', ()=>this.dispose(0)), process.once('SIGTERM', ()=>this.dispose(0)), process.once('unhandledRejection', (reason)=>{
+            console.error('Unhandled promise rejection:', reason), this.dispose(1);
+        }), process.once('uncaughtException', (err, origin)=>{
+            console.error('Uncaught exception:', err), origin && console.error('Exception origin:', origin), this.dispose(1);
+        });
+    }
+    wrapNextHandleFunction(method, cb) {
+        return async (req, res, next)=>{
+            if (req.method?.toUpperCase() === method) {
+                try {
+                    let body = await cb(req, res, next);
+                    if (res.statusCode = 200, Buffer.isBuffer(body)) {
+                        res.setHeader('Content-Length', body.byteLength);
+                        let ps = new PassThrough();
+                        ps.write(body), ps.end(), ps.pipe(res);
+                    } else body && 'object' == typeof body ? (res.writeHead(200, {
+                        'Content-Type': 'application/json;utf-8'
+                    }), res.write(JSON.stringify(body)), res.end()) : res.writeHead(200).end(body);
+                } catch (error) {
+                    return res.statusCode = 500, res.end(error.message), next(error);
+                }
+                return;
+            }
+            await next();
+        };
+    }
+    proxy(api, method, cb) {
+        let idx = this.app.stack.findIndex((e)=>e.route === api);
+        -1 === idx && (idx = this.app.stack.length - 1), this.app.stack.splice(idx, 0, {
+            route: api,
+            handle: this.wrapNextHandleFunction(method, cb)
+        });
+    }
+    getClientUrl(route = 'homepage', ...args) {
+        let relativeUrl = SDK.ServerAPI.API.EntryHtml;
+        if (route !== Client.RsdoctorClientRoutes.BundleDiff) return relativeUrl;
+        {
+            let [baseline, current] = args, qs = Bundle.getBundleDiffPageQueryString([
+                baseline,
+                current
+            ]);
+            return `${relativeUrl}${qs}#${Client.RsdoctorClientRoutes.BundleDiff}`;
+        }
+    }
+    async openClientPage(...args) {
+        let relativeUrl = this.getClientUrl(...args), needEncodeURI = args[0] === Client.RsdoctorClientRoutes.BundleDiff, url = `http://${this.host}:${this.port}${relativeUrl}`, localhostUrl = `http://localhost:${this.port}${relativeUrl}`;
+        await openBrowser(localhostUrl, !needEncodeURI), this._printServerUrl && rsdoctorLogger.info(`${color.green(`${this.sdk.name} compiler's`)} analyzer running on: ${color.cyan(url)}`);
+    }
+    sendAPIDataToClient(api, msg) {
+        this._socket?.sendAPIData(api, msg);
+    }
+    async broadcast() {
+        await this._socket?.broadcast();
+    }
+}
+class RsdoctorFakeServer extends RsdoctorServer {
+    constructor(sdk, port = defaultPort){
+        super(sdk, port), this.sdk = sdk, this.dispose = async ()=>{}, this.sdk = sdk;
+    }
+    async bootstrap() {}
+    async openClientPage() {}
+}
+function findRoot(startDir = process.cwd()) {
+    let dir = startDir, firstPkgDir = null;
+    for(; dir !== path_0.parse(dir).root;){
+        if (fs.existsSync(path_0.join(dir, 'pnpm-workspace.yaml')) || fs.existsSync(path_0.join(dir, 'yarn.lock')) || fs.existsSync(path_0.join(dir, 'lerna.json'))) return dir;
+        let pkgPath = path_0.join(dir, 'package.json');
+        if (fs.existsSync(pkgPath) && (firstPkgDir || (firstPkgDir = dir), JSON.parse(fs.readFileSync(pkgPath, 'utf8')).workspaces)) return dir;
+        dir = path_0.dirname(dir);
+    }
+    return firstPkgDir || null;
+}
+String((date = new Date()).getMonth() + 1).padStart(2, '0'), String(date.getDate()).padStart(2, '0'), date.getFullYear();
+class SDKCore {
+    constructor({ name, root }){
+        this.hooks = {
+            afterSaveManifest: new AsyncSeriesHook([
+                'result'
+            ])
+        }, this._envinfo = {}, this._clientRoutes = new Set([
+            Manifest.RsdoctorManifestClientRoutes.Overall
+        ]), this.diskManifestPath = '', this._name = name, this.root = root, this.pid = node_process.pid, this._outputDir = node_path.join(this.outputDir || this.root, Constants.RsdoctorOutputFolder);
+    }
+    get outputDir() {
+        return this._outputDir;
+    }
+    get name() {
+        return this._name;
+    }
+    async bootstrap() {
+        let [cpu, memory, nodeVersion, yarnVersion, npmVersion, pnpmVersion] = await Promise.all([
+            getCPUInfo(),
+            getMemoryInfo(),
+            getNodeVersion(),
+            getYarnVersion(),
+            getNpmVersion(),
+            getPnpmVersion()
+        ]);
+        this._envinfo = {
+            ...this._envinfo,
+            cpu,
+            memory,
+            nodeVersion,
+            yarnVersion,
+            npmVersion,
+            pnpmVersion
+        };
+        let hash = createHash('md5').update([
+            this.name,
+            this.root,
+            JSON.stringify(this._envinfo),
+            Date.now()
+        ].join('_')).digest('hex');
+        this.setHash(hash);
+    }
+    async dispose() {}
+    setOutputDir(outputDir) {
+        this._outputDir = outputDir;
+    }
+    setName(name) {
+        this._name = name;
+    }
+    setHash(hash) {
+        this.hash = hash;
+    }
+    getHash() {
+        return this.hash;
+    }
+    getClientRoutes() {
+        return [
+            ...this._clientRoutes
+        ];
+    }
+    addClientRoutes(routes) {
+        routes.forEach((route)=>{
+            this._clientRoutes.add(route);
+        }), this.onDataReport();
+    }
+    async writePieces(storeData, _options) {
+        let { outputDir } = this, manifest = node_path.resolve(outputDir, Constants.RsdoctorOutputManifest);
+        this.diskManifestPath = manifest, await external_fs_extra_fs_extra.ensureDir(outputDir);
+        let urlsPromiseList = [];
+        for (let key of Object.keys(storeData)){
+            let data = storeData[key];
+            if ('object' != typeof data) {
+                urlsPromiseList.push({
+                    name: key,
+                    files: data
+                });
+                continue;
+            }
+            let jsonStr = await (async ()=>{
+                try {
+                    if ('configs' === key) return JSON.stringify(decycle(data));
+                    return JSON.stringify(data);
+                } catch  {
+                    return stringify(data);
+                }
+            })();
+            if (Array.isArray(jsonStr)) {
+                let fileOffset = 0;
+                for (let str of jsonStr){
+                    let result = await this.writeToFolder(str, outputDir, key, fileOffset);
+                    fileOffset += result.files.length, urlsPromiseList.push(result);
+                }
+            } else urlsPromiseList.push(this.writeToFolder(jsonStr, outputDir, key));
+        }
+        let dataUrls = await Promise.all(urlsPromiseList);
+        rsdoctorLogger.debug(`SDKCore.writePieces extraConfig: ${JSON.stringify(this.extraConfig)}`, '[SDKCore.writePieces]'), this.cloudData = {
+            client: {
+                enableRoutes: this.getClientRoutes()
+            },
+            data: dataUrls.reduce((t, item)=>(t[item.name] = Array.isArray(item.files) ? item.files.map((e)=>e.path).concat(t[item.name] || []) : item.files, t), {})
+        };
+    }
+    async writeManifest() {
+        let { cloudData: data, diskManifestPath } = this, dataStr = JSON.stringify(data, null, 2);
+        rsdoctorLogger.debug(`SDKCore.writeManifest extraConfig: ${this.extraConfig}`, '[SDKCore.writeManifest]');
+        let dir = node_path.dirname(diskManifestPath), base = node_path.basename(diskManifestPath), tmpPath = node_path.join(dir, `${base}.${Date.now()}.${randomUUID()}.tmp`);
+        return await external_fs_extra_fs_extra.outputFile(tmpPath, dataStr), node_fs.renameSync(tmpPath, diskManifestPath), diskManifestPath;
+    }
+    async saveManifest(data, options) {
+        await this.writePieces(data, options);
+        let manifestDiskPath = await this.writeManifest();
+        return await this.hooks.afterSaveManifest.promise({
+            manifestWithShardingFiles: this.cloudData,
+            manifestDiskPath
+        }), manifestDiskPath;
+    }
+    writeToFolder(jsonStr, dir, key, index) {
+        let sharding = new FileSharding(Algorithm.compressText(jsonStr)), folder = node_path.resolve(dir, key);
+        return sharding.writeStringToFolder(folder, '', index).then((item)=>({
+                name: key,
+                files: item.map((el)=>({
+                        path: node_path.resolve(folder, el.filename),
+                        basename: el.filename,
+                        content: el.content
+                    }))
+            }));
+    }
+}
+let client_require = createRequire(import.meta.url), resolveClientDiffHtmlPath = (innerClientPath)=>{
+    let innerClientPath1;
+    return path_0.resolve((innerClientPath1 = innerClientPath, path_0.dirname(innerClientPath1 || client_require.resolve('@rsdoctor/client'))), 'diff.html');
+}, sdk_require = createRequire(import.meta.url);
+class RsdoctorSDK extends SDKCore {
+    constructor(options){
+        super(options), this._summary = {
+            costs: []
+        }, this._configs = [], this._errors = [], this._loader = [], this._loaderStart = [], this._resolver = [], this._plugin = {}, this._moduleGraph = new ModuleGraph(), this._chunkGraph = new ChunkGraph(), this._rawSourceMapCache = new Map(), this._sourceMap = new Map();
+        let serverConfig = options.config?.server, port = serverConfig?.port ?? options.port;
+        this.server = options.config?.noServer ? new RsdoctorFakeServer(this, port) : new RsdoctorServer(this, port, {
+            innerClientPath: options.config?.innerClientPath || '',
+            printServerUrl: options.config?.printLog?.serverUrls,
+            cors: serverConfig?.cors
+        }), this.type = Lodash.isNumber(options.type) ? options.type : SDK.ToDataType.Normal, this.extraConfig = options.config, this.root = findRoot() ?? '';
+    }
+    async bootstrap() {
+        rsdoctorLogger.debug(`${Date.now()}`, '[RsdoctorSDK][bootstrap start]'), this.server && await this.server.bootstrap(), await super.bootstrap(), rsdoctorLogger.debug(`${Date.now()} ${this.server.origin}`, '[RsdoctorSDK][bootstrap end]');
+    }
+    async dispose() {
+        rsdoctorLogger.debug(`${Date.now()}`, '[RsdoctorSDK][dispose start]'), this.server && await this.server.dispose(), await super.dispose(), rsdoctorLogger.debug(`${Date.now()}`, '[RsdoctorSDK][dispose end]');
+    }
+    async applyErrorFix(id) {
+        let { _errors: errors } = this, error = errors.find((err)=>err.id === id);
+        if (!error || !error.path || !error.fixData || error.fixData.isFixed) return;
+        let { path: filePath, fixData } = error, sameFileErrors = errors.filter((item)=>item.path === filePath && item !== error), content = (await node_fs.promises.readFile(filePath, 'utf-8')).toString(), startTxt = content.substring(0, fixData.start), endTxt = content.substring(fixData.end, content.length), offset = (fixData.newText ?? '').length - (fixData.end - fixData.start);
+        for (let other of (content = startTxt + fixData.newText + endTxt, sameFileErrors)){
+            let { fixData: otherFixData } = other;
+            otherFixData && otherFixData.start >= fixData.end && (otherFixData.start += offset, otherFixData.end += offset);
+        }
+        await node_fs.promises.writeFile(filePath, content);
+    }
+    clear() {
+        this._errors = [], this._loader = [], this._resolver = [], this._plugin = {}, this._moduleGraph = new ModuleGraph(), this._chunkGraph = new ChunkGraph();
+    }
+    clearSourceMapCache() {
+        this._rawSourceMapCache = new Map(), this._sourceMap = new Map();
+    }
+    async getSourceMap(file) {
+        let { _sourceMap: sourceMap, _rawSourceMapCache: rawMap } = this;
+        if (sourceMap.has(file)) return sourceMap.get(file);
+        let rawData = rawMap.get(file);
+        if (!rawData || rawData.version < 0 || !rawData.sourcesContent?.[0] || !rawData.mappings) return Promise.resolve(void 0);
+        try {
+            let result = await new SourceMapConsumer(rawData);
+            return sourceMap.set(file, result), result;
+        } catch  {
+            return Promise.resolve(void 0);
+        }
+    }
+    reportSourceMap(data) {
+        this._rawSourceMapCache.set(data.file, data);
+    }
+    reportConfiguration(config) {
+        config.root ??= this.root, this._configs.push(config), this.onDataReport();
+    }
+    reportError(errors) {
+        errors.forEach((item)=>{
+            this._errors.push(DevToolError.from(item, {
+                code: this.name
+            }));
+        }), this.onDataReport();
+    }
+    reportLoader(data) {
+        data.forEach((item)=>{
+            this.extraConfig?.mode === SDK.IMode[SDK.IMode.brief] && item.loaders.forEach((_loader)=>{
+                _loader.input = void 0, _loader.result = void 0;
+            });
+            let match = this._loader.find((e)=>e.resource.path === item.resource.path);
+            match ? match.loaders.push(...item.loaders) : (match = item, this._loader.push(item)), match.loaders.sort((a, b)=>a.startAt !== b.startAt ? a.startAt - b.startAt : a.isPitch ? b.isPitch ? a.loaderIndex - b.loaderIndex : -1 : b.isPitch ? 1 : b.loaderIndex - a.loaderIndex);
+        }), this.onDataReport();
+    }
+    reportLoaderStartOrEnd(data) {
+        let _builtinLoader = data.loaders[0];
+        if (_builtinLoader.startAt) this._loaderStart.push(data);
+        else if (_builtinLoader.endAt) {
+            let matchLoaderStart = this._loaderStart.find((e)=>e.resource.path === data.resource.path && e.loaders[0].loader === _builtinLoader.loader);
+            matchLoaderStart && (matchLoaderStart.loaders[0].result = _builtinLoader.result, matchLoaderStart.loaders[0].endAt = _builtinLoader.endAt, this.reportLoader([
+                matchLoaderStart
+            ]));
+        }
+    }
+    reportResolver(data) {
+        data.forEach((item)=>this._resolver.push(item)), this.onDataReport();
+    }
+    reportPlugin(data) {
+        Object.keys(data).forEach((hook)=>{
+            this._plugin[hook] ? data[hook].forEach((item)=>{
+                this._plugin[hook].push(item || void 0);
+            }) : this._plugin[hook] = data[hook];
+        }), this.onDataReport();
+    }
+    reportModuleGraph(data) {
+        rsdoctorLogger.debug(`data size: ${data.size()}`, '[SDK.reportModuleGraph][start]'), this._moduleGraph.fromInstance(data), this.createPackageGraph(), this.onDataReport(), rsdoctorLogger.debug(`sdk._moduleGraph size: ${this._moduleGraph.size()}`, '[SDK reportModuleGraph][end]');
+    }
+    reportPackageGraph(data) {
+        rsdoctorLogger.debug('[SDK.reportPackageGraph][start]'), this._packageGraph || (this._packageGraph = data), this.onDataReport(), rsdoctorLogger.debug(`sdk._packageGraph size: ${this._packageGraph.getPackages().length}`, '[SDK reportPackageGraph][end]');
+    }
+    reportChunkGraph(data) {
+        this._chunkGraph.addAsset(...data.getAssets()), this._chunkGraph.addChunk(...data.getChunks()), this._chunkGraph.addEntryPoint(...data.getEntryPoints()), this.onDataReport();
+    }
+    reportSummaryData(part) {
+        for (let key of [
+            'costs'
+        ]){
+            let v = part[key];
+            v && ('object' == typeof v ? Array.isArray(v) ? this._summary[key] = [
+                ...this._summary[key] || [],
+                ...v
+            ] : this._summary[key] = {
+                ...this._summary[key] || {},
+                ...v
+            } : this._summary[key] = v);
+        }
+        this.onDataReport();
+    }
+    createPackageGraph() {
+        if (rsdoctorLogger.debug(`sdk._moduleGraph size: ${this._moduleGraph.size()}`, '[SDK.createPackageGraph][start]'), !this._packageGraph) {
+            let pkgGraph = PackageGraph.fromModuleGraph(this._moduleGraph, this.root, (path)=>{
+                try {
+                    if (node_fs.existsSync(path)) return fs_extra.readJsonSync(path);
+                } catch (error) {
+                    let { message, stack } = error;
+                    rsdoctorLogger.debug(()=>`sdk.createPackageGraph error, path: ${path}, error message: ${stack || message}`, '[SDK.createPackageGraph][error]');
+                }
+            });
+            this._packageGraph = pkgGraph, rsdoctorLogger.debug(`sdk._packageGraph packages: ${this._packageGraph.getPackages().length}`, '[SDK.createPackageGraph][end]');
+        }
+    }
+    async writeStore(options) {
+        rsdoctorLogger.debug("sdk.writeStore has run.", '[SDK.writeStore][end]');
+        let htmlPath = '';
+        if (this.extraConfig?.mode === SDK.IMode[SDK.IMode.brief]) {
+            let clientHtmlPath = this.extraConfig.innerClientPath ? this.extraConfig.innerClientPath : sdk_require.resolve('@rsdoctor/client');
+            if (this.extraConfig?.brief?.type?.includes('json')) {
+                let data = this.getStoreData(), clientRoutes = this.getClientRoutes();
+                node_fs.mkdirSync(this.outputDir, {
+                    recursive: !0
+                }), node_fs.writeFileSync(path_0.resolve(this.outputDir, this.extraConfig.brief.jsonOptions?.fileName ?? 'rsdoctor-data.json'), JSON.stringify({
+                    data,
+                    clientRoutes
+                }));
+            }
+            return this.extraConfig.brief?.type?.includes('html') && (htmlPath = this.inlineScriptsAndStyles(clientHtmlPath)), htmlPath;
+        }
+        return this.saveManifest(this.getStoreData(), options || {});
+    }
+    getStoreData() {
+        let ctx = this, briefOptions = this.extraConfig?.brief, sections = briefOptions?.jsonOptions?.sections, isJsonType = briefOptions?.type?.includes('json');
+        return {
+            get hash () {
+                return ctx.hash;
+            },
+            get root () {
+                return ctx.root;
+            },
+            get envinfo () {
+                return ctx._envinfo;
+            },
+            get pid () {
+                return ctx.pid;
+            },
+            get errors () {
+                if (isJsonType && sections && !sections.rules) return [];
+                return ctx._errors.map((err)=>err.toData());
+            },
+            get configs () {
+                return ctx._configs.slice();
+            },
+            get summary () {
+                return {
+                    ...ctx._summary
+                };
+            },
+            get resolver () {
+                return ctx._resolver.slice();
+            },
+            get loader () {
+                return ctx._loader.slice();
+            },
+            get moduleGraph () {
+                if (isJsonType && sections && !sections.moduleGraph) return {
+                    dependencies: [],
+                    modules: [],
+                    moduleGraphModules: [],
+                    exports: [],
+                    sideEffects: [],
+                    variables: [],
+                    layers: []
+                };
+                return ctx._moduleGraph.toData({
+                    contextPath: ctx._configs?.[0]?.config?.context || '',
+                    briefOptions
+                });
+            },
+            get chunkGraph () {
+                if (isJsonType && sections && !sections.chunkGraph) return {
+                    assets: [],
+                    chunks: [],
+                    entrypoints: []
+                };
+                return ctx._chunkGraph.toData(ctx.type);
+            },
+            get moduleCodeMap () {
+                if (ctx.extraConfig?.mode === SDK.IMode[SDK.IMode.brief]) return {};
+                return ctx._moduleGraph.toCodeData(ctx.type);
+            },
+            get plugin () {
+                return {
+                    ...ctx._plugin
+                };
+            },
+            get packageGraph () {
+                return ctx._packageGraph ? ctx._packageGraph.toData() : {
+                    packages: [],
+                    dependencies: []
+                };
+            },
+            get treeShaking () {
+                if (ctx.extraConfig?.mode === SDK.IMode[SDK.IMode.brief] || !ctx.extraConfig?.features?.treeShaking) return;
+                return ctx._moduleGraph.toTreeShakingData();
+            },
+            get otherReports () {
+                return {
+                    treemapReportHtml: ''
+                };
+            }
+        };
+    }
+    getManifestData() {
+        let dataValue = this.getStoreData();
+        return {
+            client: {
+                enableRoutes: this.getClientRoutes()
+            },
+            data: Object.keys(dataValue).reduce((t, e)=>(dataValue[e] && 'object' == typeof dataValue[e] ? t[e] = [
+                    `${this.server.origin}${SDK.ServerAPI.API.LoadDataByKey}/${e}`
+                ] : t[e] = dataValue[e], t), {}),
+            __LOCAL__SERVER__: !0,
+            __SOCKET__PORT__: this.server.socketUrl.port.toString(),
+            __SOCKET__URL__: this.server.socketUrl.socketUrl
+        };
+    }
+    getRuleContext(_options) {
+        return this.createPackageGraph(), {
+            root: this.root,
+            errors: this._errors.slice(),
+            configs: this._configs.slice(),
+            moduleGraph: this._moduleGraph,
+            chunkGraph: this._chunkGraph,
+            packageGraph: this._packageGraph,
+            loader: this._loader.slice(),
+            otherReports: {
+                treemapReportHtml: ''
+            }
+        };
+    }
+    onDataReport() {
+        this.server.broadcast();
+    }
+    addRsdoctorDataToHTML(storeData, htmlContent) {
+        let compressTextScripts = `<script>window.${Constants.WINDOW_RSDOCTOR_TAG}={}</script>`;
+        for (let key of Object.keys(storeData)){
+            let data = storeData[key], jsonStrFn = ()=>{
+                try {
+                    if ('configs' === key) return JSON.stringify(decycle(data));
+                    return JSON.stringify(data);
+                } catch (error) {
+                    return console.error(error), '';
+                }
+            }, compressText = Algorithm.compressText(jsonStrFn());
+            compressTextScripts = `${compressTextScripts} <script>window.${Constants.WINDOW_RSDOCTOR_TAG}.${key}=${JSON.stringify(compressText)}</script>`;
+        }
+        return compressTextScripts = `${compressTextScripts} <script>window.${Constants.WINDOW_RSDOCTOR_TAG}.enableRoutes=${JSON.stringify(this.getClientRoutes())}</script>`, htmlContent = htmlContent.replace('<body>', `<body>${compressTextScripts}`);
+    }
+    inlineScriptsAndStyles(htmlFilePath) {
+        function resolveFilePath(basePath, filePath) {
+            return filePath.startsWith('/') ? path_0.resolve(basePath, filePath.slice(1)) : path_0.resolve(basePath, filePath);
+        }
+        let htmlContent = node_fs.readFileSync(htmlFilePath, 'utf-8'), basePath = path_0.dirname(htmlFilePath), scriptSrcs = Array.from(htmlContent.matchAll(/<script\s+(?:defer="defer"|defer)\s+src=["'](.+?)["']><\/script>/g), (m)=>m[1]), cssHrefs = Array.from(htmlContent.matchAll(/<link\s+href=["'](.+?)["']\s+rel="stylesheet">/g), (m)=>m[1]);
+        htmlContent = (htmlContent = htmlContent.replace(/<script\s+.*?src=["'].*?["']><\/script>/g, '')).replace(/<link\s+.*?rel=["']stylesheet["'].*?>/g, '');
+        let inlinedScripts = scriptSrcs.map((src)=>{
+            let scriptPath = resolveFilePath(basePath, src);
+            try {
+                let scriptContent = node_fs.readFileSync(scriptPath, 'utf-8');
+                return `<script>${scriptContent}</script>`;
+            } catch (error) {
+                return console.error(`Could not read script at ${scriptPath}:`, error), '';
+            }
+        }).join(''), inlinedCss = cssHrefs.map((href)=>{
+            let cssPath = resolveFilePath(basePath, href);
+            try {
+                let cssContent = node_fs.readFileSync(cssPath, 'utf-8');
+                return `<style>${cssContent}</style>`;
+            } catch (error) {
+                return console.error(`Could not read CSS at ${cssPath}:`, error), '';
+            }
+        }).join(''), index = htmlContent.indexOf('</body>');
+        htmlContent = htmlContent.slice(0, index) + inlinedCss + inlinedScripts + htmlContent.slice(index), htmlContent = this.addRsdoctorDataToHTML(this.getStoreData(), htmlContent);
+        let outputFilePath = path_0.resolve(this.outputDir, this.extraConfig?.brief?.htmlOptions?.reportHtmlName || 'rsdoctor-report.html');
+        return node_fs.mkdirSync(path_0.dirname(outputFilePath), {
+            recursive: !0
+        }), node_fs.writeFileSync(outputFilePath, htmlContent, {
+            encoding: 'utf-8',
+            flag: 'w'
+        }), outputFilePath;
+    }
+}
+class RsdoctorSlaveServer extends RsdoctorServer {
+    constructor(sdk, port = defaultPort, config){
+        super(sdk, port, config), this.sdk = sdk;
+    }
+    async openClientPage(...args) {
+        return this.sdk.isMaster ? super.openClientPage(...args) : Promise.resolve();
+    }
+}
+let primary_id = 1;
+class RsdoctorPrimarySDK extends RsdoctorSDK {
+    constructor({ name, stage, controller, extraConfig, type }){
+        super({
+            name,
+            root: controller.root,
+            config: extraConfig
+        });
+        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, {
+            cors: extraConfig?.server?.cors
+        }), this.type = type, this.setName(name), this.clearSwitch();
+    }
+    clearSwitch() {
+        this.uploadPieces = new Promise((resolve)=>{
+            this.finishUploadPieceSwitch = resolve;
+        });
+    }
+    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?.();
+    }
+    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 result = await super.writeManifest();
+        return this.clearSwitch(), result;
+    }
+    getSeriesData(serverUrl = !1) {
+        return this.parent.getSeriesData(serverUrl);
+    }
+    setName(name) {
+        this._name = this.parent.hasName(name) ? `${name}-${primary_id}` : name;
+    }
+    getManifestData() {
+        let data = super.getManifestData();
+        return data.name = this.name, data.series = this.getSeriesData(!0), data;
+    }
+}
+class RsdoctorSDKController {
+    constructor(root = process.cwd()){
+        this.slaves = [], this.root = '', this.root = root;
+    }
+    get master() {
+        return this.slaves[0];
+    }
+    getLastSdk() {
+        return this.slaves[this.slaves.length - 1];
+    }
+    hasName(name) {
+        return !!this.slaves.find((item)=>item.name === name);
+    }
+    getSeriesData(serverUrl = !1) {
+        return this.slaves.map((item)=>{
+            let data = {
+                name: item.name,
+                path: item.diskManifestPath,
+                stage: item.stage
+            };
+            return serverUrl && (data.origin = item.server.origin), data;
+        });
+    }
+    createSlave({ name, stage, extraConfig, type }) {
+        let slave = new RsdoctorPrimarySDK({
+            name,
+            stage,
+            controller: this,
+            extraConfig,
+            type
+        });
+        return this.slaves.push(slave), this.slaves.sort((a, b)=>a.stage - b.stage), slave;
+    }
+}
+let packageJson = external_node_module_createRequire(import.meta.url)(existsSync(new URL('../package.json', import.meta.url)) ? '../package.json' : '../../package.json'), pluginTapName = 'RsdoctorRspackPlugin', pluginTapPostOptions = {
+    name: pluginTapName,
+    stage: 999
+}, hasGreeted = !1;
+class RsdoctorRspackPlugin {
+    constructor(options){
+        this.name = pluginTapName, this.browserIsOpened = !1, this.afterPlugins = (compiler)=>{
+            logger_time('RsdoctorRspackPlugin.afterPlugins');
+            try {
+                this.getRspackConfig(compiler);
+            } finally{
+                timeEnd('RsdoctorRspackPlugin.afterPlugins');
+            }
+        }, this.done = async (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([
+                    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();
+            } finally{
+                timeEnd('RsdoctorRspackPlugin.done');
+            }
+        }, this.options = normalizeRspackUserOptions(Object.assign(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.outsideInstance = !!sdkInstance, this.modulesGraph = new ModuleGraph(), this.isRsdoctorPlugin = !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');
+        }
+    }
+    ensureModulesChunksGraphApplied(compiler) {
+        ensureModulesChunksGraphFn(compiler, this);
+    }
+    getRspackConfig(compiler) {
+        logger_time('RsdoctorRspackPlugin.getRspackConfig');
+        try {
+            if (compiler.isChild()) return;
+            let configuration = processCompilerConfig(compiler.options), { rspackVersion } = compiler.rspack;
+            this.sdk.reportConfiguration({
+                name: 'rspack',
+                version: rspackVersion || 'unknown',
+                config: configuration,
+                root: findRoot() || ''
+            });
+        } finally{
+            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,
+            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
+            },
+            type: normallizedOptions.output.reportCodeType
+        });
+        super({
+            ...options,
+            sdkInstance: instance
+        }), this.controller = controller;
+    }
+    apply(compiler) {
+        'dependencies' in compiler.options && (this.sdk.dependencies = compiler.options.dependencies), super.apply(compiler);
+    }
+}
+export { Linter, LinterRule, LinterType, defineRule, rules } from "./26.js";
+export { logger } from "./630.js";
+export { RsdoctorRspackMultiplePlugin, RsdoctorRspackPlugin, RsdoctorSDK, resolveClientDiffHtmlPath };