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

package/dist/Compiler.d.ts

@@ -79,6 +79,7 @@ export type CompilerHooks = {
     entryOption: liteTapable.SyncBailHook<[string, EntryNormalized], any>;
     additionalPass: liteTapable.AsyncSeriesHook<[]>;
 };
+export declare const GET_COMPILER_ID: unique symbol;
 declare class Compiler {
     #private;
     hooks: CompilerHooks;

package/dist/builtin-loader/swc/types.d.ts

@@ -21,6 +21,10 @@ export type SwcLoaderOptions = Config & {
      */
     rspackExperiments?: {
         import?: PluginImportOptions;
+        /**
+         * Enable React Server Components support.
+         */
+        reactServerComponents?: boolean;
     };
 };
 export interface TerserCompressOptions {

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

@@ -73,6 +73,7 @@ export * from './RslibPlugin.js';
 export * from './RstestPlugin.js';
 export * from './RuntimeChunkPlugin.js';
 export * from './RuntimePlugin.js';
+export { rsc } from './rsc/index.js';
 export * from './SideEffectsFlagPlugin.js';
 export * from './SizeLimitsPlugin.js';
 export * from './SourceMapDevToolPlugin.js';

package/dist/builtin-plugin/rsc/Coordinator.d.ts

@@ -0,0 +1,8 @@
+import { type Compiler } from '../../Compiler.js';
+export declare const GET_OR_INIT_BINDING: unique symbol;
+export declare class Coordinator {
+    #private;
+    constructor();
+    applyServerCompiler(serverCompiler: Compiler): void;
+    applyClientCompiler(clientCompiler: Compiler): void;
+}

package/dist/builtin-plugin/rsc/RscClientPlugin.d.ts

@@ -0,0 +1,13 @@
+import type binding from '@rspack/binding';
+import type { Compiler } from '../../index.js';
+import { RspackBuiltinPlugin } from '../base.js';
+import { type Coordinator } from './Coordinator.js';
+export type RscClientPluginOptions = {
+    coordinator: Coordinator;
+};
+export declare class RscClientPlugin extends RspackBuiltinPlugin {
+    #private;
+    name: string;
+    constructor(options: RscClientPluginOptions);
+    raw(compiler: Compiler): binding.BuiltinPlugin;
+}

package/dist/builtin-plugin/rsc/RscServerPlugin.d.ts

@@ -0,0 +1,14 @@
+import type binding from '@rspack/binding';
+import type { Compiler } from '../../index.js';
+import { RspackBuiltinPlugin } from '../base.js';
+import { type Coordinator } from './Coordinator.js';
+export type RscServerPluginOptions = {
+    coordinator: Coordinator;
+    onServerComponentChanges?: () => Promise<void>;
+};
+export declare class RscServerPlugin extends RspackBuiltinPlugin {
+    #private;
+    name: string;
+    constructor(options: RscServerPluginOptions);
+    raw(compiler: Compiler): binding.BuiltinPlugin;
+}

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

@@ -0,0 +1,24 @@
+import { RscClientPlugin, type RscClientPluginOptions } from './RscClientPlugin.js';
+import { RscServerPlugin } from './RscServerPlugin.js';
+declare class ServerPlugin extends RscServerPlugin {
+    constructor(options?: Omit<RscClientPluginOptions, 'coordinator'>);
+}
+declare class ClientPlugin extends RscClientPlugin {
+}
+export declare const rsc: {
+    createPlugins: () => {
+        ServerPlugin: new (options?: Omit<RscClientPluginOptions, "coordinator">) => ServerPlugin;
+        ClientPlugin: new () => ClientPlugin;
+    };
+    Layers: {
+        /**
+         * The layer for server-only runtime and picking up `react-server` export conditions.
+         */
+        readonly rsc: "react-server-components";
+        /**
+         * Server Side Rendering layer for app.
+         */
+        readonly ssr: "server-side-rendering";
+    };
+};
+export {};

package/dist/config/normalization.d.ts

@@ -76,7 +76,6 @@ export interface ModuleOptionsNormalized {
     parser: ParserOptionsByModuleType;
     generator: GeneratorOptionsByModuleType;
     noParse?: NoParseOption;
-    unsafeCache?: boolean | RegExp;
 }
 export type CacheNormalized = boolean | {
     type: 'memory';
@@ -93,10 +92,10 @@ export type CacheNormalized = boolean | {
         type: 'filesystem';
         directory: string;
     };
+    portable?: boolean;
 };
 export interface ExperimentsNormalized {
     asyncWebAssembly?: boolean;
-    outputModule?: boolean;
     css?: boolean;
     futureDefaults?: boolean;
     buildHttp?: HttpUriPluginOptions;

package/dist/config/types.d.ts

@@ -1044,10 +1044,6 @@ export type ModuleOptions = {
     generator?: GeneratorOptionsByModuleType;
     /** Keep module mechanism of the matched modules as-is, such as module.exports, require, import. */
     noParse?: NoParseOption;
-    /**
-     * Cache the resolving of module requests.
-     */
-    unsafeCache?: boolean | RegExp;
 };
 type AllowTarget = 'web' | 'webworker' | 'es3' | 'es5' | 'es2015' | 'es2016' | 'es2017' | 'es2018' | 'es2019' | 'es2020' | 'es2021' | 'es2022' | 'es2023' | 'es2024' | 'es2025' | 'node' | 'async-node' | `node${number}` | `async-node${number}` | `node${number}.${number}` | `async-node${number}.${number}` | 'electron-main' | `electron${number}-main` | `electron${number}.${number}-main` | 'electron-renderer' | `electron${number}-renderer` | `electron${number}.${number}-renderer` | 'electron-preload' | `electron${number}-preload` | `electron${number}.${number}-preload` | 'nwjs' | `nwjs${number}` | `nwjs${number}.${number}` | 'node-webkit' | `node-webkit${number}` | `node-webkit${number}.${number}` | 'browserslist' | `browserslist:${string}`;
 /** Used to configure the target environment of Rspack output and the ECMAScript version of Rspack runtime code. */
@@ -1239,6 +1235,80 @@ export type NodeOptions = {
 export type Node = false | NodeOptions;
 export type Loader = Record<string, any>;
 export type SnapshotOptions = {};
+/**
+ * Snapshot options for determining which files have been modified.
+ */
+export type CacheSnapshotOptions = {
+    /**
+     * An array of paths to immutable files, changes to these paths will be ignored during hot restart.
+     */
+    immutablePaths?: (string | RegExp)[];
+    /**
+     * An array of paths in managedPaths that are not managed by the package manager.
+     */
+    unmanagedPaths?: (string | RegExp)[];
+    /**
+     * An array of paths managed by the package manager.
+     * @default [/[\\/]node_modules[\\/][^.]/]
+     */
+    managedPaths?: (string | RegExp)[];
+};
+/**
+ * Storage options for persistent cache.
+ */
+export type CacheStorageOptions = {
+    /**
+     * Storage type, currently only supports 'filesystem'.
+     */
+    type: 'filesystem';
+    /**
+     * Cache directory path.
+     * @default 'node_modules/.cache/rspack'
+     */
+    directory?: string;
+};
+/**
+ * Persistent cache options.
+ */
+export type PersistentCacheOptions = {
+    /**
+     * Cache type.
+     */
+    type: 'persistent';
+    /**
+     * An array of files containing build dependencies, Rspack will use the hash of each of these files to invalidate the persistent cache.
+     * @default []
+     */
+    buildDependencies?: string[];
+    /**
+     * Cache version, different versions of caches are isolated from each other.
+     * @default ""
+     */
+    version?: string;
+    /**
+     * Snapshot options for determining which files have been modified.
+     */
+    snapshot?: CacheSnapshotOptions;
+    /**
+     * Storage options for cache.
+     */
+    storage?: CacheStorageOptions;
+    /**
+     * Enable portable cache mode. When enabled, the generated cache content can be shared across different platforms and paths within the same project.
+     * @description Portable cache makes the cache platform-independent by converting platform-specific data (e.g., absolute paths to relative paths) during serialization and deserialization.
+     * @default false
+     */
+    portable?: boolean;
+};
+/**
+ * Memory cache options.
+ */
+export type MemoryCacheOptions = {
+    /**
+     * Cache type.
+     */
+    type: 'memory';
+};
 /**
  * Options for caching snapshots and intermediate products during the build process.
  * @description Controls whether caching is enabled or disabled.
@@ -1250,22 +1320,7 @@ export type SnapshotOptions = {};
  * // Disable caching
  * cache: false
  */
-export type CacheOptions = boolean | {
-    type: 'memory';
-} | {
-    type: 'persistent';
-    buildDependencies?: string[];
-    version?: string;
-    snapshot?: {
-        immutablePaths?: (string | RegExp)[];
-        unmanagedPaths?: (string | RegExp)[];
-        managedPaths?: (string | RegExp)[];
-    };
-    storage?: {
-        type: 'filesystem';
-        directory?: string;
-    };
-};
+export type CacheOptions = boolean | MemoryCacheOptions | PersistentCacheOptions;
 export type StatsPresets = 'normal' | 'none' | 'verbose' | 'errors-only' | 'errors-warnings' | 'minimal' | 'detailed' | 'summary';
 type ModuleFilterItemTypes = RegExp | string | ((name: string, module: any, type: any) => boolean);
 type ModuleFilterTypes = boolean | ModuleFilterItemTypes | ModuleFilterItemTypes[];
@@ -1989,25 +2044,17 @@ export type Incremental = {
      */
     silent?: boolean;
     /**
-     * Enable incremental make.
+     * Enable incremental build module graph.
      */
-    make?: boolean;
+    buildModuleGraph?: boolean;
     /**
-     * Enable inference of async modules.
+     * Enable incremental finish modules.
      */
-    inferAsyncModules?: boolean;
+    finishModules?: boolean;
     /**
-     * Enable incremental provided exports.
+     * Enable incremental optimize dependencies.
      */
-    providedExports?: boolean;
-    /**
-     * Enables diagnostics for dependencies.
-     */
-    dependenciesDiagnostics?: boolean;
-    /**
-     * Enables incremental side effects optimization.
-     */
-    sideEffects?: boolean;
+    optimizeDependencies?: boolean;
     /**
      * Enable incremental build chunk graph.
      */
@@ -2041,11 +2088,11 @@ export type Incremental = {
      */
     chunksHashes?: boolean;
     /**
-     * Enable incremental chunk render.
+     * Enable incremental chunk asset.
      */
-    chunksRender?: boolean;
+    chunkAsset?: boolean;
     /**
-     * Enable incremental asset emission.
+     * Enable incremental emit assets.
      */
     emitAssets?: boolean;
 };
@@ -2071,11 +2118,6 @@ export type Experiments = {
      * @default false
      */
     asyncWebAssembly?: boolean;
-    /**
-     * Enable output as ES module.
-     * @default false
-     */
-    outputModule?: boolean;
     /**
      * Enable CSS support.
      *

package/dist/exports.d.ts

@@ -55,7 +55,7 @@ export { EnvironmentPlugin } from './lib/EnvironmentPlugin.js';
 export { LoaderOptionsPlugin } from './lib/LoaderOptionsPlugin.js';
 export { LoaderTargetPlugin } from './lib/LoaderTargetPlugin.js';
 export type { OutputFileSystem, WatchFileSystem } from './util/fs.js';
-import { FetchCompileAsyncWasmPlugin, lazyCompilationMiddleware, SubresourceIntegrityPlugin } from './builtin-plugin/index.js';
+import { FetchCompileAsyncWasmPlugin, lazyCompilationMiddleware, rsc, SubresourceIntegrityPlugin } from './builtin-plugin/index.js';
 export { SubresourceIntegrityPlugin };
 interface Web {
     FetchCompileAsyncWasmPlugin: typeof FetchCompileAsyncWasmPlugin;
@@ -161,5 +161,6 @@ interface Experiments {
     CssChunkingPlugin: typeof CssChunkingPlugin;
     createNativePlugin: typeof createNativePlugin;
     VirtualModulesPlugin: typeof VirtualModulesPlugin;
+    rsc: typeof rsc;
 }
 export declare const experiments: Experiments;

package/dist/index.d.ts

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

package/dist/index.js

@@ -598,6 +598,17 @@ class Stats {
             compilation: this.compilation,
             getStatsCompilation: (compilation)=>{
                 if (statsCompilationMap.has(compilation)) return statsCompilationMap.get(compilation);
+                if (this.compilation !== this.compilation.compiler._lastCompilation) return {
+                    assets: [],
+                    assetsByChunkName: [],
+                    chunks: [],
+                    entrypoints: [],
+                    errors: [],
+                    hash: 'XXXX',
+                    modules: [],
+                    namedChunkGroups: [],
+                    warnings: []
+                };
                 let innerStats = this.#getInnerByCompilation(compilation);
                 options.warnings = !1;
                 let innerStatsCompilation = innerStats.toJson(options);
@@ -613,6 +624,17 @@ class Stats {
             compilation: this.compilation,
             getStatsCompilation: (compilation)=>{
                 if (statsCompilationMap.has(compilation)) return statsCompilationMap.get(compilation);
+                if (this.compilation !== this.compilation.compiler._lastCompilation) return {
+                    assets: [],
+                    assetsByChunkName: [],
+                    chunks: [],
+                    entrypoints: [],
+                    errors: [],
+                    hash: 'XXXX',
+                    modules: [],
+                    namedChunkGroups: [],
+                    warnings: []
+                };
                 let innerStatsCompilation = this.#getInnerByCompilation(compilation).toJson(options);
                 return statsCompilationMap.set(compilation, innerStatsCompilation), innerStatsCompilation;
             },
@@ -1453,7 +1475,18 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             seal: new SyncHook([]),
             afterSeal: new AsyncSeriesHook([]),
             needAdditionalPass: new SyncBailHook([])
-        }, this.compiler = compiler, this.resolverFactory = compiler.resolverFactory, this.inputFileSystem = compiler.inputFileSystem, this.options = compiler.options, this.outputOptions = compiler.options.output, this.logging = new Map(), this.childrenCounters = {}, this.children = [], this.needAdditionalPass = !1, this.chunkGraph = inner.chunkGraph, this.moduleGraph = ModuleGraph.__from_binding(inner.moduleGraph), this.#addIncludeDispatcher = new AddEntryItemDispatcher(inner.addInclude.bind(inner)), this.#addEntryDispatcher = new AddEntryItemDispatcher(inner.addEntry.bind(inner)), this[binding_default().COMPILATION_HOOKS_MAP_SYMBOL] = new WeakMap();
+        };
+        let availableHooks = Object.keys(this.hooks);
+        this.hooks = new Proxy(this.hooks, {
+            get (target, prop, receiver) {
+                let value = Reflect.get(target, prop, receiver);
+                if (void 0 === value && 'string' == typeof prop) {
+                    let hooksList = availableHooks.join(', ');
+                    throw Error(`Compilation.hooks.${prop} is not supported in rspack. This typically happens when using webpack plugins that rely on webpack-specific hooks. Consider using an rspack-compatible alternative or removing the incompatible plugin.\n\nAvailable compilation hooks: ${hooksList}`);
+                }
+                return value;
+            }
+        }), this.compiler = compiler, this.resolverFactory = compiler.resolverFactory, this.inputFileSystem = compiler.inputFileSystem, this.options = compiler.options, this.outputOptions = compiler.options.output, this.logging = new Map(), this.childrenCounters = {}, this.children = [], this.needAdditionalPass = !1, this.chunkGraph = inner.chunkGraph, this.moduleGraph = ModuleGraph.__from_binding(inner.moduleGraph), this.#addIncludeDispatcher = new AddEntryItemDispatcher(inner.addInclude.bind(inner)), this.#addEntryDispatcher = new AddEntryItemDispatcher(inner.addEntry.bind(inner)), this[binding_default().COMPILATION_HOOKS_MAP_SYMBOL] = new WeakMap();
     }
     get hash() {
         return this.#inner.hash;
@@ -2164,7 +2197,7 @@ class EnableLibraryPlugin extends RspackBuiltinPlugin {
 }
 let EnableWasmLoadingPlugin = base_create(binding_namespaceObject.BuiltinPluginName.EnableWasmLoadingPlugin, (type)=>type), EnsureChunkConditionsPlugin = base_create(binding_namespaceObject.BuiltinPluginName.EnsureChunkConditionsPlugin, ()=>{}), RemoveDuplicateModulesPlugin = base_create(binding_namespaceObject.BuiltinPluginName.RemoveDuplicateModulesPlugin, ()=>({}));
 function applyLimits(options) {
-    options.optimization.concatenateModules = !1, options.optimization.removeEmptyChunks = !1, options.output.chunkFormat = !1, options.output.module = !0, options.output.chunkLoading && 'import' !== options.output.chunkLoading && (options.output.chunkLoading = 'import'), void 0 === options.output.chunkLoading && (options.output.chunkLoading = 'import');
+    options.optimization.concatenateModules = !1, options.optimization.removeEmptyChunks = !1, options.output.chunkFormat = !1, options.output.chunkLoading && 'import' !== options.output.chunkLoading && (options.output.chunkLoading = 'import'), void 0 === options.output.chunkLoading && (options.output.chunkLoading = 'import');
     let { splitChunks } = options.optimization;
     void 0 === splitChunks && (splitChunks = options.optimization.splitChunks = {}), !1 !== splitChunks && (splitChunks.chunks = 'all', splitChunks.minSize = 0, splitChunks.maxAsyncRequests = 1 / 0, splitChunks.maxInitialRequests = 1 / 0, splitChunks.cacheGroups ??= {}, splitChunks.cacheGroups.default = !1, splitChunks.cacheGroups.defaultVendors = !1);
 }
@@ -4563,6 +4596,66 @@ RuntimePlugin.getCompilationHooks = (compilation)=>{
         ])
     }, RuntimePlugin_compilationHooksMap.set(compilation, hooks)), hooks;
 };
+let Coordinator_PLUGIN_NAME = 'RscPlugin', GET_OR_INIT_BINDING = Symbol('GET_OR_INIT_BINDING');
+class Coordinator {
+    #serverCompiler;
+    #clientCompiler;
+    #clientLastCompilation;
+    #isProxyingClientWatching = !1;
+    #binding;
+    constructor(){
+        Object.defineProperty(this, GET_OR_INIT_BINDING, {
+            enumerable: !1,
+            configurable: !1,
+            writable: !1,
+            value: ()=>(this.#binding || (this.#binding = new binding_namespaceObject.JsCoordinator(()=>{
+                    if (!this.#serverCompiler) throw Error("[RscPlugin] Coordinator.getOrInitBinding() called before the server compiler was attached. Call coordinator.applyServerCompiler(serverCompiler) first.");
+                    return this.#serverCompiler[GET_COMPILER_ID]();
+                })), this.#binding)
+        });
+    }
+    applyServerCompiler(serverCompiler) {
+        this.#serverCompiler = serverCompiler, serverCompiler.hooks.done.tap(Coordinator_PLUGIN_NAME, (stats)=>{
+            this.#isProxyingClientWatching = !0, this.#clientLastCompilation && (stats.compilation.fileDependencies.addAll(this.#clientLastCompilation.fileDependencies), stats.compilation.contextDependencies.addAll(this.#clientLastCompilation.contextDependencies), stats.compilation.missingDependencies.addAll(this.#clientLastCompilation.missingDependencies));
+        }), serverCompiler.hooks.watchRun.tap(Coordinator_PLUGIN_NAME, ()=>{
+            this.#isProxyingClientWatching && this.#clientCompiler.watching.invalidateWithChangesAndRemovals(new Set(this.#serverCompiler.modifiedFiles), new Set(this.#serverCompiler.removedFiles));
+        });
+    }
+    applyClientCompiler(clientCompiler) {
+        this.#clientCompiler = clientCompiler;
+        let originalWatch = clientCompiler.watch;
+        clientCompiler.watch = function(watchOptions, handler) {
+            return watchOptions.ignored = ()=>!0, originalWatch.call(this, watchOptions, handler);
+        }, clientCompiler.hooks.done.tap(Coordinator_PLUGIN_NAME, (stats)=>{
+            this.#clientLastCompilation = stats.compilation;
+        });
+    }
+}
+class RscClientPlugin extends RspackBuiltinPlugin {
+    name = 'RscClientPlugin';
+    #options;
+    constructor(options){
+        super(), this.#options = options;
+    }
+    raw(compiler) {
+        return this.#options.coordinator.applyClientCompiler(compiler), createBuiltinPlugin(this.name, {
+            coordinator: this.#options.coordinator[GET_OR_INIT_BINDING]()
+        });
+    }
+}
+class RscServerPlugin extends RspackBuiltinPlugin {
+    name = 'RscServerPlugin';
+    #options;
+    constructor(options){
+        super(), this.#options = options;
+    }
+    raw(compiler) {
+        return this.#options.coordinator.applyServerCompiler(compiler), createBuiltinPlugin(this.name, {
+            coordinator: this.#options.coordinator[GET_OR_INIT_BINDING](),
+            onServerComponentChanges: this.#options.onServerComponentChanges
+        });
+    }
+}
 let SideEffectsFlagPlugin = base_create(binding_namespaceObject.BuiltinPluginName.SideEffectsFlagPlugin, ()=>{}, 'compilation'), SizeLimitsPlugin = base_create(binding_namespaceObject.BuiltinPluginName.SizeLimitsPlugin, (options)=>{
     let hints = !1 === options.hints ? void 0 : options.hints;
     return {
@@ -5955,7 +6048,6 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
     }), applySnapshotDefaults(options.snapshot, {
         production
     }), applyModuleDefaults(options.module, {
-        cache: !!options.cache,
         asyncWebAssembly: options.experiments.asyncWebAssembly,
         targetProperties,
         mode: options.mode,
@@ -5965,7 +6057,6 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         context: options.context,
         targetProperties,
         isAffectedByBrowserslist: void 0 === target || 'string' == typeof target && target.startsWith('browserslist') || Array.isArray(target) && target.some((target)=>target.startsWith('browserslist')),
-        outputModule: options.experiments.outputModule,
         entry: options.entry
     }), applyExternalsPresetsDefaults(options.externalsPresets, {
         targetProperties,
@@ -5998,11 +6089,11 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
 }, applyExperimentsDefaults = (experiments)=>{
     D(experiments, 'futureDefaults', !1), D(experiments, 'asyncWebAssembly', !0), D(experiments, 'deferImport', !1), D(experiments, 'buildHttp', void 0), experiments.buildHttp && 'object' == typeof experiments.buildHttp && D(experiments.buildHttp, 'upgrade', !1), D(experiments, 'useInputFileSystem', !1);
 }, applyIncrementalDefaults = (options)=>{
-    D(options, 'incremental', {}), 'object' == typeof options.incremental && (D(options.incremental, 'silent', !0), D(options.incremental, 'make', !0), D(options.incremental, 'inferAsyncModules', !0), D(options.incremental, 'providedExports', !0), D(options.incremental, 'dependenciesDiagnostics', !0), D(options.incremental, 'sideEffects', !0), D(options.incremental, 'buildChunkGraph', !1), D(options.incremental, 'moduleIds', !0), D(options.incremental, 'chunkIds', !0), D(options.incremental, 'modulesHashes', !0), D(options.incremental, 'modulesCodegen', !0), D(options.incremental, 'modulesRuntimeRequirements', !0), D(options.incremental, 'chunksRuntimeRequirements', !0), D(options.incremental, 'chunksHashes', !0), D(options.incremental, 'chunksRender', !0), D(options.incremental, 'emitAssets', !0));
+    D(options, 'incremental', {}), 'object' == typeof options.incremental && (D(options.incremental, 'silent', !0), D(options.incremental, 'buildModuleGraph', !0), D(options.incremental, 'finishModules', !0), D(options.incremental, 'optimizeDependencies', !0), D(options.incremental, 'buildChunkGraph', !0), D(options.incremental, 'moduleIds', !0), D(options.incremental, 'chunkIds', !0), D(options.incremental, 'modulesHashes', !0), D(options.incremental, 'modulesCodegen', !0), D(options.incremental, 'modulesRuntimeRequirements', !0), D(options.incremental, 'chunksRuntimeRequirements', !0), D(options.incremental, 'chunksHashes', !0), D(options.incremental, 'chunkAsset', !0), D(options.incremental, 'emitAssets', !0));
 }, applySnapshotDefaults = (_snapshot, _env)=>{}, applyCssGeneratorOptionsDefaults = (generatorOptions, { targetProperties })=>{
     D(generatorOptions, 'exportsOnly', !targetProperties || !1 === targetProperties.document), D(generatorOptions, 'esModule', !0);
-}, applyModuleDefaults = (module, { cache, asyncWebAssembly, targetProperties, mode, uniqueName, deferImport })=>{
-    assertNotNill(module.parser), assertNotNill(module.generator), cache ? D(module, 'unsafeCache', /[\\/]node_modules[\\/]/) : D(module, 'unsafeCache', !1), F(module.parser, "asset", ()=>({})), assertNotNill(module.parser.asset), F(module.parser.asset, 'dataUrlCondition', ()=>({})), 'object' == typeof module.parser.asset.dataUrlCondition && D(module.parser.asset.dataUrlCondition, 'maxSize', 8096), F(module.parser, "javascript", ()=>({})), assertNotNill(module.parser.javascript), ((parserOptions, { deferImport })=>{
+}, applyModuleDefaults = (module, { asyncWebAssembly, targetProperties, mode, uniqueName, deferImport })=>{
+    assertNotNill(module.parser), assertNotNill(module.generator), F(module.parser, "asset", ()=>({})), assertNotNill(module.parser.asset), F(module.parser.asset, 'dataUrlCondition', ()=>({})), 'object' == typeof module.parser.asset.dataUrlCondition && D(module.parser.asset.dataUrlCondition, 'maxSize', 8096), F(module.parser, "javascript", ()=>({})), assertNotNill(module.parser.javascript), ((parserOptions, { deferImport })=>{
         D(parserOptions, 'dynamicImportMode', 'lazy'), D(parserOptions, 'dynamicImportPrefetch', !1), D(parserOptions, 'dynamicImportPreload', !1), D(parserOptions, 'url', !0), D(parserOptions, 'exprContextCritical', !0), D(parserOptions, 'unknownContextCritical', !0), D(parserOptions, 'wrappedContextCritical', !1), D(parserOptions, 'wrappedContextRegExp', /.*/), D(parserOptions, 'strictExportPresence', !1), D(parserOptions, 'requireAsExpression', !1), D(parserOptions, 'requireAlias', !1), D(parserOptions, 'requireDynamic', !0), D(parserOptions, 'requireResolve', !0), D(parserOptions, 'commonjs', !0), D(parserOptions, 'importDynamic', !0), D(parserOptions, 'worker', [
             '...'
         ]), D(parserOptions, 'importMeta', !0), D(parserOptions, 'typeReexportsPresence', 'no-tolerant'), D(parserOptions, 'jsx', !1), D(parserOptions, 'deferImport', deferImport);
@@ -6123,7 +6214,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
             type: 'asset/bytes'
         }), rules;
     });
-}, applyOutputDefaults = (options, { context, outputModule, targetProperties: tp, isAffectedByBrowserslist, entry })=>{
+}, applyOutputDefaults = (options, { context, targetProperties: tp, isAffectedByBrowserslist, entry })=>{
     let { output } = options, getLibraryName = (library)=>{
         let libraryName = 'object' == typeof library && library && !Array.isArray(library) ? library.name : library;
         return Array.isArray(libraryName) ? libraryName.join('.') : 'object' == typeof libraryName ? getLibraryName(libraryName.root) : 'string' == typeof libraryName ? libraryName : '';
@@ -6141,7 +6232,19 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
             if ('ENOENT' !== err.code) throw err.message += `\nwhile determining default 'output.uniqueName' from 'name' in ${pkgPath}`, err;
             return '';
         }
-    }), F(output, 'devtoolNamespace', ()=>output.uniqueName), F(output, 'module', ()=>!!outputModule);
+    }), F(output, 'devtoolNamespace', ()=>output.uniqueName), output.library && F(output.library, 'type', ()=>output.module ? 'modern-module' : 'var');
+    let forEachEntry = (fn)=>{
+        if ('function' != typeof entry) for (let name of Object.keys(entry))fn(entry[name]);
+    };
+    A(output, 'enabledLibraryTypes', ()=>{
+        let enabledLibraryTypes = [];
+        return output.library && enabledLibraryTypes.push(output.library.type), forEachEntry((desc)=>{
+            desc.library && enabledLibraryTypes.push(desc.library.type);
+        }), enabledLibraryTypes.includes('modern-module') && applyLimits(options), enabledLibraryTypes;
+    }), D(output, 'module', [
+        'modern-module',
+        'module'
+    ].some((ty)=>output.enabledLibraryTypes.includes(ty)));
     let environment = output.environment, conditionallyOptimistic = (v, c)=>void 0 === v && c || v;
     F(environment, 'globalThis', ()=>tp && tp.globalThis), F(environment, 'bigIntLiteral', ()=>{
         let v;
@@ -6191,7 +6294,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         return 'function' != typeof chunkFilename ? chunkFilename.replace(/\.[mc]?js(\?|$)/, '.css$1') : '[id].css';
     }), D(output, 'hotUpdateChunkFilename', `[id].[fullhash].hot-update.${output.module ? 'mjs' : 'js'}`), F(output, 'hotUpdateMainFilename', ()=>`[runtime].[fullhash].hot-update.${output.module ? 'json.mjs' : 'json'}`);
     let uniqueNameId = Template.toIdentifier(output.uniqueName);
