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

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

@@ -11,5 +11,5 @@ export declare class InternalBundlePlugin<T extends Plugin.BaseCompiler> extends
         content: string;
     };
     thisCompilation: (compilation: Plugin.BaseCompilation) => void;
-    done: () => Promise<void>;
+    done: (compiler: T) => Promise<void>;
 }

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/loader.d.ts

@@ -2,9 +2,11 @@ import { Plugin } from '@rsdoctor/shared/types';
 import { InternalBasePlugin } from './base.js';
 export declare class InternalLoaderPlugin<T extends Plugin.BaseCompiler> extends InternalBasePlugin<T> {
     readonly name = "loader";
+    private cacheMarkerPath?;
     readonly internalLoaderPath: string;
     apply(compiler: T): void;
     afterPlugins: (compiler: T) => void;
     compilation(compiler: T, compilation: Plugin.BaseCompilation): void;
     getInterceptRules(compiler: T, rules: Plugin.BuildRuleSetRules): Plugin.BuildRuleSetRule[];
+    private getCacheMarkerPath;
 }

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/config.d.ts

@@ -1,4 +1,6 @@
 import { Linter, Plugin, SDK } from '@rsdoctor/shared/types';
+export declare function isCompilerWatching(compiler: Pick<Plugin.BaseCompiler, 'watchMode' | 'parentCompilation'>): boolean;
+export declare function getEffectiveGzipConfig(compiler: Pick<Plugin.BaseCompiler, 'watchMode' | 'parentCompilation'>, gzip: Plugin.NormalizedGzipConfig): Plugin.NormalizedGzipConfig;
 export declare function normalizeUserConfig<Rules extends Linter.ExtendRuleData[]>(config?: Plugin.RsdoctorRspackPluginOptions<Rules>): Plugin.RsdoctorPluginOptionsNormalized<Rules>;
-export declare const normalizeReportType: (reportCodeType: Plugin.IReportCodeType | Plugin.NewReportCodeType, mode: keyof typeof SDK.IMode) => SDK.ToDataType;
+export declare const normalizeReportType: (reportCodeType: Plugin.NewReportCodeType | undefined, mode: keyof typeof SDK.IMode) => SDK.ToDataType;
 export declare const normalizeRspackUserOptions: typeof normalizeUserConfig;

package/dist/inner-plugins/utils/normalize-config.d.ts

