@rspack/core 0.5.6 → 0.5.7-canary-dcd4782-20240312094134

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

@@ -33,6 +33,7 @@ export declare class Watching {
     watch(files: Iterable<string>, dirs: Iterable<string>, missing: Iterable<string>): void;
     close(callback?: () => void): void;
     invalidate(callback?: Callback<Error, void>): void;
+    lazyCompilationInvalidate(files: Set<string>): void;
     /**
      * The reason why this is _done instead of #done, is that in Webpack,
      * it will rewrite this function to another function

package/dist/Watching.js

@@ -150,6 +150,9 @@ class Watching {
         this.onChange();
         __classPrivateFieldGet(this, _Watching_instances, "m", _Watching_invalidate).call(this);
     }
+    lazyCompilationInvalidate(files) {
+        __classPrivateFieldGet(this, _Watching_instances, "m", _Watching_invalidate).call(this, new Map(), new Map(), files, new Set());
+    }
     _done(error, compilation) {
         this.running = false;
         let stats = undefined;

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

@@ -50,6 +50,7 @@ export * from "./HtmlRspackPlugin";
 export * from "./CopyRspackPlugin";
 export * from "./SwcJsMinimizerPlugin";
 export * from "./SwcCssMinimizerPlugin";
+export * from "./lazy-compilation/plugin";
 import { RawBuiltins, RawCssModulesConfig } from "@rspack/binding";
 import { RspackOptionsNormalized } from "..";
 type BuiltinsCssConfig = {

package/dist/builtin-plugin/index.js

@@ -68,6 +68,7 @@ __exportStar(require("./HtmlRspackPlugin"), exports);
 __exportStar(require("./CopyRspackPlugin"), exports);
 __exportStar(require("./SwcJsMinimizerPlugin"), exports);
 __exportStar(require("./SwcCssMinimizerPlugin"), exports);
+__exportStar(require("./lazy-compilation/plugin"), exports);
 function resolveTreeShaking(treeShaking, production) {
     return treeShaking !== undefined
         ? treeShaking.toString()

package/dist/builtin-plugin/lazy-compilation/backend.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import type { Compiler } from "../..";
+/**
+ * @param {Omit<LazyCompilationDefaultBackendOptions, "client"> & { client: NonNullable<LazyCompilationDefaultBackendOptions["client"]>}} options additional options for the backend
+ * @returns {BackendHandler} backend
+ */
+declare const getBackend: (options: any) => (compiler: Compiler, callback: (err: any, obj?: {
+    dispose: (callback: (err: any) => void) => void;
+    module: (args: {
+        module: string;
+        path: string;
+    }) => {
+        data: string;
+        client: string;
+        active: boolean;
+    };
+} | undefined) => void) => void;
+export default getBackend;
+export declare function dispose(callback: any): void;
+export declare function moduleImpl(args: {
+    module: string;
+    path: string;
+}): {
+    active: boolean;
+    data: string;
+    client: string;
+};

package/dist/builtin-plugin/lazy-compilation/backend.js

@@ -0,0 +1,144 @@
+/*
+    MIT License http://www.opensource.org/licenses/mit-license.php
+    Author Tobias Koppers @sokra
+*/
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moduleImpl = exports.dispose = void 0;
+/**
+ * @param {Omit<LazyCompilationDefaultBackendOptions, "client"> & { client: NonNullable<LazyCompilationDefaultBackendOptions["client"]>}} options additional options for the backend
+ * @returns {BackendHandler} backend
+ */
+const getBackend = (options) => (compiler, callback) => {
+    const logger = compiler.getInfrastructureLogger("LazyCompilationBackend");
+    const activeModules = new Map();
+    const filesByKey = new Map();
+    const prefix = "/lazy-compilation-using-";
+    const isHttps = options.protocol === "https" ||
+        (typeof options.server === "object" &&
+            ("key" in options.server || "pfx" in options.server));
+    const createServer = typeof options.server === "function"
+        ? options.server
+        : (() => {
+            const http = isHttps ? require("https") : require("http");
+            return http.createServer.bind(http, options.server);
+        })();
+    const listen = typeof options.listen === "function"
+        ? options.listen
+        : (server) => {
+            let listen = options.listen;
+            if (typeof listen === "object" && !("port" in listen))
+                listen = { ...listen, port: undefined };
+            server.listen(listen);
+        };
+    const protocol = options.protocol || (isHttps ? "https" : "http");
+    const requestListener = (req, res) => {
+        const keys = req.url.slice(prefix.length).split("@");
+        req.socket.on("close", () => {
+            setTimeout(() => {
+                for (const key of keys) {
+                    const oldValue = activeModules.get(key) || 0;
+                    activeModules.set(key, oldValue - 1);
+                    if (oldValue === 1) {
+                        logger.log(`${key} is no longer in use. Next compilation will skip this module.`);
+                    }
+                }
+            }, 120000);
+        });
+        req.socket.setNoDelay(true);
+        res.writeHead(200, {
+            "content-type": "text/event-stream",
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "*",
+            "Access-Control-Allow-Headers": "*"
+        });
+        res.write("\n");
+        const moduleActivated = [];
+        for (const key of keys) {
+            const oldValue = activeModules.get(key) || 0;
+            activeModules.set(key, oldValue + 1);
+            if (oldValue === 0) {
+                logger.log(`${key} is now in use and will be compiled.`);
+                moduleActivated.push(key);
+            }
+        }
+        if (moduleActivated.length && compiler.watching) {
+            compiler.watching.lazyCompilationInvalidate(new Set(moduleActivated.map(key => filesByKey.get(key))));
+        }
+    };
+    const server = createServer();
+    server.on("request", requestListener);
+    let isClosing = false;
+    const sockets = new Set();
+    server.on("connection", socket => {
+        sockets.add(socket);
+        socket.on("close", () => {
+            sockets.delete(socket);
+        });
+        if (isClosing)
+            socket.destroy();
+    });
+    server.on("clientError", e => {
+        if (e.message !== "Server is disposing")
+            logger.warn(e);
+    });
+    server.on("listening", (err) => {
+        if (err)
+            return callback(err);
+        const addr = server.address();
+        if (typeof addr === "string")
+            throw new Error("addr must not be a string");
+        const urlBase = addr.address === "::" || addr.address === "0.0.0.0"
+            ? `${protocol}://localhost:${addr.port}`
+            : addr.family === "IPv6"
+                ? `${protocol}://[${addr.address}]:${addr.port}`
+                : `${protocol}://${addr.address}:${addr.port}`;
+        logger.log(`Server-Sent-Events server for lazy compilation open at ${urlBase}.`);
+        const result = {
+            dispose(callback) {
+                isClosing = true;
+                // Removing the listener is a workaround for a memory leak in node.js
+                server.off("request", requestListener);
+                server.close(err => {
+                    console.log("server shutdown");
+                    callback(err);
+                });
+                for (const socket of sockets) {
+                    socket.destroy(new Error("Server is disposing"));
+                }
+            },
+            module({ module: originalModule, path }) {
+                const key = `${encodeURIComponent(originalModule.replace(/\\/g, "/").replace(/@/g, "_")).replace(/%(2F|3A|24|26|2B|2C|3B|3D|3A)/g, decodeURIComponent)}`;
+                filesByKey.set(key, path);
+                const active = activeModules.get(key) > 0;
+                return {
+                    client: `${options.client}?${encodeURIComponent(urlBase + prefix)}`,
+                    data: key,
+                    active
+                };
+            }
+        };
+        state.module = result.module;
+        state.dispose = result.dispose;
+        callback(null, result);
+    });
+    listen(server);
+};
+exports.default = getBackend;
+function unimplemented() {
+    throw new Error("access before initialization");
+}
+const state = {
+    module: unimplemented,
+    dispose: unimplemented
+};
+function dispose(callback) {
+    state.dispose(callback);
+    state.dispose = unimplemented;
+    state.module = unimplemented;
+}
+exports.dispose = dispose;
+function moduleImpl(args) {
+    return state.module(args);
+}
+exports.moduleImpl = moduleImpl;