@rspack/core 1.3.10 → 1.3.11

package/dist/Compilation.d.ts

@@ -27,7 +27,7 @@ import { type RspackError } from "./RspackError";
 import { RuntimeModule } from "./RuntimeModule";
 import { Stats, type StatsAsset, type StatsError, type StatsModule } from "./Stats";
 import type { EntryOptions, EntryPlugin } from "./builtin-plugin";
-import type { Filename, OutputNormalized, RspackOptionsNormalized, RspackPluginInstance, StatsOptions, StatsValue } from "./config";
+import type { OutputNormalized, RspackOptionsNormalized, RspackPluginInstance, StatsOptions, StatsValue } from "./config";
 import WebpackError from "./lib/WebpackError";
 import { Logger } from "./logging/Logger";
 import { StatsFactory } from "./stats/StatsFactory";
@@ -284,10 +284,10 @@ export declare class Compilation {
     set errors(errors: RspackError[]);
     get warnings(): RspackError[];
     set warnings(warnings: RspackError[]);
-    getPath(filename: Filename, data?: PathData): string;
-    getPathWithInfo(filename: Filename, data?: PathData): binding.PathWithInfo;
-    getAssetPath(filename: Filename, data?: PathData): string;
-    getAssetPathWithInfo(filename: Filename, data?: PathData): binding.PathWithInfo;
+    getPath(filename: string, data?: PathData): string;
+    getPathWithInfo(filename: string, data?: PathData): binding.PathWithInfo;
+    getAssetPath(filename: string, data?: PathData): string;
+    getAssetPathWithInfo(filename: string, data?: PathData): binding.PathWithInfo;
     getLogger(name: string | (() => string)): Logger;
     fileDependencies: {
         [Symbol.iterator](): Generator<string, void, unknown>;

package/dist/Diagnostics.d.ts

@@ -0,0 +1,7 @@
+import type { Diagnostics } from "@rspack/binding";
+import type { RspackError } from "./RspackError";
+declare const $proxy: unique symbol;
+export declare function createDiagnosticArray(adm: Diagnostics & {
+    [$proxy]?: RspackError[];
+}): RspackError[];
+export {};

package/dist/Module.d.ts

@@ -42,6 +42,15 @@ export declare class ContextModuleFactoryAfterResolveData {
     private constructor();
 }
 export type ContextModuleFactoryAfterResolveResult = false | ContextModuleFactoryAfterResolveData;
+declare const $assets: unique symbol;
+declare module "@rspack/binding" {
+    interface Assets {
+        [$assets]: Record<string, Source>;
+    }
+    interface BuildInfo {
+        assets: Record<string, Source>;
+    }
+}
 declare module "@rspack/binding" {
     interface Module {
         identifier(): string;

package/dist/RspackError.d.ts

@@ -7,3 +7,6 @@ export declare class JsRspackDiagnostic {
 export declare class NonErrorEmittedError extends Error {
     constructor(error: Error);
 }
+export declare class DeadlockRiskError extends Error {
+    constructor(message: string);
+}

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

@@ -0,0 +1,19 @@
+import * as binding from "@rspack/binding";
+export interface CssChunkingPluginOptions {
+    strict?: boolean;
+    /**
+     * This plugin is intended to be generic, but currently requires some special handling for Next.js.
+     * A `next` option has been added to accommodate this.
+     * In the future, once the design of CssChunkingPlugin becomes more stable, this option may be removed.
+     */
+    nextjs?: boolean;
+}
+export declare const CssChunkingPlugin: {
+    new (options: CssChunkingPluginOptions): {
+        name: binding.BuiltinPluginName;
+        _args: [options: CssChunkingPluginOptions];
+        affectedHooks: "done" | "make" | "compile" | "emit" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "compilation" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "environment" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | "additionalPass" | undefined;
+        raw(compiler: import("..").Compiler): binding.BuiltinPlugin;
+        apply(compiler: import("..").Compiler): void;
+    };
+};

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

@@ -10,7 +10,7 @@ export declare const DefinePlugin: {
     };
 };
 type CodeValue = RecursiveArrayOrRecord<CodeValuePrimitive>;
-type CodeValuePrimitive = null | undefined | RegExp | Function | string | number | boolean | bigint | undefined;
+type CodeValuePrimitive = null | undefined | RegExp | Function | string | number | boolean | bigint;
 type RecursiveArrayOrRecord<T> = {
     [index: string]: RecursiveArrayOrRecord<T>;
 } | Array<RecursiveArrayOrRecord<T>> | T;

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

@@ -1,8 +1,8 @@
-import { BuiltinPluginName, type RawSourceMapDevToolPluginOptions } from "@rspack/binding";
+import { BuiltinPluginName, type SourceMapDevToolPluginOptions } from "@rspack/binding";
 export declare const EvalSourceMapDevToolPlugin: {
-    new (options: RawSourceMapDevToolPluginOptions): {
+    new (options: SourceMapDevToolPluginOptions): {
         name: BuiltinPluginName;
-        _args: [options: RawSourceMapDevToolPluginOptions];
+        _args: [options: SourceMapDevToolPluginOptions];
         affectedHooks: "done" | "make" | "compile" | "emit" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "compilation" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "environment" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | "additionalPass" | undefined;
         raw(compiler: import("..").Compiler): import("@rspack/binding").BuiltinPlugin;
         apply(compiler: import("..").Compiler): void;

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

@@ -1,9 +1,9 @@
-import { BuiltinPluginName, type RawSourceMapDevToolPluginOptions } from "@rspack/binding";
-export type { RawSourceMapDevToolPluginOptions as SourceMapDevToolPluginOptions };
+import { BuiltinPluginName, type SourceMapDevToolPluginOptions } from "@rspack/binding";
+export type { SourceMapDevToolPluginOptions };
 export declare const SourceMapDevToolPlugin: {
-    new (options: RawSourceMapDevToolPluginOptions): {
+    new (options: SourceMapDevToolPluginOptions): {
         name: BuiltinPluginName;
-        _args: [options: RawSourceMapDevToolPluginOptions];
+        _args: [options: SourceMapDevToolPluginOptions];
         affectedHooks: "done" | "make" | "compile" | "emit" | "afterEmit" | "invalid" | "thisCompilation" | "afterDone" | "compilation" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "environment" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | "additionalPass" | undefined;
         raw(compiler: import("..").Compiler): import("@rspack/binding").BuiltinPlugin;
         apply(compiler: import("..").Compiler): void;

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

@@ -75,3 +75,4 @@ export * from "./DllReferenceAgencyPlugin";
 export * from "./RsdoctorPlugin";
 export * from "./SubresourceIntegrityPlugin";
 export * from "./ModuleInfoHeaderPlugin";
+export * from "./CssChunkingPlugin";

package/dist/config/zod.d.ts

@@ -1014,9 +1014,9 @@ export declare const rspackOptions: z.ZodObject<{
                 body: Buffer<ArrayBufferLike>;
                 headers: Record<string, string>;
             }>) | undefined;
+            upgrade?: boolean | undefined;
             lockfileLocation?: string | undefined;
             cacheLocation?: string | false | undefined;
-            upgrade?: boolean | undefined;
         }, {
             allowedUris: (string | RegExp)[];
             httpClient?: ((args_0: string, args_1: Record<string, string>, ...args: unknown[]) => Promise<{
@@ -1024,9 +1024,9 @@ export declare const rspackOptions: z.ZodObject<{
                 body: Buffer<ArrayBufferLike>;
                 headers: Record<string, string>;
             }>) | undefined;
+            upgrade?: boolean | undefined;
             lockfileLocation?: string | undefined;
             cacheLocation?: string | false | undefined;
-            upgrade?: boolean | undefined;
         }>>;
         parallelLoader: z.ZodOptional<z.ZodBoolean>;
     }, "strict", z.ZodTypeAny, {
@@ -1092,9 +1092,9 @@ export declare const rspackOptions: z.ZodObject<{
                 body: Buffer<ArrayBufferLike>;
                 headers: Record<string, string>;
             }>) | undefined;
+            upgrade?: boolean | undefined;
             lockfileLocation?: string | undefined;
             cacheLocation?: string | false | undefined;
-            upgrade?: boolean | undefined;
         } | undefined;
         parallelLoader?: boolean | undefined;
     }, {
@@ -1160,9 +1160,9 @@ export declare const rspackOptions: z.ZodObject<{
                 body: Buffer<ArrayBufferLike>;
                 headers: Record<string, string>;
             }>) | undefined;
+            upgrade?: boolean | undefined;
             lockfileLocation?: string | undefined;
             cacheLocation?: string | false | undefined;
-            upgrade?: boolean | undefined;
         } | undefined;
         parallelLoader?: boolean | undefined;
     }>>;
@@ -3487,9 +3487,9 @@ export declare const rspackOptions: z.ZodObject<{
                 body: Buffer<ArrayBufferLike>;
                 headers: Record<string, string>;
             }>) | undefined;
+            upgrade?: boolean | undefined;
             lockfileLocation?: string | undefined;
             cacheLocation?: string | false | undefined;
-            upgrade?: boolean | undefined;
         } | undefined;
         parallelLoader?: boolean | undefined;
     } | undefined;
@@ -4109,9 +4109,9 @@ export declare const rspackOptions: z.ZodObject<{
                 body: Buffer<ArrayBufferLike>;
                 headers: Record<string, string>;
             }>) | undefined;
