@rspack/core 0.5.6 → 0.5.7-canary-3320ea8-20240312032922

package/dist/ChunkGroup.d.ts

@@ -2,9 +2,11 @@ import { type JsChunkGroup, type JsCompilation } from "@rspack/binding";
 export declare class ChunkGroup {
     #private;
     static __from_binding(chunk: JsChunkGroup, compilation: JsCompilation): ChunkGroup;
-    private constructor();
+    protected constructor(inner: JsChunkGroup, compilation: JsCompilation);
     getFiles(): string[];
     getParents(): ChunkGroup[];
     get index(): number | undefined;
     get name(): string | undefined;
+    __internal_inner_ukey(): number;
+    __internal_inner_compilation(): JsCompilation;
 }

package/dist/ChunkGroup.js

@@ -45,6 +45,12 @@ class ChunkGroup {
     get name() {
         return __classPrivateFieldGet(this, _ChunkGroup_inner, "f").name;
     }
+    __internal_inner_ukey() {
+        return __classPrivateFieldGet(this, _ChunkGroup_inner, "f").__inner_ukey;
+    }
+    __internal_inner_compilation() {
+        return __classPrivateFieldGet(this, _ChunkGroup_inner_compilation, "f");
+    }
 }
 exports.ChunkGroup = ChunkGroup;
 _ChunkGroup_inner = new WeakMap(), _ChunkGroup_inner_compilation = new WeakMap();

package/dist/Compilation.d.ts

@@ -12,21 +12,21 @@ import * as tapable from "tapable";
 import { Source } from "webpack-sources";
 import type { ExternalObject, JsAssetInfo, JsChunk, JsCompatSource, JsCompilation, JsModule, JsRuntimeModule, JsStatsChunk, JsStatsError, PathData } from "@rspack/binding";
 import { RspackOptionsNormalized, StatsOptions, OutputNormalized, StatsValue, RspackPluginInstance } from "./config";
+import * as liteTapable from "./lite-tapable";
 import { ContextModuleFactory } from "./ContextModuleFactory";
 import ResolverFactory from "./ResolverFactory";
-import { ChunkGroup } from "./ChunkGroup";
 import { Compiler } from "./Compiler";
 import { Logger } from "./logging/Logger";
 import { NormalModuleFactory } from "./NormalModuleFactory";
 import { Stats } from "./Stats";
 import { StatsFactory } from "./stats/StatsFactory";
 import { StatsPrinter } from "./stats/StatsPrinter";
-import { createFakeProcessAssetsHook } from "./util/fake";
 import { NormalizedJsModule } from "./util/normalization";
 import MergeCaller from "./util/MergeCaller";
 import { Chunk } from "./Chunk";
 import { CodeGenerationResult } from "./Module";
 import { ChunkGraph } from "./ChunkGraph";
