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

package/dist/case/stats-api.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStatsAPICase = createStatsAPICase;
 const memfs_1 = require("memfs");
 const creator_1 = require("../test/creator");
-const common_1 = require("./common");
 let addedSerializer = false;
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
@@ -13,16 +12,16 @@ const creator = new creator_1.BasicCaseCreator({
         return [
             {
                 config: async (context) => {
-                    const compiler = (0, common_1.getCompiler)(context, name);
+                    const compiler = context.getCompiler();
                     compiler.setOptions(options(context, config.options));
                 },
                 compiler: async (context) => {
-                    const compilerManager = (0, common_1.getCompiler)(context, name);
+                    const compilerManager = context.getCompiler();
                     compilerManager.createCompiler();
                     compiler(context, compilerManager.getCompiler(), config.compiler);
                 },
                 build: async (context) => {
-                    const compiler = (0, common_1.getCompiler)(context, name);
+                    const compiler = context.getCompiler();
                     if (typeof config.build === "function") {
                         await config.build(context, compiler.getCompiler());
                     }
@@ -74,7 +73,7 @@ async function compiler(context, compiler, custom) {
     }
 }
 async function check(env, context, name, custom) {
-    const manager = (0, common_1.getCompiler)(context, name);
+    const manager = context.getCompiler();
     const stats = manager.getStats();
     env.expect(typeof stats).toBe("object");
     await custom?.(stats, manager.getCompiler());

package/dist/case/stats-output.js

@@ -114,7 +114,7 @@ class RspackStats {
     }
 }
 async function check(env, context, name, writeStatsOuptut, snapshot, stderr) {
-    const compiler = (0, common_1.getCompiler)(context, name);
+    const compiler = context.getCompiler();
     const options = compiler.getOptions();
     const stats = compiler.getStats();
     if (!stats || !compiler)

package/dist/case/treeshaking.js

@@ -13,7 +13,7 @@ const creator = new creator_1.BasicCaseCreator({
     steps: ({ name }) => [
         {
             config: async (context) => {
-                const compiler = (0, common_1.getCompiler)(context, name);
+                const compiler = context.getCompiler();
                 const options = (0, builtin_1.defaultOptions)(context);
                 overrideOptions(context, options);
                 compiler.setOptions(options);

package/dist/case/watch.js

@@ -29,7 +29,7 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
     };
     return {
         before: async (context) => {
-            context.setValue(name, "watchContext", watchContext);
+            context.setValue("watchContext", watchContext);
         },
         config: async (context) => {
             const testConfig = context.getTestConfig();
@@ -46,9 +46,9 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
             const compilerOptions = multiCompilerOptions.length === 1
                 ? multiCompilerOptions[0]
                 : multiCompilerOptions;
-            const compiler = (0, common_1.getCompiler)(context, name);
+            const compiler = context.getCompiler();
             compiler.setOptions(compilerOptions);
-            context.setValue(name, "multiCompilerOptions", multiCompilerOptions);
+            context.setValue("multiCompilerOptions", multiCompilerOptions);
         },
         compiler: async (context) => {
             const c = await (0, common_1.compiler)(context, name);
@@ -57,7 +57,7 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
             });
         },
         build: async (context) => {
-            const compiler = (0, common_1.getCompiler)(context, name);
+            const compiler = context.getCompiler();
             node_fs_1.default.mkdirSync(watchContext.tempDir, { recursive: true });
             (0, copyDiff_1.default)(node_path_1.default.join(context.getSource(), watchContext.step), watchContext.tempDir, true);
             const task = new Promise((resolve, reject) => {
@@ -77,12 +77,12 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
             const testConfig = context.getTestConfig();
             if (testConfig.noTests)
                 return;
-            const errors = (context.getError(name) || []).map(e => ({
+            const errors = (context.getError() || []).map(e => ({
                 message: e.message,
                 stack: e.stack
             }));
             const warnings = [];
-            const compiler = (0, common_1.getCompiler)(context, name);
+            const compiler = context.getCompiler();
             const stats = compiler.getStats();
             const options = compiler.getOptions();
             const checkStats = testConfig.checkStats || (() => true);
@@ -148,7 +148,7 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
             await (0, checkArrayExpectation_1.default)(node_path_1.default.join(context.getSource(), watchContext.step), { warnings }, "warning", "warnings", "Warning", options);
             // clear error if checked
             if (node_fs_1.default.existsSync(context.getSource("errors.js"))) {
-                context.clearError(name);
+                context.clearError();
             }
             // check hash
             if (testConfig.writeStatsOuptut) {
@@ -169,7 +169,7 @@ function createWatchStepProcessor(name, tempDir, step, watchState, { incremental
         // do nothing
     };
     processor.build = async (context) => {
-        const compiler = (0, common_1.getCompiler)(context, name);
+        const compiler = context.getCompiler();
         const task = new Promise((resolve, reject) => {
             compiler.getEmitter().once(compiler_1.ECompilerEvent.Build, (e, stats) => {
                 if (e)
@@ -283,13 +283,13 @@ function defaultOptions({ incremental = false, ignoreNotFriendlyForIncrementalWa
     return {};
 }
 function getWatchRunnerKey(context, name, file) {
-    const watchContext = context.getValue(name, "watchContext");
+    const watchContext = context.getValue("watchContext");
     const stepName = watchContext?.step;
     return `${name}-${stepName}`;
 }
 function cachedWatchStats(context, name) {
-    const compiler = context.getCompiler(name);
-    const watchContext = context.getValue(name, "watchContext");
+    const compiler = context.getCompiler();
+    const watchContext = context.getValue("watchContext");
     const stepName = watchContext?.step;
     const statsGetter = (() => {
         const cached = {};
@@ -306,9 +306,9 @@ function cachedWatchStats(context, name) {
     return statsGetter;
 }
 function createWatchRunner(context, name, file, env) {
-    const compiler = context.getCompiler(name);
+    const compiler = context.getCompiler();
     const compilerOptions = compiler.getOptions();
-    const watchContext = context.getValue(name, "watchContext");
+    const watchContext = context.getValue("watchContext");
     const stepName = watchContext?.step;
     if (!stepName) {
         throw new Error("Can not get watch step name from context");

package/dist/compiler.d.ts

@@ -1,6 +1,6 @@
 import EventEmitter from "node:events";
-import type { Compiler, RspackOptions, Stats } from "@rspack/core";
-import type { ITestCompilerManager } from "./type";
+import { Compiler, type RspackOptions, type Stats } from "@rspack/core";
+import type { ITestCompilerManager, ITestContext } from "./type";
 export declare enum ECompilerEvent {
     Build = "build",
     Option = "option",
@@ -8,11 +8,12 @@ export declare enum ECompilerEvent {
     Close = "close"
 }
 export declare class TestCompilerManager implements ITestCompilerManager {
+    protected context: ITestContext;
     protected compilerOptions: RspackOptions;
     protected compilerInstance: Compiler | null;
     protected compilerStats: Stats | null;
     protected emitter: EventEmitter;
-    constructor();
+    constructor(context: ITestContext);
     getOptions(): RspackOptions;
     setOptions(newOptions: RspackOptions): RspackOptions;
     mergeOptions(newOptions: RspackOptions): RspackOptions;

package/dist/compiler.js

@@ -5,7 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestCompilerManager = exports.ECompilerEvent = void 0;
 const node_events_1 = __importDefault(require("node:events"));
+const core_1 = require("@rspack/core");
 const webpack_merge_1 = __importDefault(require("webpack-merge"));
+const debug_1 = require("./test/debug");
 var ECompilerEvent;
 (function (ECompilerEvent) {
     ECompilerEvent["Build"] = "build";
@@ -14,7 +16,8 @@ var ECompilerEvent;
     ECompilerEvent["Close"] = "close";
 })(ECompilerEvent || (exports.ECompilerEvent = ECompilerEvent = {}));
 class TestCompilerManager {
-    constructor() {
+    constructor(context) {
+        this.context = context;
         this.compilerOptions = {};
         this.compilerInstance = null;
         this.compilerStats = null;
@@ -38,11 +41,57 @@ class TestCompilerManager {
     }
     createCompiler() {
         this.compilerInstance = require("@rspack/core")(this.compilerOptions);
+        if (__DEBUG__) {
+            const context = this.context;
+            this.compilerInstance = new Proxy(this.compilerInstance, {
+                get(target, p, receiver) {
+                    const value = Reflect.get(target, p, receiver);
+                    if (typeof value === "function" &&
+                        core_1.Compiler.prototype.hasOwnProperty(p)) {
+                        return value.bind(target);
+                    }
+                    return value;
+                },
+                set(target, p, value, receiver) {
+                    const debugSetProperties = context.getValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties) || [];
+                    debugSetProperties.push(`${p} ${new Error().stack?.split("\n")[2]?.trim()}`);
+                    context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties, debugSetProperties);
+                    return Reflect.set(target, p, value, receiver);
+                }
+            });
+            this.context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerInstance, {
+                path: require.resolve("@rspack/core"),
+                mode: "no-callback"
+            });
+        }
         this.emitter.emit(ECompilerEvent.Create, this.compilerInstance);
         return this.compilerInstance;
     }
     createCompilerWithCallback(callback) {
         this.compilerInstance = require("@rspack/core")(this.compilerOptions, callback);
+        if (__DEBUG__) {
+            const context = this.context;
+            this.compilerInstance = new Proxy(this.compilerInstance, {
+                get(target, p, receiver) {
+                    const value = Reflect.get(target, p, receiver);
+                    if (typeof value === "function" &&
+                        core_1.Compiler.prototype.hasOwnProperty(p)) {
+                        return value.bind(target);
+                    }
+                    return value;
+                },
+                set(target, p, value, receiver) {
+                    const debugSetProperties = context.getValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties) || [];
+                    debugSetProperties.push(`${p} ${new Error().stack?.split("\n")[2]?.trim()}`);
+                    context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties, debugSetProperties);
+                    return Reflect.set(target, p, value, receiver);
+                }
+            });
+            this.context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerInstance, {
+                path: require.resolve("@rspack/core"),
+                mode: "callback"
+            });
+        }
         this.emitter.emit(ECompilerEvent.Create, this.compilerInstance);
         return this.compilerInstance;
     }
@@ -51,11 +100,39 @@ class TestCompilerManager {
             throw new Error("Compiler should be created before build");
         return new Promise((resolve, reject) => {
             try {
+                const context = this.context;
+                if (__DEBUG__) {
+                    context.setValue(debug_1.DEBUG_SCOPES.BuildMethod, {
+                        method: "run"
+                    });
+                }
                 this.compilerInstance.run((error, newStats) => {
                     this.emitter.emit(ECompilerEvent.Build, error, newStats);
-                    if (error)
+                    if (error) {
+                        if (__DEBUG__) {
+                            context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
+                                type: "fatal",
+                                errors: [error]
+                            });
+                        }
                         return reject(error);
+                    }
                     this.compilerStats = newStats;
+                    if (__DEBUG__) {
+                        if (newStats?.hasErrors()) {
+                            context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
+                                type: "stats",
+                                errors: newStats.toJson({
+                                    errors: true
+                                }).errors || []
+                            });
+                        }
+                        if (newStats?.hasWarnings()) {
+                            context.setValue(debug_1.DEBUG_SCOPES.BuildWarning, newStats.toJson({
+                                warnings: true
+                            }).warnings || []);
+                        }
+                    }
                     resolve(newStats);
                 });
             }
@@ -67,7 +144,8 @@ class TestCompilerManager {
     watch(timeout = 1000) {
         if (!this.compilerInstance)
             throw new Error("Compiler should be created before watch");
-        this.compilerInstance.watch({
+        const context = this.context;
+        const watchOptions = {
             // IMPORTANT:
             // This is a workaround for the issue that watchpack cannot detect the file change in time
             // so we set the poll to 300ms to make it more sensitive to the file change
@@ -76,11 +154,40 @@ class TestCompilerManager {
             // want to watch all files, which aligns with webpack's default behavior
             ignored: [],
             aggregateTimeout: timeout
-        }, (error, newStats) => {
+        };
+        if (__DEBUG__) {
+            context.setValue(debug_1.DEBUG_SCOPES.BuildMethod, {
+                method: "watch",
+                options: watchOptions
+            });
+        }
+        this.compilerInstance.watch(watchOptions, (error, newStats) => {
             this.emitter.emit(ECompilerEvent.Build, error, newStats);
-            if (error)
-                return error;
+            if (__DEBUG__) {
+                if (error) {
+                    context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
+                        type: "fatal",
+                        errors: [error]
+                    });
+                    return error;
+                }
+            }
             if (newStats) {
+                if (__DEBUG__) {
+                    if (newStats.hasErrors()) {
+                        context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
+                            type: "stats",
+                            errors: newStats.toJson({
+                                errors: true
+                            }).errors || []
+                        });
+                    }
+                    if (newStats.hasWarnings()) {
+                        context.setValue(debug_1.DEBUG_SCOPES.BuildWarning, newStats.toJson({
+                            warnings: true
+                        }).warnings || []);
+                    }
+                }
                 this.compilerStats = newStats;
             }
             return newStats;

package/dist/helper/index.d.ts

@@ -2,6 +2,7 @@ export * from "./directory";
 export * from "./is";
 export * from "./parse-modules";
 export * from "./read-config-file";
+export * from "./stringify-config";
 export * from "./update-snapshot";
 export * from "./util/checkStats";
 export * from "./win";

package/dist/helper/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./directory"), exports);
 __exportStar(require("./is"), exports);
 __exportStar(require("./parse-modules"), exports);
 __exportStar(require("./read-config-file"), exports);
+__exportStar(require("./stringify-config"), exports);
 __exportStar(require("./update-snapshot"), exports);
 __exportStar(require("./util/checkStats"), exports);
 __exportStar(require("./win"), exports);

package/dist/helper/read-config-file.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readConfigFile = readConfigFile;
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const debug_1 = require("../test/debug");
 function readConfigFile(files, context, prevOption, functionApply) {
     const existsFile = files.find(i => fs_extra_1.default.existsSync(i));
     let fileConfig = existsFile ? require(existsFile) : {};
@@ -12,5 +13,11 @@ function readConfigFile(files, context, prevOption, functionApply) {
         fileConfig = fileConfig({ config: prevOption }, { testPath: context.getDist(), tempPath: context.getTemp() });
     }
     const configArr = Array.isArray(fileConfig) ? fileConfig : [fileConfig];
+    if (existsFile) {
+        context.setValue(debug_1.DEBUG_SCOPES.CompilerOptionsReadConfigFile, {
+            file: existsFile,
+            config: fileConfig
+        });
+    }
     return functionApply ? functionApply(configArr) : configArr;
 }

package/dist/helper/setup-env.js

@@ -16,6 +16,7 @@ if (process.env.RSTEST) {
     global.__ROOT_PATH__ ??= process.env.__ROOT_PATH__;
     global.__RSPACK_PATH__ ??= process.env.__RSPACK_PATH__;
     global.__RSPACK_TEST_TOOLS_PATH__ ??= process.env.__RSPACK_TEST_TOOLS_PATH__;
+    global.__DEBUG__ ??= process.env.DEBUG === "test";
 }
 else {
     // Compatible with wasm tests (lazyTestEnv)

package/dist/helper/stringify-config.d.ts

@@ -0,0 +1,2 @@
+import type { RspackOptions } from "@rspack/core";
+export default function stringifyConfig(config: RspackOptions, verbose?: boolean): string | undefined;

package/dist/helper/stringify-config.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = stringifyConfig;
+const javascript_stringify_1 = require("javascript-stringify");
+function stringifyConfig(config, verbose = false) {
+    return (0, javascript_stringify_1.stringify)(config, (value, indent, stringify) => {
+        // improve plugin output
+        if (value?.__pluginName) {
+            const prefix = `/* config.${value.__pluginType}('${value.__pluginName}') */\n`;
+            const constructorExpression = value.__pluginPath
+                ? // The path is stringified to ensure special characters are escaped
+                    // (such as the backslashes in Windows-style paths).
+                    `(require(${stringify(value.__pluginPath)}))`
+                : value.__pluginConstructorName;
+            if (constructorExpression) {
+                // get correct indentation for args by stringifying the args array and
+                // discarding the square brackets.
+                const args = stringify(value.__pluginArgs)?.slice(1, -1);
+                return `${prefix}new ${constructorExpression}(${args})`;
+            }
+            return (prefix +
+                stringify(value.__pluginArgs?.length ? { args: value.__pluginArgs } : {}));
+        }
+        // improve rule/use output
+        if (value?.__ruleNames) {
+            const ruleTypes = value.__ruleTypes;
+            const prefix = `/* config.module${value.__ruleNames
+                .map((r, index) => `.${ruleTypes ? ruleTypes[index] : "rule"}('${r}')`)
+                .join("")}${value.__useName ? `.use('${value.__useName}')` : ``} */\n`;
+            return prefix + stringify(value);
+        }
+        if (value?.__expression) {
+            return value.__expression;
+        }
+        // shorten long functions
+        if (typeof value === "function") {
+            if (!verbose && value.toString().length > 100) {
+                return `function () { /* omitted long function */ }`;
+            }
+        }
+        return stringify(value);
+    }, 2);
+}

package/dist/runner/node/index.d.ts

@@ -13,6 +13,8 @@ export interface INodeRunnerOptions {
     dist: string;
     compilerOptions: RspackOptions;
     cachable?: boolean;
+    logs?: string[];
+    errors?: Error[];
 }
 export declare class NodeRunner implements ITestRunner {
     protected _options: INodeRunnerOptions;
@@ -21,6 +23,7 @@ export declare class NodeRunner implements ITestRunner {
     protected baseModuleScope: IModuleScope | null;
     protected requirers: Map<string, TRunnerRequirer>;
     constructor(_options: INodeRunnerOptions);
+    protected log(message: string): void;
     run(file: string): Promise<unknown>;
     getRequire(): TRunnerRequirer;
     getGlobal(name: string): unknown;
@@ -36,3 +39,4 @@ export declare class NodeRunner implements ITestRunner {
     protected createCjsRequirer(): TRunnerRequirer;
     protected createEsmRequirer(): TRunnerRequirer;
 }
+export declare const createLocatedError: (collectedErrors: Error[], offset: number) => (e: Error, file: TRunnerFile) => Error;

package/dist/runner/node/index.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeRunner = void 0;
+exports.createLocatedError = exports.NodeRunner = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_url_1 = require("node:url");
@@ -45,6 +45,7 @@ const asModule_1 = __importDefault(require("../../helper/legacy/asModule"));
 const createFakeWorker_1 = __importDefault(require("../../helper/legacy/createFakeWorker"));
 const urlToRelativePath_1 = __importDefault(require("../../helper/legacy/urlToRelativePath"));
 const type_1 = require("../../type");
+const EVAL_LOCATION_REGEX = /<anonymous>:(\d+)/;
 const isRelativePath = (p) => /^\.\.?\//.test(p);
 const getSubPath = (p) => {
     const lastSlash = p.lastIndexOf("/");
@@ -72,6 +73,9 @@ class NodeRunner {
         this.baseModuleScope = null;
         this.requirers = new Map();
     }
+    log(message) {
+        this._options.logs?.push(`[NodeRunner] ${message}`);
+    }
     run(file) {
         if (!this.globalContext) {
             this.globalContext = this.createGlobalContext();
@@ -93,7 +97,15 @@ class NodeRunner {
     }
     getRequire() {
         const entryRequire = this.requirers.get("entry");
-        return (currentDirectory, modulePath, context = {}) => {
+        const runner = this;
+        return function (currentDirectory, modulePath, context = {}) {
+            const from = this?.from;
+            if (from) {
+                runner.log(`require: ${modulePath} from ${from}`);
+            }
+            else {
+                runner.log(`require: ${modulePath}`);
+            }
             const p = Array.isArray(modulePath)
                 ? modulePath
                 : modulePath.split("?")[0];
@@ -177,7 +189,10 @@ class NodeRunner {
         return baseModuleScope;
     }
     createModuleScope(requireFn, m, file) {
-        const requirer = requireFn.bind(null, node_path_1.default.dirname(file.path));
+        const requirer = requireFn.bind({
+            from: file.path,
+            module: m
+        }, node_path_1.default.dirname(file.path));
         requirer.webpackTestSuiteRequire = true;
         return {
             ...this.baseModuleScope,
@@ -246,6 +261,7 @@ class NodeRunner {
         this.requirers.set("json", this.createJsonRequirer());
         this.requirers.set("entry", (currentDirectory, modulePath, context) => {
             const file = this.getFile(modulePath, currentDirectory);
+            this.log(`entry: ${modulePath} -> ${file?.path}`);
             if (!file) {
                 return this.requirers.get("miss")(currentDirectory, modulePath);
             }
@@ -270,11 +286,14 @@ class NodeRunner {
     }
     createMissRequirer() {
         return (currentDirectory, modulePath, context = {}) => {
+            this.log(`missing: ${modulePath}`);
             const modulePathStr = modulePath;
             const modules = this._options.testConfig.modules;
             if (modules && modulePathStr in modules) {
+                this.log(`mock module: ${modulePathStr}`);
                 return modules[modulePathStr];
             }
+            this.log(`native require: ${modulePathStr}`);
             return require(modulePathStr.startsWith("node:")
                 ? modulePathStr.slice(5)
                 : modulePathStr);
@@ -286,6 +305,7 @@ class NodeRunner {
                 throw new Error("Array module path is not supported in hot cases");
             }
             const file = context.file || this.getFile(modulePath, currentDirectory);
+            this.log(`json: ${modulePath} -> ${file?.path}`);
             if (!file) {
                 return this.requirers.get("miss")(currentDirectory, modulePath);
             }
@@ -298,10 +318,12 @@ class NodeRunner {
                 return require("@rspack/test-tools");
             }
             const file = context.file || this.getFile(modulePath, currentDirectory);
+            this.log(`cjs: ${modulePath} -> ${file?.path}`);
             if (!file) {
                 return this.requirers.get("miss")(currentDirectory, modulePath);
             }
             if (file.path in this.requireCache) {
+                this.log(`cjs cache hit: ${file.path}`);
                 return this.requireCache[file.path].exports;
             }
             const m = {
@@ -325,19 +347,45 @@ class NodeRunner {
                     currentModuleScope.__STATS_I__ = statsIndex;
                 }
             }
+            const createNodeLocatedError = (0, exports.createLocatedError)(this._options.errors || [], 2);
+            const originIt = currentModuleScope.it;
+            currentModuleScope.it = (description, fn) => {
+                originIt(description, async () => {
+                    try {
+                        await fn();
+                    }
+                    catch (err) {
+                        throw createNodeLocatedError(err, file);
+                    }
+                });
+            };
+            currentModuleScope.__CREATE_LOCATED_ERROR__ = createNodeLocatedError;
+            currentModuleScope.__FILE__ = file;
             const args = Object.keys(currentModuleScope);
             const argValues = args.map(arg => currentModuleScope[arg]);
             const code = `(function(${args.join(", ")}) {
-        ${file.content}
+				try {
+					${file.content}
+				} catch(err) {
+					throw __CREATE_LOCATED_ERROR__(err, __FILE__);
+				}
       })`;
             this.preExecute(code, file);
+            this.log(`run mode: ${this._options.runInNewContext ? "new context" : "this context"}`);
             const fn = this._options.runInNewContext
-                ? node_vm_1.default.runInNewContext(code, this.globalContext, file.path)
-                : node_vm_1.default.runInThisContext(code, file.path);
+                ? node_vm_1.default.runInNewContext(code, this.globalContext, {
+                    filename: file.path,
+                    lineOffset: 1
+                })
+                : node_vm_1.default.runInThisContext(code, {
+                    filename: file.path,
+                    lineOffset: 1
+                });
             fn.call(this._options.testConfig.nonEsmThis
                 ? this._options.testConfig.nonEsmThis(modulePath)
                 : m.exports, ...argValues);
             this.postExecute(m, file);
+            this.log(`end cjs: ${modulePath}`);
             return m.exports;
         };
     }
@@ -353,6 +401,7 @@ class NodeRunner {
             }
             const _require = this.getRequire();
             const file = context.file || this.getFile(modulePath, currentDirectory);
+            this.log(`esm: ${modulePath} -> ${file?.path}`);
             if (!file) {
                 return this.requirers.get("miss")(currentDirectory, modulePath);
             }
@@ -378,6 +427,7 @@ class NodeRunner {
                         meta.filename = file.path;
                     },
                     importModuleDynamically: async (specifier, module) => {
+                        this.log(`import: ${specifier} from ${file?.path}`);
                         const result = await _require(node_path_1.default.dirname(file.path), specifier, {
                             esmMode: type_1.EEsmMode.Evaluated
                         });
@@ -403,9 +453,36 @@ class NodeRunner {
                     return esm;
                 }
                 const ns = esm.namespace;
+                this.log(`end esm: ${modulePath}`);
                 return ns.default && ns.default instanceof Promise ? ns.default : ns;
             })();
         };
     }
 }
 exports.NodeRunner = NodeRunner;
+const createLocatedError = (collectedErrors, offset) => {
+    return (e, file) => {
+        const match = (e.stack || e.message).match(EVAL_LOCATION_REGEX);
+        if (match) {
+            const [, line] = match;
+            const realLine = Number(line) - offset;
+            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;
+            collectedErrors.push(finalError);
+            return finalError;
+        }
+        else {
+            return e;
+        }
+    };
+};
+exports.createLocatedError = createLocatedError;

package/dist/runner/web/index.d.ts

@@ -9,6 +9,7 @@ export declare class WebRunner extends NodeRunner {
     constructor(_webOptions: IWebRunnerOptions);
     run(file: string): Promise<unknown>;
     getGlobal(name: string): unknown;
+    protected log(message: string): void;
     protected createResourceLoader(): {
         fetch(url: string, _: {
             element: HTMLScriptElement;