@rspack-debug/core 2.0.0-beta.0 → 2.0.0-beta.2

package/compiled/@rspack/lite-tapable/dist/index.d.ts

@@ -0,0 +1,175 @@
+type FixedSizeArray<T extends number, U> = T extends 0 ? undefined[] : ReadonlyArray<U> & {
+    0: U;
+    length: T;
+};
+type Measure<T extends number> = T extends 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 ? T : never;
+type Append<T extends any[], U> = {
+    0: [U];
+    1: [T[0], U];
+    2: [T[0], T[1], U];
+    3: [T[0], T[1], T[2], U];
+    4: [T[0], T[1], T[2], T[3], U];
+    5: [T[0], T[1], T[2], T[3], T[4], U];
+    6: [T[0], T[1], T[2], T[3], T[4], T[5], U];
+    7: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], U];
+    8: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7], U];
+}[Measure<T['length']>];
+export type AsArray<T> = T extends any[] ? T : [T];
+export type Fn<T, R> = (...args: AsArray<T>) => R;
+export type FnAsync<T, R> = (...args: Append<AsArray<T>, InnerCallback<Error, R>>) => void;
+export type FnPromise<T, R> = (...args: AsArray<T>) => Promise<R>;
+declare class UnsetAdditionalOptions {
+    _UnsetAdditionalOptions: true;
+}
+type IfSet<X> = X extends UnsetAdditionalOptions ? {} : X;
+export type Callback<E, T> = (error: E | null, result?: T) => void;
+type InnerCallback<E, T> = (error?: E | null | false, result?: T) => void;
+type FullTap = Tap & {
+    type: 'sync' | 'async' | 'promise';
+    fn: Function;
+};
+type Tap = TapOptions & {
+    name: string;
+};
+type TapOptions = {
+    before?: string;
+    stage?: number;
+};
+export type Options<AdditionalOptions = UnsetAdditionalOptions> = string | (Tap & IfSet<AdditionalOptions>);
+export interface HookInterceptor<T, R, AdditionalOptions = UnsetAdditionalOptions> {
+    name?: string;
+    tap?: (tap: FullTap & IfSet<AdditionalOptions>) => void;
+    call?: (...args: any[]) => void;
+    loop?: (...args: any[]) => void;
+    error?: (err: Error) => void;
+    result?: (result: R) => void;
+    done?: () => void;
+    register?: (tap: FullTap & IfSet<AdditionalOptions>) => FullTap & IfSet<AdditionalOptions>;
+}
+type ArgumentNames<T extends any[]> = FixedSizeArray<T['length'], string>;
+type ExtractHookArgs<H> = H extends Hook<infer T, any> ? T : never;
+type ExtractHookReturn<H> = H extends Hook<any, infer R> ? R : never;
+type ExtractHookAdditionalOptions<H> = H extends Hook<any, any, infer A> ? A : never;
+export interface Hook<T = any, R = any, AdditionalOptions = UnsetAdditionalOptions> {
+    name?: string;
+    tap(opt: Options<AdditionalOptions>, fn: Fn<T, R>): void;
+    tapAsync(opt: Options<AdditionalOptions>, fn: FnAsync<T, R>): void;
+    tapPromise(opt: Options<AdditionalOptions>, fn: FnPromise<T, R>): void;
+    intercept(interceptor: HookInterceptor<T, R, AdditionalOptions>): void;
+    isUsed(): boolean;
+    withOptions(opt: TapOptions & IfSet<AdditionalOptions>): Hook<T, R, AdditionalOptions>;
+    queryStageRange(stageRange: StageRange): QueriedHook<T, R, AdditionalOptions>;
+}
+export declare class HookBase<T, R, AdditionalOptions = UnsetAdditionalOptions> implements Hook<T, R, AdditionalOptions> {
+    args: ArgumentNames<AsArray<T>>;
+    name?: string;
+    taps: (FullTap & IfSet<AdditionalOptions>)[];
+    interceptors: HookInterceptor<T, R, AdditionalOptions>[];
+    constructor(args?: ArgumentNames<AsArray<T>>, name?: string);
+    intercept(interceptor: HookInterceptor<T, R, AdditionalOptions>): void;
+    _runRegisterInterceptors(options: FullTap & IfSet<AdditionalOptions>): FullTap & IfSet<AdditionalOptions>;
+    _runCallInterceptors(...args: any[]): void;
+    _runErrorInterceptors(e: Error): void;
+    _runTapInterceptors(tap: FullTap & IfSet<AdditionalOptions>): void;
+    _runDoneInterceptors(): void;
+    _runResultInterceptors(r: R): void;
+    withOptions(options: TapOptions & IfSet<AdditionalOptions>): Hook<T, R, AdditionalOptions>;
+    isUsed(): boolean;
+    queryStageRange(stageRange: StageRange): QueriedHook<T, R, AdditionalOptions>;
+    callAsyncStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, R>>): void;
+    callAsync(...args: Append<AsArray<T>, Callback<Error, R>>): void;
+    promiseStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: AsArray<T>): Promise<R>;
+    promise(...args: AsArray<T>): Promise<R>;
+    tap(options: Options<AdditionalOptions>, fn: Fn<T, R>): void;
+    tapAsync(options: Options<AdditionalOptions>, fn: FnAsync<T, R>): void;
+    tapPromise(options: Options<AdditionalOptions>, fn: FnPromise<T, R>): void;
+    _tap(type: 'sync' | 'async' | 'promise', options: Options<AdditionalOptions>, fn: Function): void;
+    _insert(item: FullTap & IfSet<AdditionalOptions>): void;
+    _prepareArgs(args: AsArray<T>): (T | undefined)[];
+}
+export type StageRange = readonly [number, number];
+export declare const minStage: number;
+export declare const maxStage: number;
+export declare const safeStage: (stage: number) => number;
+export declare class QueriedHook<T, R, AdditionalOptions = UnsetAdditionalOptions> {
+    stageRange: StageRange;
+    hook: HookBase<T, R, AdditionalOptions>;
+    tapsInRange: (FullTap & IfSet<AdditionalOptions>)[];
+    constructor(stageRange: StageRange, hook: HookBase<T, R, AdditionalOptions>);
+    isUsed(): boolean;
+    call(...args: AsArray<T>): R;
+    callAsync(...args: Append<AsArray<T>, Callback<Error, R>>): void;
+    promise(...args: AsArray<T>): Promise<R>;
+}
+export declare class SyncHook<T, R = void, AdditionalOptions = UnsetAdditionalOptions> extends HookBase<T, R, AdditionalOptions> {
+    callAsyncStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, R>>): void;
+    call(...args: AsArray<T>): R;
+    callStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: AsArray<T>): R;
+    tapAsync(): never;
+    tapPromise(): never;
+}
+export declare class SyncBailHook<T, R, AdditionalOptions = UnsetAdditionalOptions> extends HookBase<T, R, AdditionalOptions> {
+    callAsyncStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, R>>): void;
+    call(...args: AsArray<T>): R;
+    callStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: AsArray<T>): R;
+    tapAsync(): never;
+    tapPromise(): never;
+}
+export declare class SyncWaterfallHook<T, AdditionalOptions = UnsetAdditionalOptions> extends HookBase<T, AsArray<T>[0], AdditionalOptions> {
+    constructor(args?: ArgumentNames<AsArray<T>>, name?: string);
+    callAsyncStageRange(queried: QueriedHook<T, AsArray<T>[0], AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, AsArray<T>[0]>>): void;
+    call(...args: AsArray<T>): AsArray<T>[0];
+    callStageRange(queried: QueriedHook<T, AsArray<T>[0], AdditionalOptions>, ...args: AsArray<T>): AsArray<T>[0];
+    tapAsync(): never;
+    tapPromise(): never;
+}
+export declare class AsyncParallelHook<T, AdditionalOptions = UnsetAdditionalOptions> extends HookBase<T, void, AdditionalOptions> {
+    callAsyncStageRange(queried: QueriedHook<T, void, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, void>>): void;
+}
+export declare class AsyncSeriesHook<T, AdditionalOptions = UnsetAdditionalOptions> extends HookBase<T, void, AdditionalOptions> {
+    callAsyncStageRange(queried: QueriedHook<T, void, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, void>>): void;
+}
+export declare class AsyncSeriesBailHook<T, R, AdditionalOptions = UnsetAdditionalOptions> extends HookBase<T, R, AdditionalOptions> {
+    callAsyncStageRange(queried: QueriedHook<T, R, AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, R>>): void;
+}
+export declare class AsyncSeriesWaterfallHook<T, AdditionalOptions = UnsetAdditionalOptions> extends HookBase<T, AsArray<T>[0], AdditionalOptions> {
+    constructor(args?: ArgumentNames<AsArray<T>>, name?: string);
+    callAsyncStageRange(queried: QueriedHook<T, AsArray<T>[0], AdditionalOptions>, ...args: Append<AsArray<T>, Callback<Error, AsArray<T>[0]>>): void;
+}
+export type HookMapKey = any;
+export type HookFactory<H> = (key: HookMapKey, hook?: H) => H;
+export interface HookMapInterceptor<H> {
+    factory?: HookFactory<H>;
+}
+export declare class HookMap<H extends Hook> {
+    _map: Map<HookMapKey, H>;
+    _factory: HookFactory<H>;
+    name?: string;
+    _interceptors: HookMapInterceptor<H>[];
+    constructor(factory: HookFactory<H>, name?: string);
+    get(key: HookMapKey): H | undefined;
+    for(key: HookMapKey): H;
+    intercept(interceptor: HookMapInterceptor<H>): void;
+    isUsed(): boolean;
+    queryStageRange(stageRange: StageRange): QueriedHookMap<H>;
+}
+export declare class QueriedHookMap<H extends Hook> {
+    stageRange: StageRange;
+    hookMap: HookMap<H>;
+    constructor(stageRange: StageRange, hookMap: HookMap<H>);
+    get(key: HookMapKey): QueriedHook<any, any, UnsetAdditionalOptions> | undefined;
+    for(key: HookMapKey): QueriedHook<any, any, UnsetAdditionalOptions>;
+    isUsed(): boolean;
+}
+export declare class MultiHook<H extends Hook> {
+    hooks: H[];
+    name?: string;
+    constructor(hooks: H[], name?: string);
+    tap(options: Options<ExtractHookAdditionalOptions<Hook>>, fn: Fn<ExtractHookArgs<Hook>, ExtractHookReturn<Hook>>): void;
+    tapAsync(options: Options<ExtractHookAdditionalOptions<Hook>>, fn: FnAsync<ExtractHookArgs<Hook>, ExtractHookReturn<Hook>>): void;
+    tapPromise(options: Options<ExtractHookAdditionalOptions<Hook>>, fn: FnPromise<ExtractHookArgs<Hook>, ExtractHookReturn<Hook>>): void;
+    isUsed(): boolean;
+    intercept(interceptor: HookInterceptor<ExtractHookArgs<Hook>, ExtractHookReturn<Hook>, ExtractHookAdditionalOptions<Hook>>): void;
+    withOptions(options: TapOptions & IfSet<ExtractHookAdditionalOptions<Hook>>): MultiHook<Hook<any, any, UnsetAdditionalOptions>>;
+}
+export {};