@@ -3,19 +3,14 @@ import type { RuleSetCondition as RspackRuleSetCondition, RuleSetRule as RspackR
 /**
  * Process mode-specific configurations with priority logic
  */
-export declare function processModeConfigurations(finalMode: keyof typeof SDK.IMode, output: Config.IOutput<'brief' | 'normal'>, brief: Config.BriefConfig | undefined): {
+export declare function processModeConfigurations(finalMode: keyof typeof SDK.IMode, output: Config.IOutput<'brief' | 'normal'>): {
     finalBrief: {};
     finalNormalOptions: Config.NormalModeOptions;
 };
 /**
- * Process brief mode configuration with priority logic
- * Priority: output.options.briefOptions > output.brief > default
+ * Process brief mode configuration.
  */
-export declare function processBriefHtmlModeConfig(output: Config.BriefModeConfig, brief: Config.BriefConfig | undefined): Config.BriefModeOptions;
-/**
- * Convert reportCodeType object to NewReportCodeType enum value
- */
-export declare function convertReportCodeTypeObject(reportCodeType: any): Config.NewReportCodeType | undefined;
+export declare function processBriefHtmlModeConfig(output: Config.BriefModeConfig): Config.BriefModeOptions;
 /**
  * This function recursively processes rule set conditions to ensure they can be
  * properly serialized to JSON.

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

@@ -0,0 +1,2 @@
+import { DevToolError } from '../../error/index.js';
+export declare function summarizeRuleWarnings(warnings: DevToolError[]): DevToolError[];

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/proxy-loader.js

@@ -1,9 +1,13 @@
 import "node:module";
-import { shouldSkipLoader, reportLoader, getOriginLoaderModule } from "./26.js";
+import { shouldSkipLoader, reportLoader, getInternalLoaderOptions, getOriginLoaderModule } from "./26.js";
 import { createLoaderContextTrap } from "./630.js";
+function addCacheMarkerDependency(context) {
+    let { cacheMarkerPath } = getInternalLoaderOptions(context);
+    cacheMarkerPath && context.addBuildDependency(cacheMarkerPath);
+}
 let loaderModule = function(...args) {
     if (shouldSkipLoader(this)) return void this.callback(null, ...args);
-    this.cacheable(!1);
+    addCacheMarkerDependency(this);
     let mod = getOriginLoaderModule(this);
     if (mod.default) {
         !1 === mod.raw && Buffer.isBuffer(args[0]) && (args[0] = args[0].toString());
@@ -24,7 +28,7 @@ let loaderModule = function(...args) {
     this.callback(null, ...args);
 }, pitch = function() {
     if (shouldSkipLoader(this)) return;
-    this.cacheable(!1);
+    addCacheMarkerDependency(this);
     let mod = getOriginLoaderModule(this);
     if (mod.pitch && 'function' == typeof mod.pitch) {
         let start = 0, startHRTime = [

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

@@ -1,2 +1 @@
 export * from './plugin.js';
-export * from './multiple.js';

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

@@ -1,25 +1,55 @@
-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<void>;
+    applied: boolean;
+    hasOpenedClientAutomatically: 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 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<void>;
+    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 ensureBootstrap;
+    private awaitBootstrap;
+    private clearBootstrapTask;
+    private disposeSDK;
+    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,19 @@
+import { RsdoctorSDKController } from '../sdk/index.js';
+export interface RsdoctorBuildSessionOptions {
+    multiCompiler: {
+        enabled: boolean;
+        group?: string;
+    };
+    output: {
+        mode: string;
+        reportDir: string;
+    };
+    server: {
+        port?: number;
+    };
+}
+export interface RsdoctorBuildSessionLease {
+    controller: RsdoctorSDKController;
+    release(): void;
+}
+export declare function acquireBuildSession(options: RsdoctorBuildSessionOptions): RsdoctorBuildSessionLease;

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

@@ -0,0 +1,2 @@
+import type { Plugin, SDK } from '@rsdoctor/shared/types';
+export declare function getWriteStoreOptions(compiler: Pick<Plugin.BaseCompiler, 'watchMode' | 'parentCompilation'>): SDK.WriteStoreOptionsType | undefined;

package/dist/rule-utils/parser/utils.d.ts

@@ -1,13 +1,10 @@
 import { ecmaVersion } from 'acorn';
 import { Node, ECMAVersion } from './types.js';
 /**
- * Is the node semantics the same?
- * @deprecated
- * - Recursively compare whether the content of the node itself is the same
- * - Ignore comments, positions, string symbols (single and double quotation marks)
- * - String templates and string addition will be considered different
+ * Recursively compare node semantics while ignoring comments, positions, and
+ * string quote styles. String templates and string addition remain distinct.
  */
-export declare function isSameSemantics(node1: Node.SyntaxNode, node2: Node.SyntaxNode): boolean;
+export declare function isSameSyntax(node1: Node.SyntaxNode, node2: Node.SyntaxNode): boolean;
 /**
  * Get all default reference statements
  */

package/dist/rules/rules/ecma-version-check/index.d.ts

@@ -1,4 +1,4 @@
-import { Config } from './types.js';
+import type { Config } from './types.js';
 import { Linter } from '@rsdoctor/shared/types';
 export type { Config } from './types.js';
 declare const title = "ecma-version-check";

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

@@ -1,8 +1,12 @@
-import { Manifest, SDK } from '@rsdoctor/shared/types';
+import { Common, Manifest, SDK } from '@rsdoctor/shared/types';
 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 writePieces(_storeData: Common.PlainObject, options?: SDK.WriteStoreOptionsType): 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/dist/sdk/sdk/core.d.ts

@@ -24,10 +24,11 @@ export declare abstract class SDKCore<T extends RsdoctorSDKOptions> implements S
     getClientRoutes(): Manifest.RsdoctorManifestClientRoutes[];
     addClientRoutes(routes: Manifest.RsdoctorManifestClientRoutes[]): void;
     /** Upload analysis data pieces */
-    protected writePieces(storeData: Common.PlainObject, _options?: SDK.WriteStoreOptionsType): Promise<void>;
+    protected writePieces(storeData: Common.PlainObject, options?: SDK.WriteStoreOptionsType): Promise<void>;
     /** Upload manifest file */
     protected writeManifest(): Promise<string>;
     saveManifest(data: Common.PlainObject, options: SDK.WriteStoreOptionsType): Promise<string>;
-    protected writeToFolder(jsonStr: string, dir: string, key: string, index?: number): Promise<DataWithUrl>;
+    protected writeToFolder(jsonStr: string, dir: string, key: string, index?: number, compressionLevel?: number): Promise<DataWithUrl>;
+    protected writeJsonFragmentsToFolder(jsonFragments: string[], dir: string, key: string, index?: number, compressionLevel?: number): Promise<DataWithUrl>;
     abstract onDataReport(): void | Promise<void>;
 }

package/dist/sdk/sdk/types.d.ts

@@ -4,7 +4,7 @@ export interface DataWithUrl {
     files: {
         path: string;
         basename: string;
-        content: Buffer;
+        content?: Buffer;
     }[] | string;
 }
 export interface RsdoctorSDKOptions {

package/dist/sdk/utils/index.d.ts

@@ -1,3 +1,4 @@
 export * from './constant.js';
 export * from './base.js';
 export * from './upload.js';
+export * from './manifestSharding.js';

package/dist/sdk/utils/manifestSharding.d.ts

@@ -0,0 +1,16 @@
+export declare const DEFAULT_MANIFEST_SHARD_SIZE: number;
+interface WriteManifestShardsOptions {
+    index?: number;
+    shardSize?: number;
+    compressionLevel?: number;
+}
+export interface ManifestShardFile {
+    path: string;
+    basename: string;
+}
+/**
+ * Compress JSON fragments as one deflate stream, encode that stream as one
+ * continuous Base64 value, and write bounded physical shards.
+ */
+export declare function writeManifestShards(jsonFragments: string[], folder: string, options?: WriteManifestShardsOptions): Promise<ManifestShardFile[]>;
+export {};

package/dist/types/loader.d.ts

@@ -1,5 +1,10 @@
 import { Loader } from '@rsdoctor/shared/common-browser';
 export interface ProxyLoaderInternalOptions {
+    /**
+     * A session marker registered as a loader build dependency so persistent
+     * caches are invalidated when a new Rsdoctor session starts.
+     */
+    cacheMarkerPath?: string;
     cwd: string;
     /**
      * the url host of http server(which used to collect data).

package/dist/types/plugin.d.ts

@@ -1,12 +1,4 @@
 import type { Linter, Linter as LinterType, Plugin, SDK } from '@rsdoctor/shared/types';
-export interface RsdoctorMultiplePluginOptions<Rules extends LinterType.ExtendRuleData[] = LinterType.ExtendRuleData[]> extends Omit<Plugin.RsdoctorRspackPluginOptions<Rules>, 'sdkInstance'>, Pick<{
-    stage?: number;
-}, 'stage'> {
-    /**
-     * name of builder
-     */
-    name?: string;
-}
 export interface BasePluginInstance<T extends Plugin.BaseCompiler> {
     apply: (compiler: T) => void;
     [k: string]: any;

package/package.json

@@ -1,21 +1,12 @@
 {
   "name": "@rsdoctor/core",
-  "version": "2.0.0-alpha.2",
+  "version": "2.0.0-beta.1",
   "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": {
     ".": {
@@ -27,6 +18,8 @@
       "default": "./dist/proxy-loader.js"
     }
   },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "typesVersions": {
     "*": {
       ".": [
@@ -37,6 +30,10 @@
       ]
     }
   },
+  "files": [
+    "dist",
+    "static"
+  ],
   "dependencies": {
     "@babel/code-frame": "7.26.2",
     "@rspack/lite-tapable": "^1.1.5",
@@ -45,42 +42,41 @@
     "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.30001810",
+    "connect-next": "4.0.3",
+    "cors": "2.8.6",
     "envinfo": "7.21.0",
     "fs-extra": "^11.1.1",
     "get-port": "5.1.1",
+    "launch-editor": "^2.14.1",
     "lines-and-columns": "2.0.4",
-    "open": "^11.0.0",
+    "open": "^11.0.2",
     "raw-body": "3.0.2",
     "rslog": "^2.1.3",
     "semver": "^7.8.5",
-    "source-map": "^0.7.6",
-    "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"
+    "source-map": "^0.7.6",
+    "ws": "8.21.3",
+    "@rsdoctor/client": "2.0.0-beta.1",
+    "@rsdoctor/shared": "2.0.0-beta.1"
   },
   "devDependencies": {
     "@rsbuild/plugin-check-syntax": "^1.6.1",
-    "@rspack/core": "^2.1.7",
+    "@rspack/core": "^2.1.10",
     "@types/babel__code-frame": "7.27.0",
-    "@types/connect": "3.4.38",
+    "@types/cors": "2.8.19",
     "@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",
+    "@types/ws": "^8.18.1",
     "babel-loader": "10.1.1",
-    "filesize": "^11.0.22",
+    "filesize": "^11.0.23",
     "json-stream-stringify": "3.0.1",
     "string-loader": "0.0.1",
     "ts-loader": "^9.6.2",
     "tslib": "2.8.1",
     "typescript": "^7.0.2",
-    "@types/cors": "2.8.19",
-    "@types/ws": "^8.18.1",
     "@scripts/test-helper": "0.1.1"
   },
   "peerDependencies": {
@@ -91,14 +87,17 @@
       "optional": true
     }
   },
+  "engines": {
+    "node": ">=22.18.0"
+  },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
+    "build": "rs lib",
     "dev": "npm run start",
-    "build": "rslib build",
-    "start": "rslib build -w",
-    "test": "rstest run"
+    "start": "rs lib -w",
+    "test": "rs test"
   }
 }

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

@@ -1,8 +0,0 @@
-import type { RsdoctorMultiplePluginOptions } from '../types/index.js';
-import { type Linter, type Plugin } from '@rsdoctor/shared/types';
-import { RsdoctorRspackPlugin } from './plugin.js';
-export declare class RsdoctorRspackMultiplePlugin<Rules extends Linter.ExtendRuleData[]> extends RsdoctorRspackPlugin<Rules> {
-    private controller;
-    constructor(options?: RsdoctorMultiplePluginOptions<Rules>);
-    apply(compiler: Plugin.BaseCompilerType<'rspack'>): void;
-}