+import { Entrypoint } from "./Entrypoint";
 export type AssetInfo = Partial<JsAssetInfo> & Record<string, any>;
 export type Assets = Record<string, Source>;
 export interface Asset {
@@ -62,7 +62,7 @@ type CreateStatsOptionsContext = KnownCreateStatsOptionsContext & Record<string,
 export declare class Compilation {
     #private;
     hooks: {
-        processAssets: ReturnType<typeof createFakeProcessAssetsHook>;
+        processAssets: liteTapable.AsyncSeriesHook<Assets>;
         afterProcessAssets: tapable.SyncHook<Assets>;
         childCompiler: tapable.SyncHook<[Compiler, string, number]>;
         log: tapable.SyncBailHook<[string, LogEntry], true>;
@@ -125,7 +125,7 @@ export declare class Compilation {
     /**
      * Get a map of all entrypoints.
      */
-    get entrypoints(): ReadonlyMap<string, ChunkGroup>;
+    get entrypoints(): ReadonlyMap<string, Entrypoint>;
     getCache(name: string): import("./lib/CacheFacade");
     createStatsOptions(optionsOrPreset: StatsValue | undefined, context?: CreateStatsOptionsContext): StatsOptions;
     createStatsFactory(options: StatsOptions): StatsFactory;
@@ -328,6 +328,5 @@ export declare class Compilation {
     static PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER: number;
     static PROCESS_ASSETS_STAGE_ANALYSE: number;
     static PROCESS_ASSETS_STAGE_REPORT: number;
-    __internal_getProcessAssetsHookByStage(stage: number): tapable.AsyncSeriesHook<Assets, tapable.UnsetAdditionalOptions>;
 }
 export {};

package/dist/Compilation.js

@@ -49,7 +49,7 @@ exports.Compilation = void 0;
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 const tapable = __importStar(require("tapable"));
-const ChunkGroup_1 = require("./ChunkGroup");
+const liteTapable = __importStar(require("./lite-tapable"));
 const ErrorHelpers_1 = __importDefault(require("./ErrorHelpers"));
 const Logger_1 = require("./logging/Logger");
 const NormalModule_1 = require("./NormalModule");
@@ -64,6 +64,7 @@ const MergeCaller_1 = __importDefault(require("./util/MergeCaller"));
 const memoize_1 = require("./util/memoize");
 const Chunk_1 = require("./Chunk");
 const ChunkGraph_1 = require("./ChunkGraph");
+const Entrypoint_1 = require("./Entrypoint");
 class Compilation {
     constructor(compiler, inner) {
         _Compilation_inner.set(this, void 0);
@@ -95,13 +96,42 @@ class Compilation {
         this.name = undefined;
         this.startTime = undefined;
         this.endTime = undefined;
-        const processAssetsHooks = (0, fake_1.createFakeProcessAssetsHook)(this);
+        const processAssetsHook = new liteTapable.AsyncSeriesHook([
+            "assets"
+        ]);
+        const createProcessAssetsHook = (name, stage, getArgs, code) => {
+            const errorMessage = (reason) => `Can't automatically convert plugin using Compilation.hooks.${name} to Compilation.hooks.processAssets because ${reason}.
+BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a single Compilation.hooks.processAssets hook.`;
+            const getOptions = (options) => {
+                if (typeof options === "string")
+                    options = { name: options };
+                if (options.stage) {
+                    throw new Error(errorMessage("it's using the 'stage' option"));
+                }
+                return { ...options, stage: stage };
+            };
+            return Object.freeze({
+                name,
+                intercept() {
+                    throw new Error(errorMessage("it's using 'intercept'"));
+                },
+                tap: (options, fn) => {
+                    processAssetsHook.tap(getOptions(options), () => fn(...getArgs()));
+                },
+                tapAsync: (options, fn) => {
+                    processAssetsHook.tapAsync(getOptions(options), (assets, callback) => fn(...getArgs(), callback));
+                },
+                tapPromise: (options, fn) => {
+                    processAssetsHook.tapPromise(getOptions(options), () => fn(...getArgs()));
+                },
+                _fakeHook: true
+            });
+        };
         this.hooks = {
-            processAssets: processAssetsHooks,
+            processAssets: processAssetsHook,
             afterProcessAssets: new tapable.SyncHook(["assets"]),
-            // TODO: webpack 6 deprecate, keep it just for compatibility
             /** @deprecated */
-            additionalAssets: (0, fake_1.createProcessAssetsHook)(processAssetsHooks, "additionalAssets", Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL, () => []),
+            additionalAssets: createProcessAssetsHook("additionalAssets", Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL, () => []),
             childCompiler: new tapable.SyncHook([
                 "childCompiler",
                 "compilerName",
@@ -196,7 +226,7 @@ class Compilation {
     get entrypoints() {
         return new Map(Object.entries(__classPrivateFieldGet(this, _Compilation_inner, "f").entrypoints).map(([n, e]) => [
             n,
-            ChunkGroup_1.ChunkGroup.__from_binding(e, __classPrivateFieldGet(this, _Compilation_inner, "f"))
+            Entrypoint_1.Entrypoint.__from_binding(e, __classPrivateFieldGet(this, _Compilation_inner, "f"))
         ]));
     }
     getCache(name) {
@@ -218,6 +248,7 @@ class Compilation {
         options.runtimeModules = optionOrLocalFallback(options.runtimeModules, !context.forToString);
         options.reasons = optionOrLocalFallback(options.reasons, !context.forToString);
         options.usedExports = optionOrLocalFallback(options.usedExports, !context.forToString);
+        options.optimizationBailout = optionOrLocalFallback(options.optimizationBailout, !context.forToString);
         options.providedExports = optionOrLocalFallback(options.providedExports, !context.forToString);
         options.entrypoints = optionOrLocalFallback(options.entrypoints, true);
         options.chunkGroups = optionOrLocalFallback(options.chunkGroups, !context.forToString);
@@ -674,52 +705,6 @@ class Compilation {
     }
     seal() { }
     unseal() { }
-    __internal_getProcessAssetsHookByStage(stage) {
-        if (stage > Compilation.PROCESS_ASSETS_STAGE_REPORT) {
-            this.pushDiagnostic("warning", "not supported process_assets_stage", `custom stage for process_assets is not supported yet, so ${stage} is fallback to Compilation.PROCESS_ASSETS_STAGE_REPORT(${Compilation.PROCESS_ASSETS_STAGE_REPORT}) `);
-            stage = Compilation.PROCESS_ASSETS_STAGE_REPORT;
-        }
-        if (stage < Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL) {
-            this.pushDiagnostic("warning", "not supported process_assets_stage", `custom stage for process_assets is not supported yet, so ${stage} is fallback to Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL(${Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL}) `);
-            stage = Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL;
-        }
-        switch (stage) {
-            case Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL:
-                return this.hooks.processAssets.stageAdditional;
-            case Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS:
-                return this.hooks.processAssets.stagePreProcess;
-            case Compilation.PROCESS_ASSETS_STAGE_DERIVED:
-                return this.hooks.processAssets.stageDerived;
-            case Compilation.PROCESS_ASSETS_STAGE_ADDITIONS:
-                return this.hooks.processAssets.stageAdditions;
-            case Compilation.PROCESS_ASSETS_STAGE_NONE:
-                return this.hooks.processAssets.stageNone;
-            case Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE:
-                return this.hooks.processAssets.stageOptimize;
-            case Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT:
-                return this.hooks.processAssets.stageOptimizeCount;
-            case Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY:
-                return this.hooks.processAssets.stageOptimizeCompatibility;
-            case Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE:
-                return this.hooks.processAssets.stageOptimizeSize;
-            case Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING:
-                return this.hooks.processAssets.stageDevTooling;
-            case Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE:
-                return this.hooks.processAssets.stageOptimizeInline;
-            case Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE:
-                return this.hooks.processAssets.stageSummarize;
-            case Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH:
-                return this.hooks.processAssets.stageOptimizeHash;
-            case Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER:
-                return this.hooks.processAssets.stageOptimizeTransfer;
-            case Compilation.PROCESS_ASSETS_STAGE_ANALYSE:
-                return this.hooks.processAssets.stageAnalyse;
-            case Compilation.PROCESS_ASSETS_STAGE_REPORT:
-                return this.hooks.processAssets.stageReport;
-            default:
-                throw new Error("processAssets hook uses custom stage number is not supported.");
-        }
-    }
 }
 _Compilation_inner = new WeakMap();
 Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL = -2000;

package/dist/Compiler.js

@@ -36,7 +36,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _Compiler_instances, _Compiler_instance, _Compiler_disabledHooks, _Compiler_moduleExecutionResultsMap, _Compiler_getInstance, _Compiler_updateDisabledHooks, _Compiler_beforeCompile, _Compiler_afterCompile, _Compiler_finishMake, _Compiler_buildModule, _Compiler_processAssets, _Compiler_afterProcessAssets, _Compiler_beforeResolve, _Compiler_afterResolve, _Compiler_contextModuleFactoryBeforeResolve, _Compiler_contextModuleFactoryAfterResolve, _Compiler_normalModuleFactoryCreateModule, _Compiler_normalModuleFactoryResolveForScheme, _Compiler_optimizeChunkModules, _Compiler_optimizeTree, _Compiler_optimizeModules, _Compiler_afterOptimizeModules, _Compiler_chunkAsset, _Compiler_finishModules, _Compiler_shouldEmit, _Compiler_emit, _Compiler_assetEmitted, _Compiler_afterEmit, _Compiler_succeedModule, _Compiler_stillValidModule, _Compiler_runtimeModule, _Compiler_executeModule, _Compiler_registerCompilerCompilationTaps, _Compiler_registerCompilerMakeTaps, _Compiler_newCompilation;
+var _Compiler_instances, _Compiler_instance, _Compiler_disabledHooks, _Compiler_moduleExecutionResultsMap, _Compiler_getInstance, _Compiler_updateDisabledHooks, _Compiler_beforeCompile, _Compiler_afterCompile, _Compiler_finishMake, _Compiler_buildModule, _Compiler_afterProcessAssets, _Compiler_beforeResolve, _Compiler_afterResolve, _Compiler_contextModuleFactoryBeforeResolve, _Compiler_contextModuleFactoryAfterResolve, _Compiler_normalModuleFactoryCreateModule, _Compiler_normalModuleFactoryResolveForScheme, _Compiler_optimizeChunkModules, _Compiler_optimizeTree, _Compiler_optimizeModules, _Compiler_afterOptimizeModules, _Compiler_chunkAsset, _Compiler_finishModules, _Compiler_shouldEmit, _Compiler_emit, _Compiler_assetEmitted, _Compiler_afterEmit, _Compiler_succeedModule, _Compiler_stillValidModule, _Compiler_runtimeModule, _Compiler_executeModule, _Compiler_decorateUpdateDisabledHooks, _Compiler_registerCompilerCompilationTaps, _Compiler_registerCompilerMakeTaps, _Compiler_registerCompilationProcessAssetsTaps, _Compiler_newCompilation;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Compiler = void 0;
 const index_1 = require("./index");
@@ -523,22 +523,6 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
         emit: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_emit).bind(this),
         assetEmitted: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_assetEmitted).bind(this),
         afterEmit: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_afterEmit).bind(this),
-        processAssetsStageAdditional: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_processAssets).bind(this, Compilation_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL),
-        processAssetsStagePreProcess: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_processAssets).bind(this, Compilation_1.Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS),
-        processAssetsStageDerived: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_processAssets).bind(this, Compilation_1.Compilation.PROCESS_ASSETS_STAGE_DERIVED),
-        processAssetsStageAdditions: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_processAssets).bind(this, Compilation_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS),
-        processAssetsStageNone: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_processAssets).bind(this, Compilation_1.Compilation.PROCESS_ASSETS_STAGE_NONE),
-        processAssetsStageOptimize: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_processAssets).bind(this, Compilation_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE),
-        processAssetsStageOptimizeCount: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_processAssets).bind(this, Compilation_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT),
-        processAssetsStageOptimizeCompatibility: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_processAssets).bind(this, Compilation_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY),
-        processAssetsStageOptimizeSize: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_processAssets).bind(this, Compilation_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE),
-        processAssetsStageDevTooling: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_processAssets).bind(this, Compilation_1.Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING),
-        processAssetsStageOptimizeInline: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_processAssets).bind(this, Compilation_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE),
-        processAssetsStageSummarize: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_processAssets).bind(this, Compilation_1.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE),
-        processAssetsStageOptimizeHash: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_processAssets).bind(this, Compilation_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH),
-        processAssetsStageOptimizeTransfer: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_processAssets).bind(this, Compilation_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER),
-        processAssetsStageAnalyse: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_processAssets).bind(this, Compilation_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE),
-        processAssetsStageReport: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_processAssets).bind(this, Compilation_1.Compilation.PROCESS_ASSETS_STAGE_REPORT),
         afterProcessAssets: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_afterProcessAssets).bind(this),
         // `Compilation` should be created with hook `thisCompilation`, and here is the reason:
         // We know that the hook `thisCompilation` will not be called from a child compiler(it doesn't matter whether the child compiler is created on the Rust or the Node side).