package/compiled/@rspack/lite-tapable/license

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2022-present Bytedance, Inc. and its affiliates.
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/compiled/@rspack/lite-tapable/package.json

@@ -0,0 +1 @@
+{"name":"@rspack/lite-tapable","version":"1.1.0","license":"MIT","types":"./dist/index.d.ts","type":"module"}

package/dist/Compilation.d.ts

@@ -10,7 +10,7 @@
 import type { AssetInfo, ChunkGroup, Dependency, ExternalObject, JsCompilation } from '@rspack/binding';
 import binding from '@rspack/binding';
 export type { AssetInfo } from '@rspack/binding';
-import * as liteTapable from '@rspack/lite-tapable';
+import * as liteTapable from '../compiled/@rspack/lite-tapable/dist/index.d';
 import type { Source } from '../compiled/webpack-sources';
 import type { EntryOptions, EntryPlugin } from './builtin-plugin/index.js';
 import type { Chunk } from './Chunk.js';
@@ -162,6 +162,7 @@ export declare class Compilation {
             Iterable<Chunk>,
             Iterable<Module>
         ], void>;
+        beforeModuleIds: liteTapable.SyncHook<[Iterable<Module>]>;
         finishModules: liteTapable.AsyncSeriesHook<[Iterable<Module>], void>;
         chunkHash: liteTapable.SyncHook<[Chunk, Hash]>;
         chunkAsset: liteTapable.SyncHook<[Chunk, string]>;