+            upgrade?: boolean | undefined;
             lockfileLocation?: string | undefined;
             cacheLocation?: string | false | undefined;
-            upgrade?: boolean | undefined;
         } | undefined;
         parallelLoader?: boolean | undefined;
     } | undefined;

package/dist/exports.d.ts

@@ -116,6 +116,7 @@ import { RuntimeChunkPlugin } from "./builtin-plugin";
 import { SplitChunksPlugin } from "./builtin-plugin";
 import { RemoveDuplicateModulesPlugin } from "./builtin-plugin";
 import { RsdoctorPlugin } from "./builtin-plugin";
+import { CssChunkingPlugin } from "./builtin-plugin";
 interface Optimize {
     LimitChunkCountPlugin: typeof LimitChunkCountPlugin;
     RuntimeChunkPlugin: typeof RuntimeChunkPlugin;
@@ -183,5 +184,6 @@ interface Experiments {
         transform: typeof transform;
         minify: typeof minify;
     };
+    CssChunkingPlugin: typeof CssChunkingPlugin;
 }
 export declare const experiments: Experiments;

package/dist/index.js

@@ -225,6 +225,12 @@ var __webpack_modules__ = {
     "node:child_process": function(module) {
         module.exports = require("node:child_process");
     },
+    "node:http": function(module) {
+        module.exports = require("node:http");
+    },
+    "node:https": function(module) {
+        module.exports = require("node:https");
+    },
     "node:os": function(module) {
         module.exports = require("node:os");
     },
@@ -765,6 +771,11 @@ for(var __webpack_i__ in (()=>{
             super(), this.name = "NonErrorEmittedError", this.message = `(Emitted value instead of an instance of Error) ${error}`;
         }
     }
+    class DeadlockRiskError extends Error {
+        constructor(message){
+            super(message), this.name = "DeadlockRiskError", this.stack = "";
+        }
+    }
     class RuntimeModule {
         static STAGE_NORMAL = 0;
         static STAGE_BASIC = 5;
@@ -863,6 +874,7 @@ for(var __webpack_i__ in (()=>{
                     getInner: this.#getInnerByCompilation.bind(this)
                 });
             } catch (e) {
+                if (e instanceof DeadlockRiskError) throw e;
                 console.warn(`Failed to get stats due to error: ${e?.message}, are you trying to access the stats from the previous compilation?`);
             }
             return stats;
@@ -882,6 +894,7 @@ for(var __webpack_i__ in (()=>{
                     getInner: this.#getInnerByCompilation.bind(this)
                 });
             } catch (e) {
+                if (e instanceof DeadlockRiskError) throw e;
                 console.warn(`Failed to get stats due to error: ${e?.message}, are you trying to access the stats from the previous compilation?`);
             }
             if (!stats) return "";
@@ -1536,13 +1549,15 @@ for(var __webpack_i__ in (()=>{
             return originalSource ? JsSource.__from_binding(originalSource) : null;
         }
     });
-    let checkCompilation = (compilation)=>{
+    let $proxy = Symbol.for("proxy"), checkCompilation = (compilation)=>{
         if (!(compilation instanceof Compilation)) throw TypeError('The \'compilation\' argument must be an instance of Compilation. This usually occurs when multiple versions of "@rspack/core" are used, or when the code in "@rspack/core" is executed multiple times.');
     };
     Compilation_computedKey = binding_.COMPILATION_HOOKS_MAP_SYMBOL;
     class Compilation {
         #inner;
         #shutdown;
+        #errors;
+        #chunks;
         hooks;
         name;
         startTime;
@@ -1725,7 +1740,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             return new Set(this.#inner.builtModules);
         }
         get chunks() {
-            return this.#inner.chunks;
+            return this.#chunks || (this.#chunks = this.#inner.chunks), this.#chunks;
         }
         get namedChunks() {
             return createReadonlyMap({
@@ -1828,51 +1843,55 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             this.#inner.pushNativeDiagnostics(diagnostics);
         }
         get errors() {
-            let inner = this.#inner, errors = inner.getErrors();
-            for (let item of [
-                {
-                    method: "push",
-                    handler (target, thisArg, errs) {
-                        for(let i = 0; i < errs.length; i++){
-                            let error = errs[i];
-                            inner.pushDiagnostic(JsRspackDiagnostic.__to_binding(error, binding_.JsRspackSeverity.Error));
-                        }
-                        return Reflect.apply(target, thisArg, errs);
-                    }
-                },
-                {
-                    method: "pop",
-                    handler: (target, thisArg)=>(inner.spliceDiagnostic(errors.length - 1, errors.length, []), Reflect.apply(target, thisArg, []))
-                },
-                {
-                    method: "shift",
-                    handler: (target, thisArg)=>(inner.spliceDiagnostic(0, 1, []), Reflect.apply(target, thisArg, []))
-                },
-                {
-                    method: "unshift",
-                    handler (target, thisArg, errs) {
-                        let errList = errs.map((error)=>JsRspackDiagnostic.__to_binding(error, binding_.JsRspackSeverity.Error));
-                        return inner.spliceDiagnostic(0, 0, errList), Reflect.apply(target, thisArg, errs);
+            return this.#errors || (this.#errors = function(adm) {
+                if ($proxy in adm) return adm[$proxy];
+                let array = [];
+                array[external_node_util_default().inspect.custom] = ()=>adm.values();
+                let splice = function(index, deleteCount, ...newItems) {
+                    switch(arguments.length){
+                        case 0:
+                            return [];
+                        case 1:
+                            return adm.spliceWithArray(index, adm.length);
+                        case 2:
+                            return adm.spliceWithArray(index, deleteCount);
                     }
-                },
-                {
-                    method: "splice",
-                    handler (target, thisArg, [startIdx, delCount, ...errors]) {
-                        let errList = errors.map((error)=>JsRspackDiagnostic.__to_binding(error, binding_.JsRspackSeverity.Error));
-                        return inner.spliceDiagnostic(startIdx, startIdx + delCount, errList), Reflect.apply(target, thisArg, [
-                            startIdx,
-                            delCount,
-                            ...errors
-                        ]);
+                    return adm.spliceWithArray(index, deleteCount, newItems.map((item)=>concatErrorMsgAndStack(item)));
+                }, arrayExtensions = {
+                    [Symbol.iterator]: ()=>adm.values().values(),
+                    splice,
+                    push: (...newItems)=>(adm.spliceWithArray(adm.length, 0, newItems.map((item)=>concatErrorMsgAndStack(item))), adm.length),
+                    pop: ()=>splice(Math.max(adm.length - 1, 0), 1)[0],
+                    shift: ()=>splice(0, 1)[0],
+                    unshift: (...newItems)=>(adm.spliceWithArray(0, 0, newItems.map((item)=>concatErrorMsgAndStack(item))), adm.length),
+                    reverse: ()=>adm.values().reverse(),
+                    sort (compareFn) {
+                        let copy = adm.values();
+                        return copy.sort(compareFn), adm.spliceWithArray(0, adm.length, copy), this;
+                    },
+                    at: (index)=>adm.get(index),
+                    concat: (...items)=>([].includes, adm.values().concat(...items)),
+                    flat: ()=>adm.values(),
+                    every: (predicate, thisArg)=>adm.values().every(predicate, thisArg),
+                    filter: (predicate, thisArg)=>adm.values().filter(predicate, thisArg),
+                    find: (predicate, thisArg)=>adm.values().find(predicate, thisArg),
+                    findIndex: (predicate, thisArg)=>adm.values().findIndex(predicate, thisArg),
+                    flatMap: (callbackfn, thisArg)=>adm.values().flatMap(callbackfn, thisArg),
+                    forEach (callbackfn, thisArg) {
+                        adm.values().forEach(callbackfn, thisArg);
+                    },
+                    map: (callbackfn, thisArg)=>adm.values().map(callbackfn, thisArg),
+                    reduce: (callbackfn, initialValue)=>adm.values().reduce(callbackfn, initialValue),
+                    reduceRight: (callbackfn, initialValue)=>adm.values().reduceRight(callbackfn, initialValue)
+                }, proxy = new Proxy(array, {
+                    get: (target, name)=>"length" === name ? adm.length : "string" != typeof name || Number.isNaN(Number.parseInt(name)) ? Object.prototype.hasOwnProperty.call(arrayExtensions, name) ? arrayExtensions[name] : target[name] : adm.get(Number.parseInt(name)),
+                    set (target, name, value) {
+                        if ("length" === name) throw Error("The 'length' property is read-only and cannot be assigned a new value.");
+                        return "symbol" == typeof name || Number.isNaN(Number.parseInt(name)) ? target[name] = value : adm.set(Number.parseInt(name), concatErrorMsgAndStack(value)), !0;
                     }
-                }
-            ]){
-                let proxiedMethod = new Proxy(errors[item.method], {
-                    apply: item.handler
                 });
-                errors[item.method] = proxiedMethod;
-            }
-            return errors;
+                return adm[$proxy] = proxy, proxy;
+            }(this.#inner.errors)), this.#errors;
         }
         set errors(errors) {
             let inner = this.#inner, length = inner.getErrors().length;
@@ -3091,6 +3110,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
         static layer;
         static output;
         static session;
+        static counter = 100;
         static async initJavaScriptTrace(layer, output) {
             let { Session } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "node:inspector"));
             this.session = new Session(), this.layer = layer, this.output = output, this.events = [];
@@ -3767,7 +3787,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
             else {
                 var args1, raw;
                 loaderState === binding_.JsLoaderState.Normal && (args1 = args, !(raw = !!currentLoaderObject?.raw) && args1[0] instanceof Uint8Array ? args1[0] = function(buf) {
-                    let str = decoder.decode(buf);
+                    let str = decoder.decode(buf.buffer instanceof SharedArrayBuffer ? Buffer.from(buf) : buf);
                     return 0xfeff === str.charCodeAt(0) ? str.slice(1) : str;
                 }(args1[0]) : raw && "string" == typeof args1[0] && (args1[0] = Buffer.from(args1[0], "utf-8")), raw && args1[0] instanceof Uint8Array && !Buffer.isBuffer(args1[0]) && (args1[0] = Buffer.from(args1[0].buffer))), result = await utils_runSyncOrAsync(fn, loaderContext, args) || [];
             }
@@ -3822,7 +3842,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
                                 additionalData
                             ], context.resourceData));
                         }
-                        context.content = isNil(content) ? null : toBuffer(content), context.sourceMap = JsSourceMap.__to_binding(sourceMap), context.additionalData = additionalData || void 0;
+                        context.content = isNil(content) ? null : toBuffer(content), context.sourceMap = JsSourceMap.__to_binding(sourceMap), context.additionalData = additionalData || void 0, context.__internal__utf8Hint = "string" == typeof content;
                         break;
                     }
                 default:
@@ -4449,9 +4469,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
         let ret = {
             patterns: []
         };
-        return ret.patterns = (copy.patterns || []).map((pattern)=>("string" == typeof pattern && (pattern = {
+        return ret.patterns = (copy.patterns || []).map((pattern)=>{
+            "string" == typeof pattern && (pattern = {
                 from: pattern
-            }), pattern.force ??= !1, pattern.noErrorOnMissing ??= !1, pattern.priority ??= 0, pattern.globOptions ??= {}, pattern.copyPermissions ??= !1, pattern)), ret;
+            }), pattern.force ??= !1, pattern.noErrorOnMissing ??= !1, pattern.priority ??= 0, pattern.globOptions ??= {}, pattern.copyPermissions ??= !1;
+            let originalTransform = pattern.transform;
+            return originalTransform && ("object" == typeof originalTransform ? pattern.transform = (input, absoluteFilename)=>Promise.resolve(originalTransform.transformer(input, absoluteFilename)) : pattern.transform = (input, absoluteFilename)=>Promise.resolve(originalTransform(input, absoluteFilename))), pattern;
+        }), ret;
     }), DEFAULT_FILENAME = "[name].css", LOADER_PATH = (0, external_node_path_namespaceObject.join)(__dirname, "cssExtractLoader.js");
     class CssExtractRspackPlugin {
         static pluginName = "css-extract-rspack-plugin";
@@ -4635,15 +4659,7 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
             if (!enabled.has(type)) return enabled.add(type), createBuiltinPlugin(this.name, type);
         }
     }
-    let EnableWasmLoadingPlugin = base_create(binding_.BuiltinPluginName.EnableWasmLoadingPlugin, (type)=>type), EnsureChunkConditionsPlugin = base_create(binding_.BuiltinPluginName.EnsureChunkConditionsPlugin, ()=>{}), EvalDevToolModulePlugin = base_create(binding_.BuiltinPluginName.EvalDevToolModulePlugin, (options)=>options, "compilation"), EvalSourceMapDevToolPlugin = base_create(binding_.BuiltinPluginName.EvalSourceMapDevToolPlugin, (options)=>({
-            filename: options.filename || void 0,
-            append: options.append,
-            namespace: options.namespace ?? "",
-            columns: options.columns ?? !0,
-            noSources: options.noSources ?? !1,
-            publicPath: options.publicPath,
-            module: options.module
-        }), "compilation");
+    let EnableWasmLoadingPlugin = base_create(binding_.BuiltinPluginName.EnableWasmLoadingPlugin, (type)=>type), EnsureChunkConditionsPlugin = base_create(binding_.BuiltinPluginName.EnsureChunkConditionsPlugin, ()=>{}), EvalDevToolModulePlugin = base_create(binding_.BuiltinPluginName.EvalDevToolModulePlugin, (options)=>options, "compilation"), EvalSourceMapDevToolPlugin = base_create(binding_.BuiltinPluginName.EvalSourceMapDevToolPlugin, (options)=>options, "compilation");
     class ExternalsPlugin extends RspackBuiltinPlugin {
         type;
         externals;
@@ -5073,18 +5089,36 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
     let HttpExternalsRspackPlugin = base_create(binding_.BuiltinPluginName.HttpExternalsRspackPlugin, (css, webAsync)=>({
             css,
             webAsync
-        })), defaultHttpClient = (url, headers)=>fetch(url, {
+        })), external_node_zlib_namespaceObject = require("node:zlib"), getHttp = memoize(()=>__webpack_require__("node:http")), getHttps = memoize(()=>__webpack_require__("node:https")), defaultHttpClient = async (url, headers)=>{
+        let { res, body } = await function(url, options) {
+            let send = "https:" === new URL(url).protocol ? getHttps() : getHttp();
+            return new Promise((resolve, reject)=>{
+                send.get(url, options, (res)=>{
+                    let contentEncoding = res.headers["content-encoding"], stream = res;
+                    "gzip" === contentEncoding ? stream = stream.pipe((0, external_node_zlib_namespaceObject.createGunzip)()) : "br" === contentEncoding ? stream = stream.pipe((0, external_node_zlib_namespaceObject.createBrotliDecompress)()) : "deflate" === contentEncoding && (stream = stream.pipe((0, external_node_zlib_namespaceObject.createInflate)()));
+                    let chunks = [];
+                    stream.on("data", (chunk)=>{
+                        chunks.push(chunk);
+                    }), stream.on("end", ()=>{
+                        let bodyBuffer = Buffer.concat(chunks);
+                        if (!res.complete) return void reject(Error(`${url} request was terminated early`));
+                        resolve({
+                            res,
+                            body: bodyBuffer
+                        });
+                    });
+                }).on("error", reject);
+            });
+        }(url, {
             headers
-        }).then((response)=>response.arrayBuffer().then((buffer)=>{
-                let responseHeaders = {};
-                return response.headers.forEach((value, key)=>{
-                    responseHeaders[key] = value;
-                }), {
-                    status: response.status,
-                    headers: responseHeaders,
-                    body: Buffer.from(buffer)
-                };
-            }));
+        }), responseHeaders = {};
+        for (let [key, value] of Object.entries(res.headers))Array.isArray(value) ? responseHeaders[key] = value.join(", ") : responseHeaders[key] = value;
+        return {
+            status: res.statusCode,
+            headers: responseHeaders,
+            body: Buffer.from(body)
+        };
+    };
     class HttpUriPlugin extends RspackBuiltinPlugin {
         options;
         name;
@@ -5656,7 +5690,20 @@ Plugins which provide custom chunk loading types must call EnableChunkLoadingPlu
     function normalizePath(path) {
         return path.replace(/\?.*$/, "").split(external_node_path_namespaceObject.sep).join("/");
     }
-    let ModuleInfoHeaderPlugin = base_create(binding_.BuiltinPluginName.ModuleInfoHeaderPlugin, (verbose)=>verbose, "compilation");
+    let ModuleInfoHeaderPlugin = base_create(binding_.BuiltinPluginName.ModuleInfoHeaderPlugin, (verbose)=>verbose, "compilation"), CssChunkingPlugin = base_create(binding_.BuiltinPluginName.CssChunkingPlugin, function(options) {
+        if (options.nextjs) return {
+            strict: options.strict,
+            exclude: /^pages\//
+        };
+        let { splitChunks } = this.options.optimization;
+        if (splitChunks) {
+            let cssMiniExtractIndex = splitChunks.defaultSizeTypes.indexOf("css/mini-extract");
+            cssMiniExtractIndex && splitChunks.defaultSizeTypes.splice(cssMiniExtractIndex, 1);
+            let cssIndex = splitChunks.defaultSizeTypes.indexOf("css");
+            cssIndex && splitChunks.defaultSizeTypes.splice(cssIndex, 1);
+        }
+        return options;
+    });
     function assertNotNill(value) {
         if (null == value) throw Error(`${value} should not be undefined or null`);
     }
@@ -6487,7 +6534,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
             asyncWebAssembly: options.experiments.asyncWebAssembly,
             css: options.experiments.css,
             targetProperties,
-            mode: options.mode
+            mode: options.mode,
+            uniqueName: options.output.uniqueName
         }), applyOutputDefaults(options.output, {
             context: options.context,
             targetProperties,
@@ -6526,15 +6574,20 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
     }, applyExperimentsDefaults = (experiments, { production, development })=>{
         F(experiments, "cache", ()=>development), D(experiments, "futureDefaults", !1), D(experiments, "lazyCompilation", !1), D(experiments, "asyncWebAssembly", experiments.futureDefaults), D(experiments, "css", !!experiments.futureDefaults || void 0), D(experiments, "layers", !1), D(experiments, "topLevelAwait", !0), D(experiments, "buildHttp", void 0), experiments.buildHttp && "object" == typeof experiments.buildHttp && D(experiments.buildHttp, "upgrade", !1), D(experiments, "incremental", {}), "object" == typeof experiments.incremental && (D(experiments.incremental, "silent", !0), D(experiments.incremental, "make", !0), D(experiments.incremental, "inferAsyncModules", !1), D(experiments.incremental, "providedExports", !1), D(experiments.incremental, "dependenciesDiagnostics", !1), D(experiments.incremental, "sideEffects", !1), D(experiments.incremental, "buildChunkGraph", !1), D(experiments.incremental, "moduleIds", !1), D(experiments.incremental, "chunkIds", !1), D(experiments.incremental, "modulesHashes", !1), D(experiments.incremental, "modulesCodegen", !1), D(experiments.incremental, "modulesRuntimeRequirements", !1), D(experiments.incremental, "chunksRuntimeRequirements", !1), D(experiments.incremental, "chunksHashes", !1), D(experiments.incremental, "chunksRender", !1), D(experiments.incremental, "emitAssets", !0)), D(experiments, "rspackFuture", {}), D(experiments, "parallelCodeSplitting", !0), D(experiments, "parallelLoader", !1);
     }, applybundlerInfoDefaults = (rspackFuture, library)=>{
-        "object" == typeof rspackFuture && (D(rspackFuture, "bundlerInfo", {}), "object" == typeof rspackFuture.bundlerInfo && (D(rspackFuture.bundlerInfo, "version", "1.3.10"), D(rspackFuture.bundlerInfo, "bundler", "rspack"), D(rspackFuture.bundlerInfo, "force", !library)));
+        "object" == typeof rspackFuture && (D(rspackFuture, "bundlerInfo", {}), "object" == typeof rspackFuture.bundlerInfo && (D(rspackFuture.bundlerInfo, "version", "1.3.11"), D(rspackFuture.bundlerInfo, "bundler", "rspack"), D(rspackFuture.bundlerInfo, "force", !library)));
     }, applySnapshotDefaults = (_snapshot, _env)=>{}, applyJavascriptParserOptionsDefaults = (parserOptions)=>{
         D(parserOptions, "dynamicImportMode", "lazy"), D(parserOptions, "dynamicImportPrefetch", !1), D(parserOptions, "dynamicImportPreload", !1), D(parserOptions, "url", !0), D(parserOptions, "exprContextCritical", !0), D(parserOptions, "wrappedContextCritical", !1), D(parserOptions, "wrappedContextRegExp", /.*/), D(parserOptions, "strictExportPresence", !1), D(parserOptions, "requireAsExpression", !0), D(parserOptions, "requireDynamic", !0), D(parserOptions, "requireResolve", !0), D(parserOptions, "importDynamic", !0), D(parserOptions, "worker", [
             "..."
         ]), D(parserOptions, "importMeta", !0);
     }, applyJsonGeneratorOptionsDefaults = (generatorOptions)=>{
         D(generatorOptions, "JSONParse", !0);
-    }, applyModuleDefaults = (module, { asyncWebAssembly, css, targetProperties, mode })=>{
-        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), applyJavascriptParserOptionsDefaults(module.parser.javascript), F(module.parser, JSON_MODULE_TYPE, ()=>({})), assertNotNill(module.parser[JSON_MODULE_TYPE]), D(module.parser[JSON_MODULE_TYPE], "exportsDepth", "development" === mode ? 1 : Number.MAX_SAFE_INTEGER), F(module.generator, "json", ()=>({})), assertNotNill(module.generator.json), applyJsonGeneratorOptionsDefaults(module.generator.json), css && (F(module.parser, "css", ()=>({})), assertNotNill(module.parser.css), D(module.parser.css, "namedExports", !0), D(module.parser.css, "url", !0), F(module.parser, "css/auto", ()=>({})), assertNotNill(module.parser["css/auto"]), D(module.parser["css/auto"], "namedExports", !0), D(module.parser["css/auto"], "url", !0), F(module.parser, "css/module", ()=>({})), assertNotNill(module.parser["css/module"]), D(module.parser["css/module"], "namedExports", !0), D(module.parser["css/module"], "url", !0), F(module.generator, "css", ()=>({})), assertNotNill(module.generator.css), D(module.generator.css, "exportsOnly", !targetProperties || !targetProperties.document), D(module.generator.css, "esModule", !0), F(module.generator, "css/auto", ()=>({})), assertNotNill(module.generator["css/auto"]), D(module.generator["css/auto"], "exportsOnly", !targetProperties || !targetProperties.document), D(module.generator["css/auto"], "exportsConvention", "as-is"), D(module.generator["css/auto"], "localIdentName", "[uniqueName]-[id]-[local]"), D(module.generator["css/auto"], "esModule", !0), F(module.generator, "css/module", ()=>({})), assertNotNill(module.generator["css/module"]), D(module.generator["css/module"], "exportsOnly", !targetProperties || !targetProperties.document), D(module.generator["css/module"], "exportsConvention", "as-is"), D(module.generator["css/module"], "localIdentName", "[uniqueName]-[id]-[local]"), D(module.generator["css/module"], "esModule", !0)), A(module, "defaultRules", ()=>{
+    }, applyModuleDefaults = (module, { asyncWebAssembly, css, targetProperties, mode, uniqueName })=>{
+        if (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), applyJavascriptParserOptionsDefaults(module.parser.javascript), F(module.parser, JSON_MODULE_TYPE, ()=>({})), assertNotNill(module.parser[JSON_MODULE_TYPE]), D(module.parser[JSON_MODULE_TYPE], "exportsDepth", "development" === mode ? 1 : Number.MAX_SAFE_INTEGER), F(module.generator, "json", ()=>({})), assertNotNill(module.generator.json), applyJsonGeneratorOptionsDefaults(module.generator.json), css) {
+            F(module.parser, "css", ()=>({})), assertNotNill(module.parser.css), D(module.parser.css, "namedExports", !0), D(module.parser.css, "url", !0), F(module.parser, "css/auto", ()=>({})), assertNotNill(module.parser["css/auto"]), D(module.parser["css/auto"], "namedExports", !0), D(module.parser["css/auto"], "url", !0), F(module.parser, "css/module", ()=>({})), assertNotNill(module.parser["css/module"]), D(module.parser["css/module"], "namedExports", !0), D(module.parser["css/module"], "url", !0), F(module.generator, "css", ()=>({})), assertNotNill(module.generator.css), D(module.generator.css, "exportsOnly", !targetProperties || !targetProperties.document), D(module.generator.css, "esModule", !0), F(module.generator, "css/auto", ()=>({})), assertNotNill(module.generator["css/auto"]), D(module.generator["css/auto"], "exportsOnly", !targetProperties || !targetProperties.document), D(module.generator["css/auto"], "exportsConvention", "as-is");
+            let localIdentName = uniqueName && uniqueName.length > 0 ? "[uniqueName]-[id]-[local]" : "[id]-[local]";
+            D(module.generator["css/auto"], "localIdentName", localIdentName), D(module.generator["css/auto"], "esModule", !0), F(module.generator, "css/module", ()=>({})), assertNotNill(module.generator["css/module"]), D(module.generator["css/module"], "exportsOnly", !targetProperties || !targetProperties.document), D(module.generator["css/module"], "exportsConvention", "as-is"), D(module.generator["css/module"], "localIdentName", localIdentName), D(module.generator["css/module"], "esModule", !0);
+        }
+        A(module, "defaultRules", ()=>{
             let esm = {
                 type: "javascript/esm",
                 resolve: {
@@ -6736,7 +6789,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
             if (tp) {
                 if (tp.fetchWasm) return "fetch";
                 if (tp.nodeBuiltins) return "async-node";
-                if (null === tp.nodeBuiltins || null === tp.fetchWasm) return "universal";
+                null === tp.nodeBuiltins || tp.fetchWasm;
             }
             return !1;
         }), F(output, "workerWasmLoading", ()=>output.wasmLoading), F(output, "globalObject", ()=>{
@@ -7429,7 +7482,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
             },
             arm: "gnueabihf"
         }
-    }, BINDING_VERSION = __webpack_require__("@rspack/binding/package.json").version, CORE_VERSION = "1.3.10", getAddonPlatformArchAbi = ()=>{
+    }, BINDING_VERSION = __webpack_require__("@rspack/binding/package.json").version, CORE_VERSION = "1.3.11", getAddonPlatformArchAbi = ()=>{
         let { platform, arch } = process, binding = "";
         binding += platform;
         let abi = NodePlatformArchToAbi[platform][arch];
@@ -7997,7 +8050,26 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
             });
         }
     }