-    F(output, 'hotUpdateGlobal', ()=>`rspackHotUpdate${uniqueNameId}`), F(output, 'chunkLoadingGlobal', ()=>`rspackChunk${uniqueNameId}`), D(output, 'assetModuleFilename', '[hash][ext][query]'), D(output, 'webassemblyModuleFilename', '[hash].module.wasm'), D(output, 'compareBeforeEmit', !0), F(output, 'path', ()=>node_path.join(process.cwd(), 'dist')), F(output, 'pathinfo', ()=>!1), D(output, 'publicPath', tp && (tp.document || tp.importScripts) ? 'auto' : ''), D(output, 'hashFunction', 'xxhash64'), D(output, 'hashDigest', 'hex'), D(output, 'hashDigestLength', 16), D(output, 'strictModuleErrorHandling', !1), output.library && F(output.library, 'type', ()=>output.module ? 'module' : 'var'), F(output, 'chunkFormat', ()=>{
+    F(output, 'hotUpdateGlobal', ()=>`rspackHotUpdate${uniqueNameId}`), F(output, 'chunkLoadingGlobal', ()=>`rspackChunk${uniqueNameId}`), D(output, 'assetModuleFilename', '[hash][ext][query]'), D(output, 'webassemblyModuleFilename', '[hash].module.wasm'), D(output, 'compareBeforeEmit', !0), F(output, 'path', ()=>node_path.join(process.cwd(), 'dist')), F(output, 'pathinfo', ()=>!1), D(output, 'publicPath', tp && (tp.document || tp.importScripts) ? 'auto' : ''), D(output, 'hashFunction', 'xxhash64'), D(output, 'hashDigest', 'hex'), D(output, 'hashDigestLength', 16), D(output, 'strictModuleErrorHandling', !1), F(output, 'chunkFormat', ()=>{
         if (tp) {
             let helpMessage = isAffectedByBrowserslist ? "Make sure that your 'browserslist' includes only platforms that support these features or select an appropriate 'target' to allow selecting a chunk format by default. Alternatively specify the 'output.chunkFormat' directly." : "Select an appropriate 'target' to allow selecting one by default, or specify the 'output.chunkFormat' directly.";
             if (output.module) {
@@ -6253,16 +6356,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         return 'self';
     }), D(output, 'importFunctionName', 'import'), D(output, 'importMetaName', 'import.meta'), F(output, 'clean', ()=>!!output.clean), D(output, 'crossOriginLoading', !1), D(output, 'workerPublicPath', ''), D(output, 'sourceMapFilename', '[file].map[query]'), F(output, "scriptType", ()=>!!output.module && 'module'), D(output, 'chunkLoadTimeout', 120000);
     let { trustedTypes } = output;
-    trustedTypes && (F(trustedTypes, 'policyName', ()=>output.uniqueName.replace(/[^a-zA-Z0-9\-#=_/@.%]+/g, '_') || 'rspack'), D(trustedTypes, 'onPolicyCreationFailure', 'stop'));
-    let forEachEntry = (fn)=>{
-        if ('function' != typeof entry) for (let name of Object.keys(entry))fn(entry[name]);
-    };
-    A(output, 'enabledLibraryTypes', ()=>{
-        let enabledLibraryTypes = [];
-        return output.library && enabledLibraryTypes.push(output.library.type), forEachEntry((desc)=>{
-            desc.library && enabledLibraryTypes.push(desc.library.type);
-        }), enabledLibraryTypes.includes('modern-module') && applyLimits(options), enabledLibraryTypes;
-    }), A(output, 'enabledChunkLoadingTypes', ()=>{
+    trustedTypes && (F(trustedTypes, 'policyName', ()=>output.uniqueName.replace(/[^a-zA-Z0-9\-#=_/@.%]+/g, '_') || 'rspack'), D(trustedTypes, 'onPolicyCreationFailure', 'stop')), A(output, 'enabledChunkLoadingTypes', ()=>{
         let enabledChunkLoadingTypes = new Set();
         return output.chunkLoading && enabledChunkLoadingTypes.add(output.chunkLoading), output.workerChunkLoading && enabledChunkLoadingTypes.add(output.workerChunkLoading), forEachEntry((desc)=>{
             desc.chunkLoading && enabledChunkLoadingTypes.add(desc.chunkLoading);
@@ -6272,7 +6366,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         return output.wasmLoading && enabledWasmLoadingTypes.add(output.wasmLoading), output.workerWasmLoading && enabledWasmLoadingTypes.add(output.workerWasmLoading), forEachEntry((desc)=>{
             desc.wasmLoading && enabledWasmLoadingTypes.add(desc.wasmLoading);
         }), Array.from(enabledWasmLoadingTypes);
-    }), D(output, 'bundlerInfo', {}), 'object' == typeof output.bundlerInfo && (D(output.bundlerInfo, 'version', "2.0.0-alpha.0"), D(output.bundlerInfo, 'bundler', 'rspack'), D(output.bundlerInfo, 'force', !output.library));
+    }), D(output, 'bundlerInfo', {}), 'object' == typeof output.bundlerInfo && (D(output.bundlerInfo, 'version', "2.0.0-beta.0"), D(output.bundlerInfo, 'bundler', 'rspack'), D(output.bundlerInfo, 'force', !output.library));
 }, applyExternalsPresetsDefaults = (externalsPresets, { targetProperties, buildHttp, outputModule })=>{
     let isUniversal = (key)=>!!(outputModule && targetProperties && null === targetProperties[key]);
     D(externalsPresets, 'web', !buildHttp && targetProperties && (targetProperties.web || isUniversal('node'))), D(externalsPresets, 'node', targetProperties && (targetProperties.node || isUniversal('node'))), D(externalsPresets, 'electron', targetProperties && targetProperties.electron || isUniversal('electron')), D(externalsPresets, 'electronMain', targetProperties && !!targetProperties.electron && (targetProperties.electronMain || isUniversal('electronMain'))), D(externalsPresets, 'electronPreload', targetProperties && !!targetProperties.electron && (targetProperties.electronPreload || isUniversal('electronPreload'))), D(externalsPresets, 'electronRenderer', targetProperties && !!targetProperties.electron && (targetProperties.electronRenderer || isUniversal('electronRenderer'))), D(externalsPresets, 'nwjs', targetProperties && (targetProperties.nwjs || isUniversal('nwjs')));
@@ -6553,8 +6647,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                     ]),
                 rules: nestedArray(module.rules, (r)=>[
                         ...r
-                    ]),
-                unsafeCache: module.unsafeCache
+                    ])
             })),
         target: config.target,
         externals: config.externals,
@@ -6590,7 +6683,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                 storage: {
                     type: 'filesystem',
                     directory: node_path.resolve(config.context || process.cwd(), cache.storage?.directory || 'node_modules/.cache/rspack')
-                }
+                },
+                portable: cache.portable
             };
         }),
         stats: nestedConfig(config.stats, (stats)=>!1 === stats ? {
@@ -6687,12 +6781,10 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
     }
 }, getNormalizedIncrementalOptions = (incremental)=>!1 !== incremental && 'none' !== incremental && ('safe' === incremental ? {
         silent: !0,
-        make: !0,
-        inferAsyncModules: !1,
-        providedExports: !1,
-        dependenciesDiagnostics: !1,
-        sideEffects: !1,
-        buildChunkGraph: !1,
+        buildModuleGraph: !0,
+        finishModules: !1,
+        optimizeDependencies: !1,
+        buildChunkGraph: !0,
         moduleIds: !1,
         chunkIds: !1,
         modulesHashes: !1,
@@ -6700,7 +6792,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         modulesRuntimeRequirements: !1,
         chunksRuntimeRequirements: !1,
         chunksHashes: !1,
-        chunksRender: !1,
+        chunkAsset: !1,
         emitAssets: !0
     } : !0 === incremental || 'advance-silent' === incremental ? {} : 'advance' === incremental ? {
         silent: !1
@@ -7526,7 +7618,7 @@ class MultiStats {
         obj.children = this.stats.map((stat, idx)=>{
             let obj = stat.toJson(childOptions.children[idx]), compilationName = stat.compilation.name;
             return obj.name = compilationName && makePathsRelative(childOptions.context, compilationName, stat.compilation.compiler.root), obj;
-        }), childOptions.version && (obj.rspackVersion = "2.0.0-alpha.0", obj.version = "5.75.0"), childOptions.hash && (obj.hash = obj.children.map((j)=>j.hash).join(''));
+        }), childOptions.version && (obj.rspackVersion = "2.0.0-beta.0", obj.version = "5.75.0"), childOptions.hash && (obj.hash = obj.children.map((j)=>j.hash).join(''));
         let mapError = (j, obj)=>({
                 ...obj,
                 compilerPath: obj.compilerPath ? `${j.name}.${obj.compilerPath}` : j.name
@@ -8682,15 +8774,21 @@ let iterateConfig = (config, options, fn)=>{
             if (context.makePathsRelative || (context.makePathsRelative = makePathsRelative.bindContextCache(compilation.compiler.context, compilation.compiler.root)), !context.cachedGetErrors) {
                 let map = new WeakMap();
                 context.cachedGetErrors = (compilation)=>{
-                    var errors;
-                    return map.get(compilation) || (errors = statsCompilation.errors, map.set(compilation, errors), errors);
+                    if (compilation.compiler._lastCompilation !== compilation) return [];
+                    let cache = map.get(compilation);
+                    if (cache) return cache;
+                    let errors = statsCompilation.errors;
+                    return map.set(compilation, errors), errors;
                 };
             }
             if (!context.cachedGetWarnings) {
                 let map = new WeakMap();
                 context.cachedGetWarnings = (compilation)=>{
-                    var warnings;
-                    return map.get(compilation) || (warnings = compilation.__internal_getInner().createStatsWarnings(compilation.getWarnings(), !!options.colors), map.set(compilation, warnings), warnings);
+                    if (compilation.compiler._lastCompilation !== compilation) return [];
+                    let cache = map.get(compilation);
+                    if (cache) return cache;
+                    let warnings = compilation.__internal_getInner().createStatsWarnings(compilation.getWarnings(), !!options.colors);
+                    return map.set(compilation, warnings), warnings;
                 };
             }
             compilation.name && (object.name = compilation.name);
@@ -8779,7 +8877,7 @@ let iterateConfig = (config, options, fn)=>{
             object.hash = context.getStatsCompilation(compilation).hash;
         },
         version: (object)=>{
-            object.version = "5.75.0", object.rspackVersion = "2.0.0-alpha.0";
+            object.version = "5.75.0", object.rspackVersion = "2.0.0-beta.0";
         },
         env: (object, _compilation, _context, { _env })=>{
             object.env = _env;
@@ -10440,7 +10538,7 @@ class TraceHookPlugin {
         });
     }
 }
-let CORE_VERSION = "2.0.0-alpha.0", VFILES_BY_COMPILER = new WeakMap();
+let CORE_VERSION = "2.0.0-beta.0", VFILES_BY_COMPILER = new WeakMap();
 class VirtualModulesPlugin {
     #staticModules;
     #compiler;
@@ -10585,22 +10683,23 @@ class Watching {
         let startTime = this.startTime;
         this.startTime = void 0, compilation.startTime = startTime, compilation.endTime = Date.now();
         let cbs = this.callbacks;
-        this.callbacks = [];
-        let fileDependencies = new Set([
-            ...compilation.fileDependencies
-        ]);
-        fileDependencies.added = new Set(compilation.__internal__addedFileDependencies), fileDependencies.removed = new Set(compilation.__internal__removedFileDependencies);
-        let contextDependencies = new Set([
-            ...compilation.contextDependencies
-        ]);
-        contextDependencies.added = new Set(compilation.__internal__addedContextDependencies), contextDependencies.removed = new Set(compilation.__internal__removedContextDependencies);
-        let missingDependencies = new Set([
-            ...compilation.missingDependencies
-        ]);
-        missingDependencies.added = new Set(compilation.__internal__addedMissingDependencies), missingDependencies.removed = new Set(compilation.__internal__removedMissingDependencies), this.compiler.hooks.done.callAsync(stats, (err)=>{
+        this.callbacks = [], this.compiler.hooks.done.callAsync(stats, (err)=>{
             if (err) return handleError(err, cbs);
             for (let cb of (this.handler(null, stats), process.nextTick(()=>{
-                this.#closed || this.watch(fileDependencies, contextDependencies, missingDependencies);
+                if (!this.#closed) {
+                    let fileDependencies = new Set([
+                        ...compilation.fileDependencies
+                    ]);
+                    fileDependencies.added = new Set(compilation.__internal__addedFileDependencies), fileDependencies.removed = new Set(compilation.__internal__removedFileDependencies);
+                    let contextDependencies = new Set([
+                        ...compilation.contextDependencies
+                    ]);
+                    contextDependencies.added = new Set(compilation.__internal__addedContextDependencies), contextDependencies.removed = new Set(compilation.__internal__removedContextDependencies);
+                    let missingDependencies = new Set([
+                        ...compilation.missingDependencies
+                    ]);
+                    missingDependencies.added = new Set(compilation.__internal__addedMissingDependencies), missingDependencies.removed = new Set(compilation.__internal__removedMissingDependencies), this.watch(fileDependencies, contextDependencies, missingDependencies);
+                }
             }), cbs))cb(null);
             this.compiler.hooks.afterDone.call(stats);
         });
@@ -10620,7 +10719,7 @@ class Watching {
         this.suspended && (this.suspended = !1, this.#invalidate());
     }
 }
-let Compiler_require = createRequire(import.meta.url);
+let Compiler_require = createRequire(import.meta.url), GET_COMPILER_ID = Symbol('getCompilerId');
 class Compiler {
     #instance;
     #initial;
@@ -10751,6 +10850,17 @@ class Compiler {
             ]),
             additionalPass: new AsyncSeriesHook([])
         };
+        let availableCompilerHooks = Object.keys(this.hooks);
+        this.hooks = new Proxy(this.hooks, {
+            get (target, prop, receiver) {
+                let value = Reflect.get(target, prop, receiver);
+                if (void 0 === value && 'string' == typeof prop) {
+                    let hooksList = availableCompilerHooks.join(', ');
+                    throw Error(`Compiler.hooks.${prop} is not supported in rspack. This typically happens when using webpack plugins that rely on webpack-specific hooks. Consider using an rspack-compatible alternative or removing the incompatible plugin.\n\nAvailable compiler hooks: ${hooksList}`);
+                }
+                return value;
+            }
+        });
         let compilerRspack = Object.assign(function(...params) {
             return rspack(...params);
         }, exports_namespaceObject, {
@@ -10765,7 +10875,12 @@ class Compiler {
             electron: null
         }, this.#target = {}, this.__internal_browser_require = ()=>{
             throw Error('Cannot execute user defined code in browser without `BrowserRequirePlugin`');
-        }, this.resolverFactory = new ResolverFactory(options.resolve.pnp ?? getPnpDefault(), options.resolve, options.resolveLoader), new JsLoaderRspackPlugin(this).apply(this), new ExecuteModulePlugin().apply(this), new TraceHookPlugin().apply(this);
+        }, this.resolverFactory = new ResolverFactory(options.resolve.pnp ?? getPnpDefault(), options.resolve, options.resolveLoader), new JsLoaderRspackPlugin(this).apply(this), new ExecuteModulePlugin().apply(this), new TraceHookPlugin().apply(this), Object.defineProperty(this, GET_COMPILER_ID, {
+            writable: !1,
+            configurable: !1,
+            enumerable: !1,
+            value: ()=>this.#instance.getCompilerId()
+        });
     }
     get recordsInputPath() {
         return unsupported('Compiler.recordsInputPath');
@@ -11026,8 +11141,7 @@ Help:
                             k,
                             getRawGeneratorOptions(v, k)
                         ]).filter(([_, v])=>void 0 !== v)),
-                    noParse: module.noParse,
-                    unsafeCache: module.unsafeCache
+                    noParse: module.noParse
                 };
             }(options.module, {
                 compiler: this,
@@ -12229,7 +12343,7 @@ async function transform(source, options) {
     let _options = JSON.stringify(options || {});
     return binding_default().transform(source, _options);
 }
-let exports_rspackVersion = "2.0.0-alpha.0", exports_version = "5.75.0", exports_WebpackError = Error, exports_config = {
+let exports_rspackVersion = "2.0.0-beta.0", exports_version = "5.75.0", exports_WebpackError = Error, exports_config = {
     getNormalizedRspackOptions: getNormalizedRspackOptions,
     applyRspackOptionsDefaults: applyRspackOptionsDefaults,
     getNormalizedWebpackOptions: getNormalizedRspackOptions,
@@ -12488,12 +12602,36 @@ let exports_rspackVersion = "2.0.0-alpha.0", exports_version = "5.75.0", exports
         if (INTERNAL_PLUGIN_NAMES.includes(name)) throw Error(`Cannot register native plugin with name '${name}', it conflicts with internal plugin names.`);
         return base_create(name, resolve, affectedHooks);
     },
-    VirtualModulesPlugin: VirtualModulesPlugin
+    VirtualModulesPlugin: VirtualModulesPlugin,
+    rsc: {
+        createPlugins: ()=>{
+            let coordinator = new Coordinator();
+            return {
+                ServerPlugin: class extends RscServerPlugin {
+                    constructor(options = {}){
+                        super({
+                            coordinator,
+                            ...options
+                        });
+                    }
+                },
+                ClientPlugin: class extends RscClientPlugin {
+                    constructor(){
+                        super({
+                            coordinator
+                        });
+                    }
+                }
+            };
+        },
+        Layers: {
+            rsc: 'react-server-components',
+            ssr: 'server-side-rendering'
+        }
+    }
 }, src_fn = Object.assign(rspack, exports_namespaceObject);
 src_fn.rspack = src_fn, src_fn.webpack = src_fn;
 let src_rspack_0 = src_fn;
 var AsyncDependenciesBlock = binding_namespaceObject.AsyncDependenciesBlock, ConcatenatedModule = binding_namespaceObject.ConcatenatedModule, ContextModule = binding_namespaceObject.ContextModule, Dependency = binding_namespaceObject.Dependency, EntryDependency = binding_namespaceObject.EntryDependency, ExternalModule = binding_namespaceObject.ExternalModule, Module = binding_namespaceObject.Module, NormalModule = binding_namespaceObject.NormalModule;
 export default src_rspack_0;
-export { AsyncDependenciesBlock, BannerPlugin, CaseSensitivePlugin, CircularDependencyRspackPlugin, Compilation, Compiler, ConcatenatedModule, ContextModule, ContextReplacementPlugin, CopyRspackPlugin, CssExtractRspackPlugin, DefaultRuntimeGlobals as RuntimeGlobals, DefinePlugin, Dependency, DllPlugin, DllReferencePlugin, DynamicEntryPlugin, EntryDependency, EntryPlugin, EnvironmentPlugin, EvalDevToolModulePlugin, EvalSourceMapDevToolPlugin, ExternalModule, ExternalsPlugin, HotModuleReplacementPlugin, HtmlRspackPlugin, IgnorePlugin, LightningCssMinimizerRspackPlugin, LoaderOptionsPlugin, LoaderTargetPlugin, Module, ModuleFilenameHelpers_namespaceObject as ModuleFilenameHelpers, MultiCompiler, MultiStats, NoEmitOnErrorsPlugin, NormalModule, NormalModuleReplacementPlugin, ProgressPlugin, ProvidePlugin, RspackOptionsApply, RspackOptionsApply as WebpackOptionsApply, RuntimeModule, RuntimePlugin, SourceMapDevToolPlugin, Stats, SubresourceIntegrityPlugin, SwcJsMinimizerRspackPlugin, Template, ValidationError, container, electron, exports_WebpackError as WebpackError, exports_config as config, exports_experiments as experiments, exports_library as library, exports_node as node, exports_rspackVersion as rspackVersion, exports_version as version, exports_wasm as wasm, index_js_namespaceObject as sources, javascript, lazyCompilationMiddleware, lib_EntryOptionPlugin as EntryOptionPlugin, optimize, sharing, src_rspack_0 as rspack, statsFactoryUtils_StatsErrorCode as StatsErrorCode, util, web, webworker };
-
-export { src_rspack_0 as 'module.exports' }
+export { AsyncDependenciesBlock, BannerPlugin, CaseSensitivePlugin, CircularDependencyRspackPlugin, Compilation, Compiler, ConcatenatedModule, ContextModule, ContextReplacementPlugin, CopyRspackPlugin, CssExtractRspackPlugin, DefaultRuntimeGlobals as RuntimeGlobals, DefinePlugin, Dependency, DllPlugin, DllReferencePlugin, DynamicEntryPlugin, EntryDependency, EntryPlugin, EnvironmentPlugin, EvalDevToolModulePlugin, EvalSourceMapDevToolPlugin, ExternalModule, ExternalsPlugin, HotModuleReplacementPlugin, HtmlRspackPlugin, IgnorePlugin, LightningCssMinimizerRspackPlugin, LoaderOptionsPlugin, LoaderTargetPlugin, Module, ModuleFilenameHelpers_namespaceObject as ModuleFilenameHelpers, MultiCompiler, MultiStats, NoEmitOnErrorsPlugin, NormalModule, NormalModuleReplacementPlugin, ProgressPlugin, ProvidePlugin, RspackOptionsApply, RspackOptionsApply as WebpackOptionsApply, RuntimeModule, RuntimePlugin, SourceMapDevToolPlugin, Stats, SubresourceIntegrityPlugin, SwcJsMinimizerRspackPlugin, Template, ValidationError, container, electron, exports_WebpackError as WebpackError, exports_config as config, exports_experiments as experiments, exports_library as library, exports_node as node, exports_rspackVersion as rspackVersion, exports_version as version, exports_wasm as wasm, index_js_namespaceObject as sources, javascript, lazyCompilationMiddleware, lib_EntryOptionPlugin as EntryOptionPlugin, optimize, sharing, src_rspack_0 as "module.exports", src_rspack_0 as rspack, statsFactoryUtils_StatsErrorCode as StatsErrorCode, util, web, webworker };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack-debug/core",
-  "version": "2.0.0-alpha.0",
+  "version": "2.0.0-beta.0",
   "webpackVersion": "5.75.0",
   "license": "MIT",
   "description": "The fast Rust-based web bundler with webpack-compatible API",
@@ -39,17 +39,17 @@
   "devDependencies": {
     "@ast-grep/napi": "^0.40.5",
     "@napi-rs/wasm-runtime": "1.0.7",
-    "@rsbuild/plugin-node-polyfill": "^1.4.2",
-    "@rslib/core": "0.19.2",
+    "@rsbuild/plugin-node-polyfill": "^1.4.3",
+    "@rslib/core": "0.19.3",
     "@swc/types": "0.1.25",
-    "@types/node": "^20.19.29",
+    "@types/node": "^20.19.30",
     "@types/watchpack": "^2.4.5",
     "browserslist-load-config": "^1.0.1",
     "browserslist-to-es-version": "^1.4.1",
     "enhanced-resolve": "5.18.4",
     "glob-to-regexp": "^0.4.1",
     "memfs": "4.53.0",
-    "prebundle": "^1.6.0",
+    "prebundle": "^1.6.2",
     "tinypool": "^1.1.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
@@ -58,7 +58,7 @@
   },
   "dependencies": {
     "@rspack/lite-tapable": "1.1.0",
-    "@rspack/binding": "npm:@rspack-debug/binding@2.0.0-alpha.0"
+    "@rspack/binding": "npm:@rspack-debug/binding@2.0.0-beta.0"
   },
   "peerDependencies": {
     "@module-federation/runtime-tools": ">=0.22.0",