@@ -564,7 +548,8 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
         runtimeModule: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_runtimeModule).bind(this)
     }, {
         registerCompilerCompilationTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_registerCompilerCompilationTaps).bind(this),
-        registerCompilerMakeTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_registerCompilerMakeTaps).bind(this)
+        registerCompilerMakeTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_registerCompilerMakeTaps).bind(this),
+        registerCompilationProcessAssetsTaps: __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_registerCompilationProcessAssetsTaps).bind(this)
     }, (0, fileSystem_1.createThreadsafeNodeFSFromRaw)(this.outputFileSystem), loader_runner_1.runLoaders.bind(undefined, this)), "f");
     callback(null, __classPrivateFieldGet(this, _Compiler_instance, "f"));
 }, _Compiler_updateDisabledHooks = function _Compiler_updateDisabledHooks(callback) {
@@ -578,22 +563,6 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
         emit: this.hooks.emit,
         assetEmitted: this.hooks.assetEmitted,
         afterEmit: this.hooks.afterEmit,
-        processAssetsStageAdditional: this.compilation.__internal_getProcessAssetsHookByStage(Compilation_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL),
-        processAssetsStagePreProcess: this.compilation.__internal_getProcessAssetsHookByStage(Compilation_1.Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS),
-        processAssetsStageDerived: this.compilation.__internal_getProcessAssetsHookByStage(Compilation_1.Compilation.PROCESS_ASSETS_STAGE_DERIVED),
-        processAssetsStageAdditions: this.compilation.__internal_getProcessAssetsHookByStage(Compilation_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS),
-        processAssetsStageNone: this.compilation.__internal_getProcessAssetsHookByStage(Compilation_1.Compilation.PROCESS_ASSETS_STAGE_NONE),
-        processAssetsStageOptimize: this.compilation.__internal_getProcessAssetsHookByStage(Compilation_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE),
-        processAssetsStageOptimizeCount: this.compilation.__internal_getProcessAssetsHookByStage(Compilation_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT),
-        processAssetsStageOptimizeCompatibility: this.compilation.__internal_getProcessAssetsHookByStage(Compilation_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY),
-        processAssetsStageOptimizeSize: this.compilation.__internal_getProcessAssetsHookByStage(Compilation_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE),
-        processAssetsStageDevTooling: this.compilation.__internal_getProcessAssetsHookByStage(Compilation_1.Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING),
-        processAssetsStageOptimizeInline: this.compilation.__internal_getProcessAssetsHookByStage(Compilation_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE),
-        processAssetsStageSummarize: this.compilation.__internal_getProcessAssetsHookByStage(Compilation_1.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE),
-        processAssetsStageOptimizeHash: this.compilation.__internal_getProcessAssetsHookByStage(Compilation_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH),
-        processAssetsStageOptimizeTransfer: this.compilation.__internal_getProcessAssetsHookByStage(Compilation_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER),
-        processAssetsStageAnalyse: this.compilation.__internal_getProcessAssetsHookByStage(Compilation_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE),
-        processAssetsStageReport: this.compilation.__internal_getProcessAssetsHookByStage(Compilation_1.Compilation.PROCESS_ASSETS_STAGE_REPORT),
         afterProcessAssets: this.compilation.hooks.afterProcessAssets,
         optimizeTree: this.compilation.hooks.optimizeTree,
         finishModules: this.compilation.hooks.finishModules,
@@ -650,11 +619,6 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
     const normalized = (0, normalization_1.normalizeJsModule)(module);
     this.compilation.hooks.buildModule.call(normalized);
     __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
-}, _Compiler_processAssets = async function _Compiler_processAssets(stage) {
-    await this.compilation
-        .__internal_getProcessAssetsHookByStage(stage)
-        .promise(this.compilation.assets);
-    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
 }, _Compiler_afterProcessAssets = async function _Compiler_afterProcessAssets() {
     await this.compilation.hooks.afterProcessAssets.promise(this.compilation.assets);
     __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
@@ -810,41 +774,79 @@ _Compiler_instance = new WeakMap(), _Compiler_disabledHooks = new WeakMap(), _Co
     }
     const executeResult = __webpack_require__(entry);
     __classPrivateFieldGet(this, _Compiler_moduleExecutionResultsMap, "f").set(id, executeResult);