-    Object.defineProperty(binding_.Module.prototype, "identifier", {
+    let $assets = Symbol("assets");
+    Object.defineProperty(binding_.BuildInfo.prototype, "assets", {
+        enumerable: !0,
+        configurable: !0,
+        get () {
+            if (this._assets[$assets]) return this._assets[$assets];
+            let assets = new Proxy(Object.create(null), {
+                ownKeys: ()=>this._assets.keys(),
+                getOwnPropertyDescriptor: ()=>({
+                        enumerable: !0,
+                        configurable: !0
+                    })
+            });
+            return Object.defineProperty(this._assets, $assets, {
+                enumerable: !1,
+                configurable: !0,
+                value: assets
+            }), assets;
+        }
+    }), Object.defineProperty(binding_.Module.prototype, "identifier", {
         enumerable: !0,
         configurable: !0,
         value () {
@@ -8152,7 +8224,132 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                     await queried.promise(data, {});
                 };
             })
-        }), COMPILATION_WEAK_MAP = new WeakMap();
+        }), traceHookPlugin_PLUGIN_NAME = "TraceHookPlugin", makeInterceptorFor = (compilerName, tracer)=>(hookName)=>({
+                register: (tapInfo)=>{
+                    let { name, type, fn: internalFn } = tapInfo, newFn = name === traceHookPlugin_PLUGIN_NAME ? internalFn : makeNewTraceTapFn(compilerName, hookName, tracer, {
+                        name,
+                        type,
+                        fn: internalFn
+                    });
+                    return {
+                        ...tapInfo,
+                        fn: newFn
+                    };
+                }
+            }), interceptAllHooksFor = (instance, tracer, logLabel)=>{
+        if (Reflect.has(instance, "hooks")) for (let hookName of Object.keys(instance.hooks)){
+            let hook = instance.hooks[hookName];
+            hook && !hook._fakeHook && hook.intercept(makeInterceptorFor(logLabel, tracer)(hookName));
+        }
+    }, makeNewTraceTapFn = (compilerName, hookName, tracer, { name: pluginName, type, fn })=>{
+        let name = `${pluginName}:${hookName}`;
+        switch(type){
+            case "promise":
+                return (...args)=>{
+                    let id2 = tracer.counter++;
+                    return tracer.startAsync({
+                        name,
+                        id: pluginName,
+                        args: {
+                            id2,
+                            compilerName,
+                            hookName,
+                            pluginName
+                        }
+                    }), fn(...args).then((r)=>(tracer.endAsync({
+                            name,
+                            id: pluginName,
+                            args: {
+                                id2,
+                                compilerName,
+                                hookName,
+                                pluginName
+                            }
+                        }), r));
+                };
+            case "async":
+                return (...args)=>{
+                    let id2 = tracer.counter++;
+                    tracer.startAsync({
+                        name,
+                        id: pluginName,
+                        args: {
+                            id2,
+                            compilerName,
+                            hookName,
+                            pluginName
+                        }
+                    });
+                    let callback = args.pop();
+                    fn(...args, (...r)=>{
+                        tracer.endAsync({
+                            name,
+                            id: pluginName,
+                            args: {
+                                id2,
+                                compilerName,
+                                hookName,
+                                pluginName
+                            }
+                        }), callback(...r);
+                    });
+                };
+            case "sync":
+                return (...args)=>{
+                    let r, id2 = tracer.counter++;
+                    if (name === traceHookPlugin_PLUGIN_NAME) return fn(...args);
+                    tracer.startAsync({
+                        name,
+                        id: pluginName,
+                        args: {
+                            id2,
+                            compilerName,
+                            hookName,
+                            pluginName
+                        }
+                    });
+                    try {
+                        r = fn(...args);
+                    } catch (err) {
+                        throw tracer.endAsync({
+                            name,
+                            id: pluginName,
+                            args: {
+                                id2: compilerName,
+                                hookName,
+                                pluginName
+                            }
+                        }), err;
+                    }
+                    return tracer.endAsync({
+                        name,
+                        id: pluginName,
+                        args: {
+                            id2,
+                            compilerName,
+                            hookName,
+                            pluginName
+                        }
+                    }), r;
+                };
+            default:
+                return fn;
+        }
+    }, compilerId = 0;
+    class TraceHookPlugin {
+        name = traceHookPlugin_PLUGIN_NAME;
+        apply(compiler) {
+            let compilerName = compiler.name || (compilerId++).toString();
+            for (let hookName of Object.keys(compiler.hooks)){
+                let hook = compiler.hooks[hookName];
+                hook && hook.intercept(makeInterceptorFor(compilerName, JavaScriptTracer)(hookName));
+            }
+            compiler.hooks.compilation.tap(traceHookPlugin_PLUGIN_NAME, (compilation, { normalModuleFactory, contextModuleFactory })=>{
+                interceptAllHooksFor(compilation, JavaScriptTracer, "Compilation"), interceptAllHooksFor(normalModuleFactory, JavaScriptTracer, "Normal Module Factory"), interceptAllHooksFor(contextModuleFactory, JavaScriptTracer, "Context Module Factory");
+            });
+        }
+    }
+    let COMPILATION_WEAK_MAP = new WeakMap();
     class Compiler {
         #instance;
         #initial;
@@ -8277,7 +8474,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                     "entry"
                 ]),
                 additionalPass: new lite_tapable_namespaceObject.AsyncSeriesHook([])
