@rspack-canary/test-tools 1.6.0-canary-e28e40e9-20251022173516 → 1.6.0-canary-941e2203-20251024173714

package/dist/runner/web/index.js

@@ -13,7 +13,6 @@ const helper_1 = require("../../helper");
 const EventSourceForNode_1 = __importDefault(require("../../helper/legacy/EventSourceForNode"));
 const urlToRelativePath_1 = __importDefault(require("../../helper/legacy/urlToRelativePath"));
 const node_1 = require("../node");
-const EVAL_LOCATION_REGEX = /<anonymous>:(\d+)/;
 // Compatibility code to suppress iconv-lite warnings
 require("iconv-lite").skipDecodeWarning = true;
 const FAKE_HOSTS = [
@@ -73,6 +72,7 @@ class WebRunner extends node_1.NodeRunner {
     }
     run(file) {
         if (!file.endsWith(".js") && !file.endsWith(".mjs")) {
+            this.log(`css: ${file}`);
             const cssElement = this.dom.window.document.createElement("link");
             cssElement.href = file;
             cssElement.rel = "stylesheet";
@@ -84,11 +84,15 @@ class WebRunner extends node_1.NodeRunner {
     getGlobal(name) {
         return this.globalContext[name];
     }
+    log(message) {
+        this._options.logs?.push(`[WebRunner] ${message}`);
+    }
     createResourceLoader() {
         const that = this;
         class CustomResourceLoader extends jsdom_1.ResourceLoader {
             fetch(url, _) {
                 const filePath = that.urlToPath(url);
+                that.log(`resource loader: ${url} -> ${filePath}`);
                 let finalCode;
                 if (node_path_1.default.extname(filePath) === ".js") {
                     const currentDirectory = node_path_1.default.dirname(filePath);
@@ -139,7 +143,9 @@ class WebRunner extends node_1.NodeRunner {
         moduleScope.EventSource = EventSourceForNode_1.default;
         moduleScope.fetch = async (url) => {
             try {
-                const buffer = await new Promise((resolve, reject) => node_fs_1.default.readFile(this.urlToPath(url), (err, b) => err ? reject(err) : resolve(b)));
+                const filePath = this.urlToPath(url);
+                this.log(`fetch: ${url} -> ${filePath}`);
+                const buffer = await new Promise((resolve, reject) => node_fs_1.default.readFile(filePath, (err, b) => (err ? reject(err) : resolve(b))));
                 return {
                     status: 200,
                     ok: true,
@@ -158,8 +164,9 @@ class WebRunner extends node_1.NodeRunner {
         };
         moduleScope.URL = URL;
         moduleScope.importScripts = (url) => {
-            this._options.env.expect(url).toMatch(/^https:\/\/test\.cases\/path\//);
-            this.requirers.get("entry")(this._options.dist, (0, urlToRelativePath_1.default)(url));
+            const path = (0, urlToRelativePath_1.default)(url);
+            this.log(`importScripts: ${url} -> ${path}`);
+            this.requirers.get("entry")(this._options.dist, path);
         };
         moduleScope.getComputedStyle = (element) => {
             const computedStyle = this.dom.window.getComputedStyle(element);
@@ -195,51 +202,7 @@ class WebRunner extends node_1.NodeRunner {
                 currentModuleScope.__STATS_I__ = statsIndex;
             }
         }
-        const createLocatedError = (e, file) => {
-            const match = (e.stack || e.message).match(EVAL_LOCATION_REGEX);
-            if (match) {
-                const [, line] = match;
-                const realLine = Number(line) - 34;
-                const codeLines = file.content.split("\n");
-                const lineContents = [
-                    ...codeLines
-                        .slice(Math.max(0, realLine - 3), Math.max(0, realLine - 1))
-                        .map(line => `│  ${line}`),
-                    `│> ${codeLines[realLine - 1]}`,
-                    ...codeLines.slice(realLine, realLine + 2).map(line => `│  ${line}`)
-                ];
-                const message = `Error in JSDOM when running file '${file.path}' at line ${realLine}: ${e.message}\n${lineContents.join("\n")}`;
-                const finalError = new Error(message);
-                finalError.stack = undefined;
-                return finalError;
-            }
-            else {
-                return e;
-            }
-        };
-        const originIt = currentModuleScope.it;
-        currentModuleScope.it = (description, fn) => {
-            originIt(description, async () => {
-                try {
-                    await fn();
-                }
-                catch (err) {
-                    throw createLocatedError(err, file);
-                }
-            });
-        };
-        const scopeKey = (0, helper_1.escapeSep)(file.path);
-        const args = Object.keys(currentModuleScope).filter(arg => !["window", "self", "globalThis", "console"].includes(arg));
-        const argValues = args
-            .map(arg => `window["${scopeKey}"]["${arg}"]`)
-            .join(", ");
-        this.dom.window[scopeKey] = currentModuleScope;
-        this.dom.window["__GLOBAL_SHARED__"] = this.globalContext;
-        this.dom.window["__FILE__"] = file;
-        this.dom.window["__CREATE_LOCATED_ERROR__"] = createLocatedError;
-        return [
-            m,
-            `// hijack document.currentScript for auto public path
+        const proxyCode = `// hijack document.currentScript for auto public path
 			var $$g$$ = new Proxy(window, {
 				get(target, prop, receiver) {
 					if (prop === "document") {
@@ -270,7 +233,31 @@ class WebRunner extends node_1.NodeRunner {
 					}
 					return Reflect.set(target, prop, value, receiver);
 				}
-			});
+			});`;
+        const createJSDOMLocatedError = (0, node_1.createLocatedError)(this._options.errors || [], proxyCode.split("\n").length + 2);
+        const originIt = currentModuleScope.it;
+        currentModuleScope.it = (description, fn) => {
+            originIt(description, async () => {
+                try {
+                    await fn();
+                }
+                catch (err) {
+                    throw createJSDOMLocatedError(err, file);
+                }
+            });
+        };
+        const scopeKey = (0, helper_1.escapeSep)(file.path);
+        const args = Object.keys(currentModuleScope).filter(arg => !["window", "self", "globalThis", "console"].includes(arg));
+        const argValues = args
+            .map(arg => `window["${scopeKey}"]["${arg}"]`)
+            .join(", ");
+        this.dom.window[scopeKey] = currentModuleScope;
+        this.dom.window["__GLOBAL_SHARED__"] = this.globalContext;
+        this.dom.window["__FILE__"] = file;
+        this.dom.window["__CREATE_LOCATED_ERROR__"] = createJSDOMLocatedError;
+        return [
+            m,
+            `${proxyCode}
 			(function(window, self, globalThis, console, ${args.join(", ")}) {
 				try {
 				  ${file.content}
@@ -283,6 +270,7 @@ class WebRunner extends node_1.NodeRunner {
     createJSDOMRequirer() {
         return (currentDirectory, modulePath, context = {}) => {
             const file = context.file || this.getFile(modulePath, currentDirectory);
+            this.log(`jsdom: ${modulePath} -> ${file?.path}`);
             if (!file) {
                 return this.requirers.get("miss")(currentDirectory, modulePath);
             }

package/dist/test/context.d.ts

@@ -1,24 +1,23 @@
 import type { ITestCompilerManager, ITestContext, ITestEnv, ITesterConfig, ITestRunner, TTestConfig } from "../type";
-export type TTestContextOptions = Omit<ITesterConfig, "name" | "steps">;
+export type TTestContextOptions = Omit<ITesterConfig, "steps">;
 export declare class TestContext implements ITestContext {
     private config;
-    protected errors: Map<string, Error[]>;
-    protected compilers: Map<string, ITestCompilerManager>;
-    protected store: Map<string, Record<string, unknown>>;
+    protected errors: Error[];
+    protected compiler: ITestCompilerManager | null;
+    protected store: Map<string, unknown>;
     protected runners: Map<string, ITestRunner>;
     constructor(config: TTestContextOptions);
     getSource(sub?: string): string;
     getDist(sub?: string): string;
     getTemp(sub?: string): string | null;
-    getCompiler(name: string): ITestCompilerManager;
-    getRunner(name: string, file: string, env: ITestEnv): ITestRunner;
+    getCompiler(): ITestCompilerManager;
+    getRunner(file: string, env: ITestEnv): ITestRunner;
     getTestConfig(): TTestConfig;
-    setValue<T>(name: string, key: string, value: T): void;
-    getValue<T>(name: string, key: string): T | void;
-    hasError(name?: string): boolean;
-    emitError(name: string, err: Error | string): void;
-    getNames(): string[];
-    getError(name?: string): Error[];
-    clearError(name?: string): void;
-    closeCompiler(name: string): Promise<void>;
+    setValue<T>(key: string, value: T): void;
+    getValue<T>(key: string): T | void;
+    hasError(): boolean;
+    emitError(err: Error | string): void;
+    getError(): Error[];
+    clearError(): void;
+    closeCompiler(): Promise<void>;
 }

package/dist/test/context.js

@@ -6,11 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestContext = void 0;
 const node_path_1 = __importDefault(require("node:path"));
 const compiler_1 = require("../compiler");
+const debug_1 = require("./debug");
 class TestContext {
     constructor(config) {
         this.config = config;
-        this.errors = new Map();
-        this.compilers = new Map();
+        this.errors = [];
+        this.compiler = null;
         this.store = new Map();
         this.runners = new Map();
     }
@@ -34,76 +35,68 @@ class TestContext {
         }
         return this.config.temp;
     }
-    getCompiler(name) {
-        let compiler = this.compilers.get(name);
-        if (!compiler) {
-            compiler = new compiler_1.TestCompilerManager();
-            this.compilers.set(name, compiler);
+    getCompiler() {
+        if (!this.compiler) {
+            this.compiler = new compiler_1.TestCompilerManager(this);
         }
-        return compiler;
+        return this.compiler;
     }
-    getRunner(name, file, env) {
+    getRunner(file, env) {
         if (!this.config.runnerCreator) {
             throw new Error("TestContext: Runner creator not found");
         }
-        const runnerKey = this.config.runnerCreator.key(this, name, file);
+        const runnerKey = this.config.runnerCreator.key(this, this.config.name, file);
         let runner = this.runners.get(runnerKey);
         if (runner) {
+            if (__DEBUG__) {
+                const getRunnerInfo = this.getValue(debug_1.DEBUG_SCOPES.RunGetRunner) || {};
+                getRunnerInfo[file] = {
+                    runnerKey,
+                    reused: true,
+                    runnerType: runner.constructor.name
+                };
+                this.setValue(debug_1.DEBUG_SCOPES.RunGetRunner, getRunnerInfo);
+            }
             return runner;
         }
-        runner = this.config.runnerCreator.runner(this, name, file, env);
+        runner = this.config.runnerCreator.runner(this, this.config.name, file, env);
+        runner.__key__ = runnerKey;
+        if (__DEBUG__) {
+            const getRunnerInfo = this.getValue(debug_1.DEBUG_SCOPES.RunGetRunner) || {};
+            getRunnerInfo[file] = {
+                runnerKey,
+                reused: false,
+                runnerType: runner.constructor.name
+            };
+            this.setValue(debug_1.DEBUG_SCOPES.RunGetRunner, getRunnerInfo);
+        }
         this.runners.set(runnerKey, runner);
         return runner;
     }
     getTestConfig() {
         return this.config.testConfig || {};
     }
-    setValue(name, key, value) {
-        if (!this.store.has(name)) {
-            this.store.set(name, {});
-        }
-        const scope = this.store.get(name);
-        scope[key] = value;
-    }
-    getValue(name, key) {
-        if (!this.store.has(name)) {
-            this.store.set(name, {});
-        }
-        const scope = this.store.get(name);
-        return scope[key];
+    setValue(key, value) {
+        this.store.set(key, value);
     }
-    hasError(name) {
-        if (name) {
-            return this.getError(name).length > 0;
-        }
-        return !!Array.from(this.errors.values()).reduce((res, arr) => res + arr.length, 0);
+    getValue(key) {
+        return this.store.get(key);
     }
-    emitError(name, err) {
-        const errors = this.errors.get(name) || [];
-        errors.push(typeof err === "string" ? new Error(err) : err);
-        this.errors.set(name, errors);
+    hasError() {
+        return this.errors.length > 0;
     }
-    getNames() {
-        return Array.from(this.compilers.keys());
+    emitError(err) {
+        this.errors.push(typeof err === "string" ? new Error(err) : err);
     }
-    getError(name) {
-        if (name) {
-            return this.errors.get(name) || [];
-        }
-        return Array.prototype.concat(...this.errors.values());
+    getError() {
+        return this.errors;
     }
-    clearError(name) {
-        if (name) {
-            this.errors.delete(name);
-        }
-        else {
-            this.errors.clear();
-        }
+    clearError() {
+        this.errors.length = 0;
     }
-    async closeCompiler(name) {
-        const compiler = this.getCompiler(name);
-        if (compiler) {
-            await compiler.close();
+    async closeCompiler() {
+        if (this.compiler) {
+            await this.compiler.close();
         }
     }
 }

package/dist/test/creator.js

@@ -161,7 +161,7 @@ class BasicCaseCreator {
                 }
                 catch (e) {
                     bailout = true;
-                    context.emitError(name, e);
+                    context.emitError(e);
                 }
                 await tester.check(env);
                 if (!tester.next() && context.hasError()) {

package/dist/test/debug.d.ts

@@ -0,0 +1,15 @@
+import type { ITestContext } from "../type";
+export declare function generateDebugReport(context: ITestContext): void;
+export declare const DEBUG_SCOPES: {
+    CompilerOptionsReadConfigFile: string;
+    CompilerOptionsFinalOptions: string;
+    CreateCompilerInstance: string;
+    CreateCompilerSetProperties: string;
+    BuildMethod: string;
+    BuildError: string;
+    BuildWarning: string;
+    RunFindBundle: string;
+    RunGetRunner: string;
+    RunLogs: string;
+    RunErrors: string;
+};

package/dist/test/debug.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEBUG_SCOPES = void 0;
+exports.generateDebugReport = generateDebugReport;
+const node_path_1 = __importDefault(require("node:path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const javascript_stringify_1 = require("javascript-stringify");
+const stringify_config_1 = __importDefault(require("../helper/stringify-config"));
+function generateDebugReport(context) {
+    const report = `
+## Case Meta
+
+${generateCaseMetaPathReport(context)}
+
+${generateCaseMetaTestConfigReport(context)}
+
+## Compiler Options
+
+${generateReadConfigFileReport(context)}
+
+${generateFinalOptionsReport(context)}
+
+## Create Compiler
+
+${generateCreateCompilerInstanceReport(context)}
+
+${generateCreateCompilerSetPropertiesReport(context)}
+
+## Build
+
+${generateBuildMethodReport(context)}
+
+${generateBuildErrorReport(context)}
+
+${generateBuildWarningReport(context)}
+
+## Run
+
+${generateRunFindBundleReport(context)}
+
+${generateRunGetRunnerReport(context)}
+
+${generateRunLogsReport(context)}
+
+${generateRunErrorsReport(context)}
+
+  `;
+    const dist = context.getDist("debug.md");
+    fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(dist));
+    fs_extra_1.default.writeFileSync(dist, report);
+}
+function generateCaseMetaPathReport(context) {
+    return `
+### Case Path
+
+- Source: ${context.getSource()}
+- Dist: ${context.getDist()}
+- Temp: ${context.getTemp()}
+  `;
+}
+function generateCaseMetaTestConfigReport(context) {
+    return `
+### Test Config
+
+\`\`\`js
+// ${node_path_1.default.resolve(context.getSource(), "./test.config.js")}
+${(0, javascript_stringify_1.stringify)(context.getTestConfig(), null, 2)}
+\`\`\`
+  `;
+}
+function generateReadConfigFileReport(context) {
+    const configFileInfo = context.getValue(exports.DEBUG_SCOPES.CompilerOptionsReadConfigFile);
+    if (!configFileInfo)
+        return "";
+    return `
+### Read Config File
+
+\`\`\`js
+// ${configFileInfo.file}
+${(0, stringify_config_1.default)(configFileInfo.config)}
+\`\`\`
+  `;
+}
+function generateFinalOptionsReport(context) {
+    const finalOptions = context.getCompiler().getOptions();
+    return `
+### Final Options
+
+\`\`\`js
+${(0, stringify_config_1.default)(finalOptions)}
+\`\`\`
+`;
+}
+function generateCreateCompilerInstanceReport(context) {
+    const instanceInfo = context.getValue(exports.DEBUG_SCOPES.CreateCompilerInstance);
+    if (!instanceInfo)
+        return "";
+    return `
+### Create Compiler Instance
+
+- Rspack Path: ${instanceInfo.path}
+- Callback Mode: ${instanceInfo.mode}
+`;
+}
+function generateCreateCompilerSetPropertiesReport(context) {
+    const setPropertiesInfo = context.getValue(exports.DEBUG_SCOPES.CreateCompilerSetProperties);
+    if (!setPropertiesInfo || setPropertiesInfo.length === 0)
+        return "";
+    return `
+### Set Properties
+
+${setPropertiesInfo.map(p => `- ${p}`).join("\n")}
+`;
+}
+function generateBuildMethodReport(context) {
+    const buildMethod = context.getValue(exports.DEBUG_SCOPES.BuildMethod);
+    if (!buildMethod)
+        return "";
+    return `
+### Build Method
+
+- Method: \`compiler.${buildMethod.method}()\`
+${buildMethod.options ? `- Options:\n\`\`\`js\n${(0, javascript_stringify_1.stringify)(buildMethod.options, null, 2)}\n\`\`\`` : ""}
+`;
+}
+function generateBuildErrorReport(context) {
+    const buildError = context.getValue(exports.DEBUG_SCOPES.BuildError);
+    if (!buildError)
+        return "";
+    return `
+### Build Error
+
+type: ${buildError.type}
+
+${buildError.errors.map(e => `\`\`\`\n// message:\n${e.message}\n// stack:\n${e.stack}\n\`\`\``).join("\n\n")}
+`;
+}
+function generateBuildWarningReport(context) {
+    const buildWarning = context.getValue(exports.DEBUG_SCOPES.BuildWarning);
+    if (!buildWarning)
+        return "";
+    return `
+### Build Warning
+
+${buildWarning.map(w => `\`\`\`\n// message:\n${w.message}\n// stack:\n${w.stack}\n\`\`\``).join("\n\n")}
+`;
+}
+function generateRunFindBundleReport(context) {
+    const runFindBundle = context.getValue(exports.DEBUG_SCOPES.RunFindBundle);
+    if (!runFindBundle)
+        return "";
+    return `
+### Find Bundle
+
+${runFindBundle.map(b => `- ${context.getDist(b)}`).join("\n")}
+`;
+}
+function generateRunGetRunnerReport(context) {
+    const getRunnerInfo = context.getValue(exports.DEBUG_SCOPES.RunGetRunner);
+    if (!getRunnerInfo)
+        return "";
+    return `
+### Get Runner
+
+${Object.entries(getRunnerInfo)
+        .map(([file, info]) => `- ${file}: ${info.runnerKey} (Reused: ${info.reused}, Type: \`${info.runnerType}\`)`)
+        .join("\n")}
+`;
+}
+function generateRunLogsReport(context) {
+    const runLogs = context.getValue(exports.DEBUG_SCOPES.RunLogs);
+    if (!runLogs)
+        return "";
+    return `
+### Run Logs
+
+${runLogs.map(l => `- ${l}`).join("\n")}
+`;
+}
+function generateRunErrorsReport(context) {
+    const runErrors = context.getValue(exports.DEBUG_SCOPES.RunErrors);
+    if (!runErrors)
+        return "";
+    return `
+### Run Errors
+
+${runErrors.map(e => `\`\`\`\n// message:\n${e.message}\n// stack:\n${e.stack}\n\`\`\``).join("\n\n")}
+`;
+}
+exports.DEBUG_SCOPES = {
+    CompilerOptionsReadConfigFile: "compiler-options:read-config-file",
+    CompilerOptionsFinalOptions: "compiler-options:final-options",
+    CreateCompilerInstance: "create-compiler:instance",
+    CreateCompilerSetProperties: "create-compiler:set-properties",
+    BuildMethod: "build:method",
+    BuildError: "build:error",
+    BuildWarning: "build:warning",
+    RunFindBundle: "run:find-bundle",
+    RunGetRunner: "run:get-runner",
+    RunLogs: "run:logs",
+    RunErrors: "run:errors"
+};

package/dist/test/tester.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tester = void 0;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const context_1 = require("./context");
+const debug_1 = require("./debug");
 class Tester {
     constructor(config) {
         this.config = config;
@@ -20,7 +21,7 @@ class Tester {
         this.total = config.steps?.length || 0;
         if (config.contextValue) {
             for (const [key, value] of Array.from(Object.entries(config.contextValue))) {
-                this.context.setValue(config.name, key, value);
+                this.context.setValue(key, value);
             }
         }
     }
@@ -79,11 +80,19 @@ class Tester {
             }
         }
         try {
-            await this.context.closeCompiler(this.config.name);
+            await this.context.closeCompiler();
         }
         catch (e) {
             console.warn(`Error occured while closing compilers of '${this.config.name}':\n${e.stack}`);
         }
+        if (__DEBUG__) {
+            try {
+                (0, debug_1.generateDebugReport)(this.context);
+            }
+            catch (e) {
+                console.warn(`Generate debug report failed: ${e.message}`);
+            }
+        }
     }
     async runStepMethods(step, methods, force = false) {
         for (const i of methods) {
@@ -94,7 +103,7 @@ class Tester {
                     await step[i](this.context);
                 }
                 catch (e) {
-                    this.context.emitError(this.config.name, e);
+                    this.context.emitError(e);
                 }
             }
         }
@@ -108,7 +117,7 @@ class Tester {
             }
         }
         catch (e) {
-            const errors = this.context.getError(this.config.name);
+            const errors = this.context.getError();
             console.error(new Error([...errors, e].map(e => e.message).join("\n")));
             throw e;
         }

package/dist/type.d.ts

@@ -4,17 +4,16 @@ export interface ITestContext {
     getSource(sub?: string): string;
     getDist(sub?: string): string;
     getTemp(sub?: string): string | null;
-    getCompiler(name: string): ITestCompilerManager;
-    closeCompiler(name: string): Promise<void>;
+    getCompiler(): ITestCompilerManager;
+    closeCompiler(): Promise<void>;
     getTestConfig(): TTestConfig;
-    getRunner(name: string, file: string, env: ITestEnv): ITestRunner;
-    setValue<T>(name: string, key: string, value: T): void;
-    getValue<T>(name: string, key: string): T | void;
-    getNames(): string[];
-    hasError(name?: string): boolean;
-    emitError(name: string, err: Error | string): void;
-    getError(name?: string): Error[];
-    clearError(name?: string): void;
+    getRunner(file: string, env: ITestEnv): ITestRunner;
+    setValue<T>(key: string, value: T): void;
+    getValue<T>(key: string): T | void;
+    hasError(): boolean;
+    emitError(err: Error | string): void;
+    getError(): Error[];
+    clearError(): void;
 }
 export interface ITestCompilerManager {
     getOptions(): RspackOptions;
@@ -189,6 +188,7 @@ export type TTestRunnerCreator = {
     runner: (context: ITestContext, name: string, file: string, env: ITestEnv) => ITestRunner;
 };
 declare global {
+    var __DEBUG__: boolean;
     var __TEST_PATH__: string;
     var __TEST_FIXTURES_PATH__: string;
     var __TEST_DIST_PATH__: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack-canary/test-tools",
-  "version": "1.6.0-canary-e28e40e9-20251022173516",
+  "version": "1.6.0-canary-941e2203-20251024173714",
   "license": "MIT",
   "description": "Test tools for rspack",
   "main": "dist/index.js",
@@ -45,6 +45,7 @@
     "filenamify": "4.3.0",
     "fs-extra": "^11.3.2",
     "iconv-lite": "^0.6.3",
+    "javascript-stringify": "^2.1.0",
     "jest-diff": "^29.7.0",
     "jest-snapshot": "29.7.0",
     "jest-environment-node": "29.7.0",
@@ -67,7 +68,7 @@
     "@types/jsdom": "^21.1.7",
     "typescript": "^5.9.3",
     "wast-loader": "^1.14.1",
-    "@rspack/core": "npm:@rspack-canary/core@1.6.0-canary-e28e40e9-20251022173516"
+    "@rspack/core": "npm:@rspack-canary/core@1.6.0-canary-941e2203-20251024173714"
   },
   "peerDependencies": {
     "@rspack/core": ">=1.0.0"