@rspack/core 1.0.4 → 1.0.6

package/dist/Chunk.d.ts

@@ -23,6 +23,11 @@ export declare class Chunk {
     canBeInitial(): boolean;
     hasRuntime(): boolean;
     get groupsIterable(): Iterable<ChunkGroup>;
+    getChunkMaps(realHash: boolean): {
+        hash: Record<string | number, string>;
+        contentHash: Record<string | number, Record<string, string>>;
+        name: Record<string | number, string>;
+    };
     getAllAsyncChunks(): Iterable<Chunk>;
     getAllInitialChunks(): Iterable<Chunk>;
     getAllReferencedChunks(): Iterable<Chunk>;

package/dist/Chunk.js

@@ -60,6 +60,34 @@ class Chunk {
         chunk_groups.sort(comparators_1.compareChunkGroupsByIndex);
         return new Set(chunk_groups);
     }
+    getChunkMaps(realHash) {
+        const chunkHashMap = {};
+        const chunkContentHashMap = {};
+        const chunkNameMap = {};
+        for (const chunk of this.getAllAsyncChunks()) {
+            const id = chunk.id;
+            if (!id)
+                continue;
+            const chunkHash = realHash ? chunk.hash : chunk.renderedHash;
+            if (chunkHash) {
+                chunkHashMap[id] = chunkHash;
+            }
+            for (const key of Object.keys(chunk.contentHash)) {
+                if (!chunkContentHashMap[key]) {
+                    chunkContentHashMap[key] = {};
+                }
+                chunkContentHashMap[key][id] = chunk.contentHash[key];
+            }
+            if (chunk.name) {
+                chunkNameMap[id] = chunk.name;
+            }
+        }
+        return {
+            hash: chunkHashMap,
+            contentHash: chunkContentHashMap,
+            name: chunkNameMap
+        };
+    }
     getAllAsyncChunks() {
         return new Set((0, binding_1.__chunk_inner_get_all_async_chunks)(__classPrivateFieldGet(this, _Chunk_inner, "f").__inner_ukey, __classPrivateFieldGet(this, _Chunk_innerCompilation, "f")).map(c => Chunk.__from_binding(c, __classPrivateFieldGet(this, _Chunk_innerCompilation, "f"))));
     }

package/dist/Compilation.d.ts

@@ -21,6 +21,7 @@ import { type CodeGenerationResult, Module } from "./Module";
 import type { NormalModuleFactory } from "./NormalModuleFactory";
 import type { ResolverFactory } from "./ResolverFactory";
 import { type RspackError } from "./RspackError";
+import { RuntimeModule } from "./RuntimeModule";
 import { Stats, type StatsAsset, type StatsError, type StatsModule } from "./Stats";
 import type { Filename, OutputNormalized, RspackOptionsNormalized, RspackPluginInstance, StatsOptions, StatsValue } from "./config";
 import { Logger } from "./logging/Logger";
@@ -43,10 +44,6 @@ export interface LogEntry {
     time?: number;
     trace?: string[];
 }
-export type RuntimeModule = liteTapable.SyncHook<[
-    JsRuntimeModule,
-    Chunk
-], void>;
 export interface CompilationParams {
     normalModuleFactory: NormalModuleFactory;
     contextModuleFactory: ContextModuleFactory;
@@ -167,7 +164,11 @@ export declare class Compilation {
             Chunk,
             Set<string>
         ], void>;
-        runtimeModule: RuntimeModule;
+        runtimeRequirementInTree: liteTapable.SyncBailHook<[
+            Chunk,
+            Set<string>
+        ], void>;
+        runtimeModule: liteTapable.SyncHook<[JsRuntimeModule, Chunk], void>;
         seal: liteTapable.SyncHook<[], void>;
         afterSeal: liteTapable.AsyncSeriesHook<[], void>;
     }>;
@@ -256,13 +257,19 @@ export declare class Compilation {
      *
      * @internal
      */
-    __internal__pushDiagnostic(diagnostic: binding.JsDiagnostic): void;
+    __internal__pushRspackDiagnostic(diagnostic: binding.JsRspackDiagnostic): void;
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal__pushDiagnostic(diagnostic: ExternalObject<"Diagnostic">): void;
     /**
      * Note: This is not a webpack public API, maybe removed in future.
      *
      * @internal
      */
-    __internal__pushNativeDiagnostics(diagnostics: ExternalObject<"Diagnostic[]">): void;
+    __internal__pushDiagnostics(diagnostics: ExternalObject<"Diagnostic[]">): void;
     get errors(): RspackError[];
     get warnings(): RspackError[];
     getPath(filename: Filename, data?: PathData): string;
@@ -297,6 +304,7 @@ export declare class Compilation {
     getStats(): Stats;
     createChildCompiler(name: string, outputOptions: OutputNormalized, plugins: RspackPluginInstance[]): Compiler;
     rebuildModule(m: Module, f: (err: Error, m: Module) => void): void;
+    addRuntimeModule(chunk: Chunk, runtimeModule: RuntimeModule): void;
     /**
      * Get the `Source` of a given asset filename.
      *

package/dist/Compilation.js

@@ -48,6 +48,7 @@ const Entrypoint_1 = require("./Entrypoint");
 const ErrorHelpers_1 = require("./ErrorHelpers");
 const Module_1 = require("./Module");
 const RspackError_1 = require("./RspackError");
+const RuntimeModule_1 = require("./RuntimeModule");
 const Stats_1 = require("./Stats");
 const Logger_1 = require("./logging/Logger");
 const StatsFactory_1 = require("./stats/StatsFactory");
@@ -159,6 +160,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 "chunk",
                 "runtimeRequirements"
             ]),
+            runtimeRequirementInTree: new liteTapable.SyncBailHook([
+                "chunk",
+                "runtimeRequirements"
+            ]),
             runtimeModule: new liteTapable.SyncHook(["module", "chunk"]),
             seal: new liteTapable.SyncHook([]),
             afterSeal: new liteTapable.AsyncSeriesHook([])
@@ -374,7 +379,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
      *
      * @internal
      */
-    __internal__pushDiagnostic(diagnostic) {
+    __internal__pushRspackDiagnostic(diagnostic) {
         __classPrivateFieldGet(this, _Compilation_inner, "f").pushDiagnostic(diagnostic);
     }
     /**
@@ -382,7 +387,15 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
      *
      * @internal
      */
-    __internal__pushNativeDiagnostics(diagnostics) {
+    __internal__pushDiagnostic(diagnostic) {
+        __classPrivateFieldGet(this, _Compilation_inner, "f").pushNativeDiagnostic(diagnostic);
+    }
+    /**
+     * Note: This is not a webpack public API, maybe removed in future.
+     *
+     * @internal
+     */
+    __internal__pushDiagnostics(diagnostics) {
         __classPrivateFieldGet(this, _Compilation_inner, "f").pushNativeDiagnostics(diagnostics);
     }
     get errors() {
@@ -394,7 +407,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 handler(target, thisArg, errs) {
                     for (let i = 0; i < errs.length; i++) {
                         const error = errs[i];
-                        inner.pushDiagnostic(RspackError_1.JsDiagnostic.__to_binding(error, binding_1.JsRspackSeverity.Error));
+                        inner.pushDiagnostic(RspackError_1.JsRspackDiagnostic.__to_binding(error, binding_1.JsRspackSeverity.Error));
                     }
                     return Reflect.apply(target, thisArg, errs);
                 }
@@ -417,7 +430,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 method: "unshift",
                 handler(target, thisArg, errs) {
                     const errList = errs.map(error => {
-                        return RspackError_1.JsDiagnostic.__to_binding(error, binding_1.JsRspackSeverity.Error);
+                        return RspackError_1.JsRspackDiagnostic.__to_binding(error, binding_1.JsRspackSeverity.Error);
                     });
                     inner.spliceDiagnostic(0, 0, errList);
                     return Reflect.apply(target, thisArg, errs);
@@ -427,7 +440,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 method: "splice",
                 handler(target, thisArg, [startIdx, delCount, ...errors]) {
                     const errList = errors.map(error => {
-                        return RspackError_1.JsDiagnostic.__to_binding(error, binding_1.JsRspackSeverity.Error);
+                        return RspackError_1.JsRspackDiagnostic.__to_binding(error, binding_1.JsRspackSeverity.Error);
                     });
                     inner.spliceDiagnostic(startIdx, startIdx + delCount, errList);
                     return Reflect.apply(target, thisArg, [
@@ -455,7 +468,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 method: "push",
                 handler(target, thisArg, warns) {
                     return Reflect.apply(target, thisArg, processWarningsHook.call(warns).map(warn => {
-                        inner.pushDiagnostic(RspackError_1.JsDiagnostic.__to_binding(warn, binding_1.JsRspackSeverity.Warn));
+                        inner.pushDiagnostic(RspackError_1.JsRspackDiagnostic.__to_binding(warn, binding_1.JsRspackSeverity.Warn));
                         return warn;
                     }));
                 }
@@ -479,7 +492,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 handler(target, thisArg, warns) {
                     const warnings = processWarningsHook.call(warns);
                     inner.spliceDiagnostic(0, 0, warnings.map(warn => {
-                        return RspackError_1.JsDiagnostic.__to_binding(warn, binding_1.JsRspackSeverity.Warn);
+                        return RspackError_1.JsRspackDiagnostic.__to_binding(warn, binding_1.JsRspackSeverity.Warn);
                     }));
                     return Reflect.apply(target, thisArg, warnings);
                 }
@@ -489,7 +502,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                 handler(target, thisArg, [startIdx, delCount, ...warns]) {
                     warns = processWarningsHook.call(warns);
                     const warnList = warns.map(warn => {
-                        return RspackError_1.JsDiagnostic.__to_binding(warn, binding_1.JsRspackSeverity.Warn);
+                        return RspackError_1.JsRspackDiagnostic.__to_binding(warn, binding_1.JsRspackSeverity.Warn);
                     });
                     inner.spliceDiagnostic(startIdx, startIdx + delCount, warnList);
                     return Reflect.apply(target, thisArg, [
@@ -624,6 +637,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
     rebuildModule(m, f) {
         __classPrivateFieldGet(this, _Compilation_rebuildModuleCaller, "f").push([m.identifier(), f]);
     }
+    addRuntimeModule(chunk, runtimeModule) {
+        runtimeModule.attach(this, chunk, this.chunkGraph);
+        __classPrivateFieldGet(this, _Compilation_inner, "f").addRuntimeModule(chunk.__internal__innerUkey(), RuntimeModule_1.RuntimeModule.__to_binding(this, runtimeModule));
+    }
     /**
      * Get the `Source` of a given asset filename.
      *

package/dist/Compiler.js

@@ -220,8 +220,7 @@ class Compiler {
             let normalizedChildName = childName;
             if (typeof normalizedName === "function") {
                 if (typeof normalizedChildName === "function") {
-                    // @ts-expect-error
-                    return this.getInfrastructureLogger(_ => {
+                    return this.getInfrastructureLogger(() => {
                         if (typeof normalizedName === "function") {
                             normalizedName = normalizedName();
                             if (!normalizedName) {
@@ -268,12 +267,13 @@ class Compiler {
      */
     watch(watchOptions, handler) {
         if (this.running) {
-            // @ts-expect-error
+            // cannot be resolved without assertion
+            // copy from webpack
+            // Type 'void' is not assignable to type 'Watching'.
             return handler(new ConcurrentCompilationError_1.default());
         }
         this.running = true;
         this.watchMode = true;
-        // @ts-expect-error
         this.watching = new Watching_1.Watching(this, watchOptions, handler);
         return this.watching;
     }
@@ -287,7 +287,6 @@ class Compiler {
         const startTime = Date.now();
         this.running = true;
         const doRun = () => {
-            // @ts-expect-error
             const finalCallback = (err, stats) => {
                 this.idle = true;
                 this.cache.beginIdle();
@@ -426,11 +425,10 @@ class Compiler {
             ...__classPrivateFieldGet(childCompiler, _Compiler_builtinPlugins, "f"),
             ...__classPrivateFieldGet(this, _Compiler_builtinPlugins, "f").filter(plugin => plugin.canInherentFromParent === true)
         ], "f");
-        for (const name in this.hooks) {
+        for (const hookName in this.hooks) {
+            const name = hookName;
             if ((0, base_1.canInherentFromParent)(name)) {
-                //@ts-ignore
                 if (childCompiler.hooks[name]) {
-                    //@ts-ignore
                     childCompiler.hooks[name].taps = this.hooks[name].taps.slice();
                 }
             }
@@ -596,6 +594,13 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
                 runtimeRequirements: (0, RuntimeGlobals_1.__to_binding_runtime_globals)(set)
             };
         }),
+        registerCompilationRuntimeRequirementInTree: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationRuntimeRequirementInTree, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.runtimeRequirementInTree, queried => ({ chunk, runtimeRequirements }) => {
+            const set = (0, RuntimeGlobals_1.__from_binding_runtime_globals)(runtimeRequirements);
+            queried.call(Chunk_1.Chunk.__from_binding(chunk, __classPrivateFieldGet(this, _Compiler_compilation, "f")), set);
+            return {
+                runtimeRequirements: (0, RuntimeGlobals_1.__to_binding_runtime_globals)(set)
+            };
+        }),
         registerCompilationRuntimeModuleTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.CompilationRuntimeModule, () => __classPrivateFieldGet(this, _Compiler_compilation, "f").hooks.runtimeModule, queried => ({ module, chunk }) => {
             const originSource = module.source?.source;
             queried.call(module, Chunk_1.Chunk.__from_binding(chunk, __classPrivateFieldGet(this, _Compiler_compilation, "f")));
@@ -750,30 +755,11 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
         }),
         registerContextModuleFactoryAfterResolveTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_createHookRegisterTaps).call(this, binding.RegisterJsTapKind.ContextModuleFactoryAfterResolve, () => __classPrivateFieldGet(this, _Compiler_compilationParams, "f").contextModuleFactory.hooks.afterResolve, queried => async (bindingData) => {
             const data = bindingData
-                ? ({
-                    resource: bindingData.resource,
-                    regExp: bindingData.regExp
-                        ? new RegExp(bindingData.regExp.source, bindingData.regExp.flags)
-                        : undefined,
-                    request: bindingData.request,
-                    context: bindingData.context,
-                    // TODO: Dependencies are not fully supported yet; this is a placeholder to prevent errors in moment-locales-webpack-plugin.
-                    dependencies: []
-                })
+                ? Module_1.ContextModuleFactoryAfterResolveData.__from_binding(bindingData)
                 : false;
             const ret = await queried.promise(data);
             const result = ret
-                ? ({
-                    resource: ret.resource,
-                    context: ret.context,
-                    request: ret.request,
-                    regExp: ret.regExp
-                        ? {
-                            source: ret.regExp.source,
-                            flags: ret.regExp.flags
-                        }
-                        : undefined
-                })
+                ? Module_1.ContextModuleFactoryAfterResolveData.__to_binding(ret)
                 : false;
             return result;
         }),
@@ -849,7 +835,7 @@ _Compiler_instance = new WeakMap(), _Compiler_initial = new WeakMap(), _Compiler
         }
     }
     if (__classPrivateFieldGet(this, _Compiler_nonSkippableRegisters, "f").join() !== kinds.join()) {
-        __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_getInstance).call(this, (error, instance) => {
+        __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_getInstance).call(this, (_error, instance) => {
             instance.setNonSkippableRegisters(kinds);
             __classPrivateFieldSet(this, _Compiler_nonSkippableRegisters, kinds, "f");
         });

package/dist/Module.d.ts

@@ -1,7 +1,8 @@
-import type { JsCodegenerationResult, JsCreateData, JsFactoryMeta, JsModule, ModuleDTO } from "@rspack/binding";
+import type { JsCodegenerationResult, JsContextModuleFactoryAfterResolveData, JsCreateData, JsFactoryMeta, JsModule, ModuleDTO } from "@rspack/binding";
 import type { Source } from "../compiled/webpack-sources";
 import type { Compilation } from "./Compilation";
 import { DependenciesBlock } from "./DependenciesBlock";
+import type { Dependency } from "./Dependency";
 export type ResourceData = {
     resource: string;
     path: string;
@@ -28,13 +29,24 @@ export type ContextModuleFactoryBeforeResolveResult = false | {
     context: string;
     request?: string;
 };
-export type ContextModuleFactoryAfterResolveResult = false | {
-    resource: string;
-    context: string;
-    request: string;
-    regExp?: RegExp;
-    dependencies: Array<any>;
-};
+export declare class ContextModuleFactoryAfterResolveData {
+    #private;
+    static __from_binding(binding: JsContextModuleFactoryAfterResolveData): ContextModuleFactoryAfterResolveData;
+    static __to_binding(data: ContextModuleFactoryAfterResolveData): JsContextModuleFactoryAfterResolveData;
+    constructor(data: JsContextModuleFactoryAfterResolveData);
+    get resource(): string;
+    set resource(val: string);
+    get context(): string;
+    set context(val: string);
+    get request(): string;
+    set request(val: string);
+    get regExp(): RegExp | undefined;
+    set regExp(val: RegExp | undefined);
+    get recursive(): boolean;
+    set recursive(val: boolean);
+    get dependencies(): Dependency[];
+}
+export type ContextModuleFactoryAfterResolveResult = false | ContextModuleFactoryAfterResolveData;
 export declare class Module {
     #private;
     context?: Readonly<string>;

package/dist/Module.js

@@ -1,20 +1,79 @@
 "use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Module_inner, _Module_originalSource, _CodeGenerationResult_inner;
+var _ContextModuleFactoryAfterResolveData_inner, _Module_inner, _Module_originalSource, _CodeGenerationResult_inner;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodeGenerationResults = exports.CodeGenerationResult = exports.Module = void 0;
+exports.CodeGenerationResults = exports.CodeGenerationResult = exports.Module = exports.ContextModuleFactoryAfterResolveData = void 0;
 const DependenciesBlock_1 = require("./DependenciesBlock");
 const source_1 = require("./util/source");
+class ContextModuleFactoryAfterResolveData {
+    static __from_binding(binding) {
+        return new ContextModuleFactoryAfterResolveData(binding);
+    }
+    static __to_binding(data) {
+        return __classPrivateFieldGet(data, _ContextModuleFactoryAfterResolveData_inner, "f");
+    }
+    constructor(data) {
+        _ContextModuleFactoryAfterResolveData_inner.set(this, void 0);
+        __classPrivateFieldSet(this, _ContextModuleFactoryAfterResolveData_inner, data, "f");
+    }
+    get resource() {
+        return __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").resource;
+    }
+    set resource(val) {
+        __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").resource = val;
+    }
+    get context() {
+        return __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").context;
+    }
+    set context(val) {
+        __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").context = val;
+    }
+    get request() {
+        return __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").request;
+    }
+    set request(val) {
+        __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").request = val;
+    }
+    get regExp() {
+        if (!__classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").regExp) {
+            return undefined;
+        }
+        const { source, flags } = __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").regExp;
+        return new RegExp(source, flags);
+    }
+    set regExp(val) {
+        if (!val) {
+            __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").regExp = undefined;
+            return;
+        }
+        __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").regExp = {
+            source: val.source,
+            flags: val.flags
+        };
+    }
+    get recursive() {
+        return __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").recursive;
+    }
+    set recursive(val) {
+        __classPrivateFieldGet(this, _ContextModuleFactoryAfterResolveData_inner, "f").recursive = val;
+    }
+    get dependencies() {
+        // TODO: Dependencies are not fully supported yet; this is a placeholder to prevent errors in moment-locales-webpack-plugin.
+        return [];
+    }
+}
+exports.ContextModuleFactoryAfterResolveData = ContextModuleFactoryAfterResolveData;
+_ContextModuleFactoryAfterResolveData_inner = new WeakMap();
 class Module {
     static __from_binding(module, compilation) {
         return new Module(module, compilation);

package/dist/MultiCompiler.js

@@ -171,7 +171,6 @@ class MultiCompiler {
             }
             return false;
         };
-        // @ts-expect-error
         const sortEdges = (e1, e2) => {
             return (e1.source.name.localeCompare(e2.source.name) ||
                 e1.target.name.localeCompare(e2.target.name));
@@ -193,7 +192,6 @@ class MultiCompiler {
                 }
             }
         }
-        /** @type {string[]} */
         const errors = missing.map(m => `Compiler dependency \`${m}\` not found.`);
         const stack = this.compilers.filter(c => !targetFound(c));
         while (stack.length > 0) {
@@ -209,7 +207,6 @@ class MultiCompiler {
             }
         }
         if (edges.size > 0) {
-            /** @type {string[]} */
             const lines = Array.from(edges)
                 .sort(sortEdges)
                 .map(edge => `${edge.source.name} -> ${edge.target.name}`);
@@ -234,14 +231,8 @@ class MultiCompiler {
         }
         this.running = true;
         if (this.validateDependencies(handler)) {
-            const watchings = __classPrivateFieldGet(this, _MultiCompiler_instances, "m", _MultiCompiler_runGraph).call(this, 
-            // @ts-expect-error
-            (compiler, idx, done, isBlocked, setChanged, setInvalid) => {
-                const watching = compiler.watch(
-                // @ts-expect-error
-                Array.isArray(watchOptions) ? watchOptions[idx] : watchOptions, 
-                // @ts-expect-error
-                done);
+            const watchings = __classPrivateFieldGet(this, _MultiCompiler_instances, "m", _MultiCompiler_runGraph).call(this, (compiler, idx, done, isBlocked, setChanged, setInvalid) => {
+                const watching = compiler.watch(Array.isArray(watchOptions) ? watchOptions[idx] : watchOptions, done);
                 if (watching) {
                     watching.onInvalid = setInvalid;
                     watching.onChange = setChanged;
@@ -254,7 +245,6 @@ class MultiCompiler {
                 if (!watching.running)
                     watching.invalidate();
             }, handler);
-            // @ts-expect-error
             return new MultiWatching_1.default(watchings, this);
         }
         return new MultiWatching_1.default([], this);
@@ -282,13 +272,13 @@ class MultiCompiler {
         neo_async_1.default.each(this.compilers, (compiler, cb) => {
             compiler.close(cb);
         }, 
-        // @ts-expect-error
+        // cannot be resolved without assertion
+        // Type 'Error | null | undefined' is not assignable to type 'Error | null'
         callback);
     }
 }
 exports.MultiCompiler = MultiCompiler;
 _MultiCompiler_instances = new WeakSet(), _MultiCompiler_runGraph = function _MultiCompiler_runGraph(setup, run, callback) {
-    /** @typedef {{ compiler: Compiler, setupResult: SetupResult, result: Stats, state: "pending" | "blocked" | "queued" | "starting" | "running" | "running-outdated" | "done", children: Node[], parents: Node[] }} Node */
     // State transitions for nodes:
     // -> blocked (initial)
     // blocked -> starting [running++] (when all parents done)
@@ -332,12 +322,6 @@ _MultiCompiler_instances = new WeakSet(), _MultiCompiler_runGraph = function _Mu
     let errored = false;
     let running = 0;
     const parallelism = this._options.parallelism;
-    /**
-     * @param {Node} node node
-     * @param {Error=} err error
-     * @param {Stats=} stats result
-     * @returns {void}
-     */
     const nodeDone = (node, err, stats) => {
         if (errored)
             return;
@@ -401,8 +385,7 @@ _MultiCompiler_instances = new WeakSet(), _MultiCompiler_runGraph = function _Mu
      * @param {Node} node node
      * @returns {void}
      */
-    // @ts-expect-error
-    const nodeChange = node => {
+    const nodeChange = (node) => {
         nodeInvalid(node);
         if (node.state === "pending") {
             node.state = "blocked";
@@ -414,9 +397,7 @@ _MultiCompiler_instances = new WeakSet(), _MultiCompiler_runGraph = function _Mu
     };
     const setupResults = [];
     nodes.forEach((node, i) => {
-        setupResults.push((node.setupResult = setup(node.compiler, i, 
-        // @ts-expect-error
-        nodeDone.bind(null, node), () => node.state !== "starting" && node.state !== "running", () => nodeChange(node), () => nodeInvalid(node))));
+        setupResults.push((node.setupResult = setup(node.compiler, i, nodeDone.bind(null, node), () => node.state !== "starting" && node.state !== "running", () => nodeChange(node), () => nodeInvalid(node))));
     });
     let processing = true;
     const processQueue = () => {
@@ -433,7 +414,6 @@ _MultiCompiler_instances = new WeakSet(), _MultiCompiler_runGraph = function _Mu
                     node.parents.every(p => p.state === "done"))) {
                 running++;
                 node.state = "starting";
-                // @ts-expect-error
                 run(node.compiler, node.setupResult, nodeDone.bind(null, node));
                 node.state = "running";
             }

package/dist/MultiWatching.d.ts

@@ -7,6 +7,7 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
+import type { Callback } from "@rspack/lite-tapable";
 import type { MultiCompiler } from "./MultiCompiler";
 import type { Watching } from "./Watching";
 declare class MultiWatching {
@@ -17,12 +18,8 @@ declare class MultiWatching {
      * @param compiler - the compiler
      */
     constructor(watchings: Watching[], compiler: MultiCompiler);
-    invalidate(callback: any): void;
-    /**
-     * @param {Callback<void>} callback signals when the watcher is closed
-     * @returns {void}
-     */
-    close(callback: any): void;
+    invalidate(callback: Callback<Error, void>): void;
+    close(callback: Callback<Error, void>): void;
     suspend(): void;
     resume(): void;
 }

package/dist/MultiWatching.js

@@ -22,10 +22,12 @@ class MultiWatching {
         this.watchings = watchings;
         this.compiler = compiler;
     }
-    // @ts-expect-error
     invalidate(callback) {
         if (callback) {
-            neo_async_1.default.each(this.watchings, (watching, callback) => watching.invalidate(callback), callback);
+            neo_async_1.default.each(this.watchings, (watching, callback) => watching.invalidate(callback), 
+            // cannot be resolved without assertion
+            // Type 'Error | null | undefined' is not assignable to type 'Error | null'
+            callback);
         }
         else {
             for (const watching of this.watchings) {
@@ -33,11 +35,6 @@ class MultiWatching {
             }
         }
     }
-    /**
-     * @param {Callback<void>} callback signals when the watcher is closed
-     * @returns {void}
-     */
-    // @ts-expect-error
     close(callback) {
         neo_async_1.default.forEach(this.watchings, (watching, finishedCallback) => {
             watching.close(finishedCallback);
@@ -45,6 +42,8 @@ class MultiWatching {
             this.compiler.hooks.watchClose.call();
             if (typeof callback === "function") {
                 this.compiler.running = false;
+                // cannot be resolved without assertion
+                // Type 'Error | null | undefined' is not assignable to type 'Error | null'
                 callback(err);
             }
         });

package/dist/Resolver.d.ts

@@ -1,9 +1,7 @@
 import type * as binding from "@rspack/binding";
 import { type Resolve } from "./config";
+import type { ResolveCallback } from "./config/adapterRuleUse";
 type ResolveContext = {};
-type ErrorWithDetail = Error & {
-    details?: string;
-};
 type ResolveOptionsWithDependencyType = Resolve & {
     dependencyCategory?: string;
     resolveToContext?: boolean;
@@ -12,7 +10,7 @@ export declare class Resolver {
     binding: binding.JsResolver;
     constructor(binding: binding.JsResolver);
     resolveSync(context: object, path: string, request: string): string | false;
-    resolve(context: object, path: string, request: string, resolveContext: ResolveContext, callback: (err: null | ErrorWithDetail, res?: string | false) => void): void;
+    resolve(context: object, path: string, request: string, resolveContext: ResolveContext, callback: ResolveCallback): void;
     withOptions({ dependencyCategory, resolveToContext, ...resolve }: ResolveOptionsWithDependencyType): Resolver;
 }
 export {};

package/dist/RspackError.d.ts

@@ -1,7 +1,7 @@
 import type * as binding from "@rspack/binding";
 export type RspackError = binding.JsRspackError;
-export declare class JsDiagnostic {
-    static __to_binding(error: Error | RspackError, severity: binding.JsRspackSeverity): binding.JsDiagnostic;
+export declare class JsRspackDiagnostic {
+    static __to_binding(error: Error | RspackError, severity: binding.JsRspackSeverity): binding.JsRspackDiagnostic;
 }
 export declare class NonErrorEmittedError extends Error {
     constructor(error: Error);