-            }, this.webpack = src_rspack, this.rspack = src_rspack, this.root = this, this.outputPath = "", this.inputFileSystem = null, this.intermediateFileSystem = null, this.outputFileSystem = null, this.watchFileSystem = null, this.records = {}, this.options = options, this.context = context, this.cache = new Cache_Cache(), this.compilerPath = "", this.running = !1, this.idle = !1, this.watchMode = !1, this.resolverFactory = new ResolverFactory(options.resolve.pnp ?? getPnpDefault()), new JsLoaderRspackPlugin(this).apply(this), new ExecuteModulePlugin().apply(this);
+            }, this.webpack = src_rspack, this.rspack = src_rspack, this.root = this, this.outputPath = "", this.inputFileSystem = null, this.intermediateFileSystem = null, this.outputFileSystem = null, this.watchFileSystem = null, this.records = {}, this.options = options, this.context = context, this.cache = new Cache_Cache(), this.compilerPath = "", this.running = !1, this.idle = !1, this.watchMode = !1, this.resolverFactory = new ResolverFactory(options.resolve.pnp ?? getPnpDefault()), new JsLoaderRspackPlugin(this).apply(this), new ExecuteModulePlugin().apply(this), new TraceHookPlugin().apply(this);
         }
         get recordsInputPath() {
             return unsupported("Compiler.recordsInputPath");
@@ -8608,7 +8805,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
             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 = "1.3.10", obj.version = "5.75.0"), childOptions.hash && (obj.hash = obj.children.map((j)=>j.hash).join(""));