package/dist/Compiler.d.ts

@@ -8,7 +8,7 @@
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 import type binding from '@rspack/binding';
-import * as liteTapable from '@rspack/lite-tapable';
+import * as liteTapable from '../compiled/@rspack/lite-tapable/dist/index.d';
 import type Watchpack from '../compiled/watchpack';
 import type { Source } from '../compiled/webpack-sources';
 import type { Chunk } from './Chunk.js';

package/dist/ContextModuleFactory.d.ts

@@ -1,4 +1,4 @@
-import * as liteTapable from '@rspack/lite-tapable';
+import * as liteTapable from '../compiled/@rspack/lite-tapable/dist/index.d';
 import type { ContextModuleFactoryAfterResolveResult, ContextModuleFactoryBeforeResolveResult } from './Module.js';
 export declare class ContextModuleFactory {
     hooks: {

package/dist/MultiCompiler.d.ts

@@ -7,7 +7,7 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-import * as liteTapable from '@rspack/lite-tapable';
+import * as liteTapable from '../compiled/@rspack/lite-tapable/dist/index.d';
 import type { CompilationParams, Compiler, CompilerHooks, RspackOptions } from './index.js';
 import type { WatchOptions } from './config/index.js';
 import MultiStats from './MultiStats.js';

package/dist/MultiWatching.d.ts

@@ -7,7 +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 { Callback } from '../compiled/@rspack/lite-tapable/dist/index.d';
 import type { MultiCompiler } from './MultiCompiler.js';
 import type { Watching } from './Watching.js';
 declare class MultiWatching {

package/dist/NormalModule.d.ts

@@ -1,10 +1,9 @@
-import * as liteTapable from '@rspack/lite-tapable';
+import * as liteTapable from '../compiled/@rspack/lite-tapable/dist/index.d';
 import type { Compilation } from './Compilation.js';
 import type { LoaderContext } from './config/index.js';
 import type { Module } from './Module.js';
 export interface NormalModuleCompilationHooks {
     loader: liteTapable.SyncHook<[LoaderContext, Module]>;
-    readResourceForScheme: any;
     readResource: liteTapable.HookMap<liteTapable.AsyncSeriesBailHook<[LoaderContext], string | Buffer>>;
 }
 declare module '@rspack/binding' {

package/dist/NormalModuleFactory.d.ts

@@ -1,5 +1,5 @@
 import type binding from '@rspack/binding';
-import * as liteTapable from '@rspack/lite-tapable';
+import * as liteTapable from '../compiled/@rspack/lite-tapable/dist/index.d';
 import type { ResolveData, ResourceDataWithData } from './Module.js';
 import type { ResolveOptionsWithDependencyType, ResolverFactory } from './ResolverFactory.js';
 export type NormalModuleCreateData = binding.JsNormalModuleFactoryCreateModuleArgs & {

package/dist/RuntimeGlobals.d.ts

@@ -352,5 +352,5 @@ export declare enum RuntimeVariable {
 }
 export declare function renderRuntimeVariables(variable: RuntimeVariable, _compilerOptions?: RspackOptionsNormalized): string;
 export declare function createCompilerRuntimeGlobals(compilerOptions?: RspackOptionsNormalized): Record<keyof typeof RuntimeGlobals, string>;
-declare const DefaultRuntimeGlobals: Record<"publicPath" | "chunkName" | "moduleId" | "module" | "require" | "global" | "system" | "exports" | "requireScope" | "thisAsExports" | "returnExportsFromRuntime" | "moduleLoaded" | "entryModuleId" | "moduleCache" | "moduleFactories" | "moduleFactoriesAddOnly" | "ensureChunk" | "ensureChunkHandlers" | "ensureChunkIncludeEntries" | "prefetchChunk" | "prefetchChunkHandlers" | "preloadChunk" | "preloadChunkHandlers" | "definePropertyGetters" | "makeNamespaceObject" | "createFakeNamespaceObject" | "compatGetDefaultExport" | "harmonyModuleDecorator" | "nodeModuleDecorator" | "getFullHash" | "wasmInstances" | "instantiateWasm" | "uncaughtErrorHandler" | "scriptNonce" | "loadScript" | "createScript" | "createScriptUrl" | "getTrustedTypesPolicy" | "hasFetchPriority" | "runtimeId" | "getChunkScriptFilename" | "getChunkCssFilename" | "rspackVersion" | "hasCssModules" | "rspackUniqueId" | "getChunkUpdateScriptFilename" | "getChunkUpdateCssFilename" | "startup" | "startupNoDefault" | "startupOnlyAfter" | "startupOnlyBefore" | "chunkCallback" | "startupEntrypoint" | "startupChunkDependencies" | "onChunksLoaded" | "externalInstallChunk" | "interceptModuleExecution" | "shareScopeMap" | "initializeSharing" | "currentRemoteGetScope" | "getUpdateManifestFilename" | "hmrDownloadManifest" | "hmrDownloadUpdateHandlers" | "hmrModuleData" | "hmrInvalidateModuleHandlers" | "hmrRuntimeStatePrefix" | "amdDefine" | "amdOptions" | "hasOwnProperty" | "systemContext" | "baseURI" | "relativeUrl" | "asyncModule" | "asyncModuleExportSymbol" | "makeDeferredNamespaceObject" | "makeDeferredNamespaceObjectSymbol", string>;
+declare const DefaultRuntimeGlobals: Record<"publicPath" | "chunkName" | "moduleId" | "module" | "exports" | "require" | "global" | "system" | "requireScope" | "thisAsExports" | "returnExportsFromRuntime" | "moduleLoaded" | "entryModuleId" | "moduleCache" | "moduleFactories" | "moduleFactoriesAddOnly" | "ensureChunk" | "ensureChunkHandlers" | "ensureChunkIncludeEntries" | "prefetchChunk" | "prefetchChunkHandlers" | "preloadChunk" | "preloadChunkHandlers" | "definePropertyGetters" | "makeNamespaceObject" | "createFakeNamespaceObject" | "compatGetDefaultExport" | "harmonyModuleDecorator" | "nodeModuleDecorator" | "getFullHash" | "wasmInstances" | "instantiateWasm" | "uncaughtErrorHandler" | "scriptNonce" | "loadScript" | "createScript" | "createScriptUrl" | "getTrustedTypesPolicy" | "hasFetchPriority" | "runtimeId" | "getChunkScriptFilename" | "getChunkCssFilename" | "rspackVersion" | "hasCssModules" | "rspackUniqueId" | "getChunkUpdateScriptFilename" | "getChunkUpdateCssFilename" | "startup" | "startupNoDefault" | "startupOnlyAfter" | "startupOnlyBefore" | "chunkCallback" | "startupEntrypoint" | "startupChunkDependencies" | "onChunksLoaded" | "externalInstallChunk" | "interceptModuleExecution" | "shareScopeMap" | "initializeSharing" | "currentRemoteGetScope" | "getUpdateManifestFilename" | "hmrDownloadManifest" | "hmrDownloadUpdateHandlers" | "hmrModuleData" | "hmrInvalidateModuleHandlers" | "hmrRuntimeStatePrefix" | "amdDefine" | "amdOptions" | "hasOwnProperty" | "systemContext" | "baseURI" | "relativeUrl" | "asyncModule" | "asyncModuleExportSymbol" | "makeDeferredNamespaceObject" | "makeDeferredNamespaceObjectSymbol", string>;
 export { DefaultRuntimeGlobals as RuntimeGlobals };

package/dist/Watching.d.ts

@@ -7,7 +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 { Callback } from '../compiled/@rspack/lite-tapable/dist/index.d';
 import type { Compiler } from './index.js';
 import { Stats } from './index.js';
 import type { WatchOptions } from './config/index.js';

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

@@ -1,5 +1,5 @@
 import { type BuiltinPlugin, BuiltinPluginName } from '@rspack/binding';
-import * as liteTapable from '@rspack/lite-tapable';
+import * as liteTapable from '../../compiled/@rspack/lite-tapable/dist/index.d';
 import type { Chunk } from '../Chunk.js';
 import { type Compilation } from '../Compilation.js';
 import type Hash from '../util/hash/index.js';

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

@@ -1,5 +1,5 @@
 import { type JsRsdoctorAsset, type JsRsdoctorAssetPatch, type JsRsdoctorChunk, type JsRsdoctorChunkAssets, type JsRsdoctorChunkGraph, type JsRsdoctorChunkModules, type JsRsdoctorDependency, type JsRsdoctorEntrypoint, type JsRsdoctorEntrypointAssets, type JsRsdoctorExportInfo, type JsRsdoctorModule, type JsRsdoctorModuleGraph, type JsRsdoctorModuleGraphModule, type JsRsdoctorModuleIdsPatch, type JsRsdoctorModuleOriginalSource, type JsRsdoctorModuleSourcesPatch, type JsRsdoctorSideEffect, type JsRsdoctorSourcePosition, type JsRsdoctorSourceRange, type JsRsdoctorStatement, type JsRsdoctorVariable } from '@rspack/binding';
-import * as liteTapable from '@rspack/lite-tapable';
+import * as liteTapable from '../../compiled/@rspack/lite-tapable/dist/index.d';
 import { type Compilation } from '../Compilation.js';
 import type { Compiler } from '../Compiler.js';
 import type { CreatePartialRegisters } from '../taps/types.js';

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

@@ -1,5 +1,5 @@
 import binding from '@rspack/binding';
-import * as liteTapable from '@rspack/lite-tapable';
+import * as liteTapable from '../../compiled/@rspack/lite-tapable/dist/index.d';
 import type { Chunk } from '../Chunk.js';
 import { type Compilation } from '../Compilation.js';
 import type { CreatePartialRegisters } from '../taps/types.js';

package/dist/builtin-plugin/html-plugin/hooks.d.ts

@@ -1,5 +1,5 @@
 import type { JsAfterEmitData, JsAfterTemplateExecutionData, JsAlterAssetTagGroupsData, JsAlterAssetTagsData, JsBeforeAssetTagGenerationData, JsBeforeEmitData } from '@rspack/binding';
-import * as liteTapable from '@rspack/lite-tapable';
+import * as liteTapable from '../../../compiled/@rspack/lite-tapable/dist/index.d';
 import { type Compilation } from '../../Compilation.js';
 import type { HtmlRspackPluginOptions } from './options.js';
 type ExtraPluginHookData = {

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

@@ -1,6 +1,6 @@
 import { type Compiler, MultiCompiler } from '../../index.js';
 import type { MiddlewareHandler } from '../../config/devServer.js';
-export declare const LAZY_COMPILATION_PREFIX = "/lazy-compilation-using-";
+export declare const LAZY_COMPILATION_PREFIX = "/_rspack/lazy/trigger";
 /**
  * Create a middleware that handles lazy compilation requests from the client.
  * This function returns an Express-style middleware that listens for

package/dist/config/types.d.ts

@@ -367,7 +367,6 @@ export type Output = {
     library?: Library;
     /**
      * Output JavaScript files as module type.
-     * Disabled by default as it's an experimental feature. To use it, you must set experiments.outputModule to true.
      * @default false
      */
     module?: OutputModule;
@@ -718,6 +717,14 @@ export type AssetParserOptions = {
 };
 export type CssParserNamedExports = boolean;
 export type CssParserUrl = boolean;
+export type CssParserResolveImportContext = {
+    url: string;
+    media: string | undefined;
+    resourcePath: string;
+    supports: string | undefined;
+    layer: string | undefined;
+};
+export type CssParserResolveImport = boolean | ((context: CssParserResolveImportContext) => boolean);
 /** Options object for `css` modules. */
 export type CssParserOptions = {
     /**
@@ -730,6 +737,11 @@ export type CssParserOptions = {
      * @default true
      * */
     url?: CssParserUrl;
+    /**
+     * Allow to enable/disables `@import` at-rules handling.
+     * @default true
+     * */
+    resolveImport?: CssParserResolveImport;
 };
 /** Options object for `css/auto` modules. */
 export type CssAutoParserOptions = {
@@ -743,6 +755,11 @@ export type CssAutoParserOptions = {
      * @default true
      * */
     url?: CssParserUrl;
+    /**
+     * Allow to enable/disables `@import` at-rules handling.
+     * @default true
+     * */
+    resolveImport?: CssParserResolveImport;
 };
 /** Options object for `css/module` modules. */
 export type CssModuleParserOptions = {
@@ -756,6 +773,11 @@ export type CssModuleParserOptions = {
      * @default true
      * */
     url?: CssParserUrl;
+    /**
+     * Allow to enable/disables `@import` at-rules handling.
+     * @default true
+     * */
+    resolveImport?: CssParserResolveImport;
 };
 type ExportsPresence = 'error' | 'warn' | 'auto' | false;
 export type JavascriptParserCommonjsExports = boolean | 'skipInEsm';
@@ -815,15 +837,13 @@ export type JavascriptParserOptions = {
     wrappedContextRegExp?: RegExp;
     /**
      * Warn or error for using non-existent exports and conflicting re-exports.
-     * @default 'auto'
+     * @default 'error'
      */
     exportsPresence?: ExportsPresence;
     /** Warn or error for using non-existent exports */
     importExportsPresence?: ExportsPresence;
     /** Warn or error for conflicting re-exports */
     reexportExportsPresence?: ExportsPresence;
-    /** Emit errors instead of warnings when imported names don't exist in imported module. */
-    strictExportPresence?: boolean;
     /** Provide custom syntax for Worker parsing, commonly used to support Worklet */
     worker?: string[] | boolean;
     /** Override the module to strict or non-strict. */
@@ -1299,6 +1319,12 @@ export type PersistentCacheOptions = {
      * @default false
      */
     portable?: boolean;
+    /**
+     * Enable read-only mode. When enabled, the cache will only be read from disk and never written to.
+     * @description This is useful for CI environments where you want to use a pre-warmed cache without modifying it.
+     * @default false
+     */
+    readonly?: boolean;
 };
 /**
  * Memory cache options.
@@ -2031,7 +2057,7 @@ export type LazyCompilationOptions = {
     serverUrl?: string;
     /**
      * Customize the prefix used for lazy compilation endpoint.
-     * @default "/lazy-compilation-using-"
+     * @default "/_rspack/lazy/trigger"
      */
     prefix?: string;
 };

package/dist/container/ModuleFederationManifestPlugin.d.ts

@@ -1,6 +1,7 @@
 import { type BuiltinPlugin, BuiltinPluginName } from '@rspack/binding';
 import { RspackBuiltinPlugin } from '../builtin-plugin/base.js';
 import type { Compiler } from '../Compiler.js';
+import { type ModuleFederationPluginOptions } from './ModuleFederationPlugin.js';
 export type RemoteAliasMap = Record<string, {
     name: string;
     entry?: string;
@@ -15,7 +16,7 @@ export type ManifestSharedOption = {
     requiredVersion?: string;
     singleton?: boolean;
 };
-export type ModuleFederationManifestPluginOptions = {
+type InternalManifestPluginOptions = {
     name?: string;
     globalName?: string;
     filePath?: string;
@@ -25,13 +26,19 @@ export type ModuleFederationManifestPluginOptions = {
     exposes?: ManifestExposeOption[];
     shared?: ManifestSharedOption[];
 };
+export type ModuleFederationManifestPluginOptions = boolean | Pick<InternalManifestPluginOptions, 'disableAssetsAnalyze' | 'filePath' | 'fileName'>;
+export declare function getFileName(manifestOptions: ModuleFederationManifestPluginOptions): {
+    statsFileName: string;
+    manifestFileName: string;
+};
 /**
  * JS-side post-processing plugin: reads mf-manifest.json and mf-stats.json, executes additionalData callback and merges/overwrites manifest.
  * To avoid cross-NAPI callback complexity, this plugin runs at the afterProcessAssets stage to ensure Rust-side MfManifestPlugin has already output its artifacts.
  */
 export declare class ModuleFederationManifestPlugin extends RspackBuiltinPlugin {
     name: BuiltinPluginName;
-    private opts;
-    constructor(opts: ModuleFederationManifestPluginOptions);
+    private rawOpts;
+    constructor(opts: ModuleFederationPluginOptions);
     raw(compiler: Compiler): BuiltinPlugin;
 }
+export {};

package/dist/container/ModuleFederationPlugin.d.ts

@@ -1,4 +1,5 @@
 import type { Compiler } from '../Compiler.js';
+import type { ExternalsType } from '../config/index.js';
 import { type ModuleFederationManifestPluginOptions } from './ModuleFederationManifestPlugin.js';
 import type { ModuleFederationPluginV1Options } from './ModuleFederationPluginV1.js';
 import { type ModuleFederationRuntimeExperimentsOptions } from './ModuleFederationRuntimePlugin.js';
@@ -6,12 +7,27 @@ export interface ModuleFederationPluginOptions extends Omit<ModuleFederationPlug
     runtimePlugins?: RuntimePlugins;
     implementation?: string;
     shareStrategy?: 'version-first' | 'loaded-first';
-    manifest?: boolean | Omit<ModuleFederationManifestPluginOptions, 'remoteAliasMap' | 'globalName' | 'name' | 'exposes' | 'shared'>;
+    manifest?: ModuleFederationManifestPluginOptions;
+    injectTreeShakingUsedExports?: boolean;
+    treeShakingSharedDir?: string;
+    treeShakingSharedExcludePlugins?: string[];
+    treeShakingSharedPlugins?: string[];
     experiments?: ModuleFederationRuntimeExperimentsOptions;
 }
 export type RuntimePlugins = string[] | [string, Record<string, unknown>][];
 export declare class ModuleFederationPlugin {
     private _options;
+    private _treeShakingSharedPlugin?;
     constructor(_options: ModuleFederationPluginOptions);
     apply(compiler: Compiler): void;
 }
+interface RemoteInfo {
+    alias: string;
+    name?: string;
+    entry?: string;
+    externalType: ExternalsType;
+    shareScope: string;
+}
+type RemoteInfos = Record<string, RemoteInfo[]>;
+export declare function getRemoteInfos(options: ModuleFederationPluginOptions): RemoteInfos;
+export {};

package/dist/exports.d.ts

@@ -43,7 +43,7 @@ type Config = {
 export declare const config: Config;
 export type * from './config/index.js';
 export declare const util: {
-    createHash: (algorithm: "debug" | "xxhash64" | "md4" | "native-md4" | (string & {}) | (new () => import("./util/hash/index.js").default)) => import("./util/hash/index.js").default;
+    createHash: (algorithm: "xxhash64" | "md4" | "native-md4" | (string & {}) | (new () => import("./util/hash/index.js").default)) => import("./util/hash/index.js").default;
     cleverMerge: <First, Second>(first: First, second: Second) => First | Second | (First & Second);
 };
 export type { BannerPluginArgument, DefinePluginOptions, EntryOptions, ProgressPluginArgument, ProvidePluginOptions, } from './builtin-plugin/index.js';
@@ -121,11 +121,14 @@ export declare const container: {
 import { ConsumeSharedPlugin } from './sharing/ConsumeSharedPlugin.js';
 import { ProvideSharedPlugin } from './sharing/ProvideSharedPlugin.js';
 import { SharePlugin } from './sharing/SharePlugin.js';
+import { TreeShakingSharedPlugin } from './sharing/TreeShakingSharedPlugin.js';
 export type { ConsumeSharedPluginOptions, Consumes, ConsumesConfig, ConsumesItem, ConsumesObject, } from './sharing/ConsumeSharedPlugin.js';
 export type { ProvideSharedPluginOptions, Provides, ProvidesConfig, ProvidesItem, ProvidesObject, } from './sharing/ProvideSharedPlugin.js';
 export type { Shared, SharedConfig, SharedItem, SharedObject, SharePluginOptions, } from './sharing/SharePlugin.js';
+export type { TreeshakingSharedPluginOptions } from './sharing/TreeShakingSharedPlugin.js';
 export declare const sharing: {
     ProvideSharedPlugin: typeof ProvideSharedPlugin;
+    TreeShakingSharedPlugin: typeof TreeShakingSharedPlugin;
     ConsumeSharedPlugin: typeof ConsumeSharedPlugin;
     SharePlugin: typeof SharePlugin;
 };

package/dist/index.d.ts

@@ -8,4 +8,4 @@ declare const rspack: Rspack;
 export * from './exports.js';
 export default rspack;
 export { rspack };
-export { rspack as 'module.exports' };
+