+}, _Compiler_decorateUpdateDisabledHooks = function _Compiler_decorateUpdateDisabledHooks(jsTaps) {
+    if (jsTaps.length > 0) {
+        const last = jsTaps[jsTaps.length - 1];
+        const old = last.function;
+        last.function = async () => {
+            await old();
+            __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
+        };
+    }
 }, _Compiler_registerCompilerCompilationTaps = function _Compiler_registerCompilerCompilationTaps(stages) {
     if (!this.hooks.compilation.isUsed())
         return [];
-    const breakpoints = [-Infinity, ...stages, Infinity];
+    const breakpoints = [liteTapable.minStage, ...stages, liteTapable.maxStage];
     const jsTaps = [];
     for (let i = 0; i < breakpoints.length - 1; i++) {
-        const stageRange = liteTapable.StageRange.from(breakpoints[i], breakpoints[i + 1]);
+        const from = breakpoints[i];
+        const to = breakpoints[i + 1];
+        const stageRange = [from, to];
+        const queried = this.hooks.compilation.queryStageRange(stageRange);
+        if (!queried.isUsed())
+            continue;
         jsTaps.push({
-            function: (native) => {
-                this.hooks.compilation.callStageRange(stageRange, this.compilation, {
+            function: () => {
+                queried.call(this.compilation, {
                     normalModuleFactory: this.compilation.normalModuleFactory
                 });
-                if (i + 1 >= breakpoints.length - 1)
-                    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
             },
-            stage: stageRange.from + 1
+            stage: liteTapable.safeStage(from + 1)
         });
     }
+    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_decorateUpdateDisabledHooks).call(this, jsTaps);
     return jsTaps;
 }, _Compiler_registerCompilerMakeTaps = function _Compiler_registerCompilerMakeTaps(stages) {
     if (!this.hooks.make.isUsed())
         return [];
-    const breakpoints = [-Infinity, ...stages, Infinity];
+    const breakpoints = [liteTapable.minStage, ...stages, liteTapable.maxStage];
+    const jsTaps = [];
+    for (let i = 0; i < breakpoints.length - 1; i++) {
+        const from = breakpoints[i];
+        const to = breakpoints[i + 1];
+        const stageRange = [from, to];
+        const queried = this.hooks.make.queryStageRange(stageRange);
+        if (!queried.isUsed())
+            continue;
+        jsTaps.push({
+            function: async () => {
+                await queried.promise(this.compilation);
+            },
+            stage: liteTapable.safeStage(from + 1)
+        });
+    }
+    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_decorateUpdateDisabledHooks).call(this, jsTaps);
+    return jsTaps;
+}, _Compiler_registerCompilationProcessAssetsTaps = function _Compiler_registerCompilationProcessAssetsTaps(stages) {
+    if (!this.compilation.hooks.processAssets.isUsed())
+        return [];
+    const breakpoints = [liteTapable.minStage, ...stages, liteTapable.maxStage];
     const jsTaps = [];
     for (let i = 0; i < breakpoints.length - 1; i++) {
-        const stageRange = liteTapable.StageRange.from(breakpoints[i], breakpoints[i + 1]);
+        const from = breakpoints[i];
+        const to = breakpoints[i + 1];
+        const stageRange = [from, to];
+        const queried = this.compilation.hooks.processAssets.queryStageRange(stageRange);
+        if (!queried.isUsed())
+            continue;
         jsTaps.push({
-            function: async (native) => {
-                await this.hooks.make.promiseStageRange(stageRange, this.compilation);
-                if (i + 1 >= breakpoints.length - 1)
-                    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_updateDisabledHooks).call(this);
+            function: async () => {
+                await queried.promise(this.compilation.assets);
             },
-            stage: stageRange.from + 1
+            stage: liteTapable.safeStage(from + 1)
         });
     }
+    __classPrivateFieldGet(this, _Compiler_instances, "m", _Compiler_decorateUpdateDisabledHooks).call(this, jsTaps);
     return jsTaps;
 }, _Compiler_newCompilation = function _Compiler_newCompilation(native) {
     const compilation = new Compilation_1.Compilation(this, native);

package/dist/Entrypoint.d.ts

@@ -0,0 +1,8 @@
+import { type JsChunkGroup, type JsCompilation } from "@rspack/binding";
+import { ChunkGroup } from "./ChunkGroup";
+import { Chunk } from "./Chunk";
+export declare class Entrypoint extends ChunkGroup {
+    static __from_binding(chunk: JsChunkGroup, compilation: JsCompilation): Entrypoint;
+    protected constructor(inner: JsChunkGroup, compilation: JsCompilation);
+    getRuntimeChunk(): Chunk | null;
+}

package/dist/Entrypoint.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entrypoint = void 0;
+const binding_1 = require("@rspack/binding");
+const ChunkGroup_1 = require("./ChunkGroup");
+const Chunk_1 = require("./Chunk");
+class Entrypoint extends ChunkGroup_1.ChunkGroup {
+    static __from_binding(chunk, compilation) {
+        return new Entrypoint(chunk, compilation);
+    }
+    constructor(inner, compilation) {
+        super(inner, compilation);
+    }
+    getRuntimeChunk() {
+        const c = (0, binding_1.__entrypoint_inner_get_runtime_chunk)(this.__internal_inner_ukey(), this.__internal_inner_compilation());
+        if (c)
+            return Chunk_1.Chunk.__from_binding(c, this.__internal_inner_compilation());
+        return null;
+    }
+}
+exports.Entrypoint = Entrypoint;

package/dist/config/adapter.js

@@ -64,7 +64,7 @@ function getRawTarget(target) {
     }
     return target;
 }
-function getRawAlias(alias = {}) {
+function getRawExtensionAlias(alias = {}) {
     const entries = Object.entries(alias).map(([key, value]) => {
         if (Array.isArray(value)) {
             return [key, value];
@@ -75,6 +75,12 @@ function getRawAlias(alias = {}) {
     });
     return Object.fromEntries(entries);
 }
+function getRawAlias(alias = {}) {
+    return Object.entries(alias).map(([key, value]) => ({
+        path: key,
+        redirect: Array.isArray(value) ? value : [value]
+    }));
+}
 function getRawResolveByDependency(byDependency) {
     if (byDependency === undefined)
         return byDependency;
@@ -88,7 +94,7 @@ function getRawResolve(resolve) {
         ...resolve,
         alias: getRawAlias(resolve.alias),
         fallback: getRawAlias(resolve.fallback),
-        extensionAlias: getRawAlias(resolve.extensionAlias),
+        extensionAlias: getRawExtensionAlias(resolve.extensionAlias),
         tsconfig: tsconfigConfigFile
             ? {
                 configFile: tsconfigConfigFile,
@@ -209,7 +215,8 @@ function getRawModule(module, options) {
     return {
         rules,
         parser: getRawParserOptionsByModuleType(module.parser),
-        generator: getRawGeneratorOptionsByModuleType(module.generator)
+        generator: getRawGeneratorOptionsByModuleType(module.generator),
+        noParse: module.noParse
     };
 }
 function tryMatch(payload, condition) {

package/dist/config/adapterRuleUse.d.ts

@@ -49,7 +49,7 @@ export interface LoaderContext<OptionsType = {}> {
     cacheable(cacheable?: boolean): void;
     sourceMap: boolean;
     rootContext: string;
-    context: string;
+    context: string | null;
     loaderIndex: number;
     remainingRequest: string;
     currentRequest: string;

package/dist/config/normalization.d.ts

@@ -8,7 +8,7 @@
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 import { Compilation } from "..";
-import type { Context, Dependencies, Node, DevTool, Externals, ExternalsPresets, ExternalsType, InfrastructureLogging, LibraryOptions, Mode, Name, Resolve, RspackOptions, Target, SnapshotOptions, CacheOptions, StatsValue, Optimization, Plugins, Watch, WatchOptions, DevServer, Profile, Bail, Builtins, EntryRuntime, ChunkLoading, PublicPath, EntryFilename, Path, Clean, Filename, ChunkFilename, CrossOriginLoading, CssFilename, CssChunkFilename, HotUpdateMainFilename, HotUpdateChunkFilename, AssetModuleFilename, UniqueName, ChunkLoadingGlobal, EnabledLibraryTypes, OutputModule, StrictModuleErrorHandling, GlobalObject, ImportFunctionName, Iife, WasmLoading, EnabledWasmLoadingTypes, WebassemblyModuleFilename, TrustedTypes, SourceMapFilename, HashDigest, HashDigestLength, HashFunction, HashSalt, WorkerPublicPath, RuleSetRules, ParserOptionsByModuleType, GeneratorOptionsByModuleType, RspackFutureOptions, HotUpdateGlobal, ScriptType, DevtoolNamespace, DevtoolModuleFilenameTemplate, DevtoolFallbackModuleFilenameTemplate } from "./zod";
+import type { Context, Dependencies, Node, DevTool, Externals, ExternalsPresets, ExternalsType, InfrastructureLogging, LibraryOptions, Mode, Name, Resolve, RspackOptions, Target, SnapshotOptions, CacheOptions, StatsValue, Optimization, Plugins, Watch, WatchOptions, DevServer, Profile, Bail, Builtins, EntryRuntime, ChunkLoading, PublicPath, EntryFilename, Path, Clean, Filename, ChunkFilename, CrossOriginLoading, CssFilename, CssChunkFilename, HotUpdateMainFilename, HotUpdateChunkFilename, AssetModuleFilename, UniqueName, ChunkLoadingGlobal, EnabledLibraryTypes, OutputModule, StrictModuleErrorHandling, GlobalObject, ImportFunctionName, Iife, WasmLoading, EnabledWasmLoadingTypes, WebassemblyModuleFilename, TrustedTypes, SourceMapFilename, HashDigest, HashDigestLength, HashFunction, HashSalt, WorkerPublicPath, RuleSetRules, ParserOptionsByModuleType, GeneratorOptionsByModuleType, RspackFutureOptions, HotUpdateGlobal, ScriptType, NoParseOption, DevtoolNamespace, DevtoolModuleFilenameTemplate, DevtoolFallbackModuleFilenameTemplate } from "./zod";
 export declare const getNormalizedRspackOptions: (config: RspackOptions) => RspackOptionsNormalized;
 export type EntryNormalized = EntryStaticNormalized;
 export interface EntryStaticNormalized {
@@ -72,6 +72,7 @@ export interface ModuleOptionsNormalized {
     rules: RuleSetRules;
     parser: ParserOptionsByModuleType;
     generator: GeneratorOptionsByModuleType;
+    noParse?: NoParseOption;
 }
 export interface ExperimentsNormalized {
     lazyCompilation?: boolean;

package/dist/config/normalization.js

@@ -125,6 +125,7 @@ const getNormalizedRspackOptions = (config) => {
             ...resolve
         })),
         module: nestedConfig(config.module, module => ({
+            noParse: module.noParse,
             parser: keyedNestedConfig(module.parser, cloneObject, {}),
             generator: keyedNestedConfig(module.generator, cloneObject, {}),
             defaultRules: optionalNestedArray(module.defaultRules, r => [...r]),