+            }), childOptions.version && (obj.rspackVersion = "1.3.11", 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
@@ -9498,7 +9695,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                 object.hash = context.getStatsCompilation(compilation).hash;
             },
             version: (object)=>{
-                object.version = "5.75.0", object.rspackVersion = "1.3.10";
+                object.version = "5.75.0", object.rspackVersion = "1.3.11";
             },
             env: (object, _compilation, _context, { _env })=>{
                 object.env = _env;
@@ -9510,6 +9707,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
                 object.builtAt = compilation.endTime;
             },
             publicPath: (object, compilation)=>{
+                if ("function" == typeof compilation.outputOptions.publicPath) throw new DeadlockRiskError("publicPath as function can't be used with stats.publicPath=true, which may cause deadlock risk, consider setting stats.publicPath=false in rspack config");
                 object.publicPath = compilation.getPath(compilation.outputOptions.publicPath || "");
             },
             outputPath: (object, compilation)=>{
@@ -11944,7 +12142,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
     }), entryStatic = zod_index_js_namespaceObject.z.record(entryItem.or(entryDescription)).or(entryItem), entryDynamic = zod_index_js_namespaceObject.z.function().returns(entryStatic.or(zod_index_js_namespaceObject.z.promise(entryStatic))), zod_entry = entryStatic.or(entryDynamic), zod_path = zod_index_js_namespaceObject.z.string(), pathinfo = zod_index_js_namespaceObject.z.boolean().or(zod_index_js_namespaceObject.z.literal("verbose")), webassemblyModuleFilename = zod_index_js_namespaceObject.z.string(), zod_crossOriginLoading = zod_index_js_namespaceObject.z.literal(!1).or(zod_index_js_namespaceObject.z.enum([
         "anonymous",
         "use-credentials"
-    ])), hotUpdateGlobal = zod_index_js_namespaceObject.z.string(), uniqueName = zod_index_js_namespaceObject.z.string(), chunkLoadingGlobal = zod_index_js_namespaceObject.z.string(), zod_enabledLibraryTypes = zod_index_js_namespaceObject.z.array(libraryType), clean = zod_index_js_namespaceObject.z.union([
+    ])), hotUpdateGlobal = zod_index_js_namespaceObject.z.string(), zod_uniqueName = zod_index_js_namespaceObject.z.string(), chunkLoadingGlobal = zod_index_js_namespaceObject.z.string(), zod_enabledLibraryTypes = zod_index_js_namespaceObject.z.array(libraryType), clean = zod_index_js_namespaceObject.z.union([
         zod_index_js_namespaceObject.z.boolean(),
         zod_index_js_namespaceObject.z.strictObject({
             keep: zod_index_js_namespaceObject.z.instanceof(RegExp).or(zod_index_js_namespaceObject.z.string()).or(zod_index_js_namespaceObject.z.function().args(zod_index_js_namespaceObject.z.string()).returns(zod_index_js_namespaceObject.z.boolean())).optional()
@@ -11993,7 +12191,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         hotUpdateChunkFilename: filenameTemplate.optional(),
         hotUpdateGlobal: hotUpdateGlobal.optional(),
         assetModuleFilename: zod_filename.optional(),
-        uniqueName: uniqueName.optional(),
+        uniqueName: zod_uniqueName.optional(),
         chunkLoadingGlobal: chunkLoadingGlobal.optional(),
         enabledLibraryTypes: zod_enabledLibraryTypes.optional(),
         library: zod_library.optional(),
@@ -13161,7 +13359,7 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         let _options = JSON.stringify(options || {});
         return binding_default().transform(source, _options);
     }
-    let exports_rspackVersion = "1.3.10", exports_version = "5.75.0", exports_WebpackError = Error, sources = __webpack_require__("webpack-sources"), exports_config = {
+    let exports_rspackVersion = "1.3.11", exports_version = "5.75.0", exports_WebpackError = Error, sources = __webpack_require__("webpack-sources"), exports_config = {
         getNormalizedRspackOptions: getNormalizedRspackOptions,
         applyRspackOptionsDefaults: applyRspackOptionsDefaults,
         getNormalizedWebpackOptions: getNormalizedRspackOptions,
@@ -13268,7 +13466,8 @@ You can also more options via the 'target' option: 'browserslist' / 'browserslis
         swc: {
             minify: minify,
             transform: transform
-        }
+        },
+        CssChunkingPlugin: CssChunkingPlugin
     };
     function createCompiler(userOptions) {
         let options = getNormalizedRspackOptions(userOptions);

package/dist/trace/index.d.ts

@@ -3,9 +3,9 @@ export interface ChromeEvent {
     ph?: string;
     cat?: string;
     ts?: number;
-    pid?: number;
-    tid?: number;
-    id?: number;
+    pid?: number | string;
+    tid?: number | string;
+    id?: number | string;
     args?: {
         [key: string]: any;
     };
@@ -20,6 +20,7 @@ export declare class JavaScriptTracer {
     static layer: string;
     static output: string;
     static session: import("node:inspector").Session;
+    static counter: number;
     static initJavaScriptTrace(layer: string, output: string): Promise<void>;
     static initCpuProfiler(): void;
     static cleanupJavaScriptTrace(): Promise<void>;

package/dist/trace/traceHookPlugin.d.ts

@@ -0,0 +1,5 @@
+import type { Compiler } from "../exports";
+export declare class TraceHookPlugin {
+    name: string;
+    apply(compiler: Compiler): void;
+}

package/dist/worker.js

@@ -853,7 +853,7 @@ for(var __webpack_i__ in (()=>{
                     await loadLoaderAsync(currentLoaderObject);
                     let fn = currentLoaderObject.normal;
                     currentLoaderObject.normalExecuted = !0, fn && (args1 = args, !(raw = !!currentLoaderObject.raw) && args1[0] instanceof Uint8Array ? args1[0] = function(buf) {
-                        let str = decoder.decode(buf);
+                        let str = decoder.decode(buf.buffer instanceof SharedArrayBuffer ? Buffer.from(buf) : buf);
                         return 0xfeff === str.charCodeAt(0) ? str.slice(1) : str;
                     }(args1[0]) : raw && "string" == typeof args1[0] && (args1[0] = Buffer.from(args1[0], "utf-8")), raw && args1[0] instanceof Uint8Array && !Buffer.isBuffer(args1[0]) && (args1[0] = Buffer.from(args1[0].buffer)), args = await utils_runSyncOrAsync(fn, loaderContext, args) || []);
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/core",
-  "version": "1.3.10",
+  "version": "1.3.11",
   "webpackVersion": "5.75.0",
   "license": "MIT",
   "description": "The fast Rust-based web bundler with webpack-compatible API",
@@ -39,7 +39,7 @@
   "devDependencies": {
     "@swc/core": "1.11.24",
     "@swc/types": "0.1.21",
-    "@rslib/core": "0.6.8",
+    "@rslib/core": "0.7.0",
     "@types/graceful-fs": "4.1.9",
     "@types/watchpack": "^2.4.4",
     "@types/webpack-sources": "3.2.3",
@@ -58,8 +58,8 @@
   "dependencies": {
     "@module-federation/runtime-tools": "0.13.1",
     "@rspack/lite-tapable": "1.0.1",
-    "caniuse-lite": "^1.0.30001717",
-    "@rspack/binding": "1.3.10"
+    "caniuse-lite": "^1.0.30001718",
+    "@rspack/binding": "1.3.11"
   },
   "peerDependencies": {
     "@swc/helpers": ">=0.5.1"