@rspack-canary/test-tools 1.5.6-canary-95c56d3d-20250917183900 → 1.5.6-canary-54864f9e-20250919065011

package/dist/case/hot-step.js

@@ -20,7 +20,7 @@ function getCreator(target) {
                     configFiles: ["rspack.config.js", "webpack.config.js"]
                 })
             ],
-            runner: runner_1.HotStepRunnerFactory,
+            runner: runner_1.HotRunnerFactory,
             concurrent: true
         }));
     }

package/dist/case/normal.js

@@ -27,7 +27,7 @@ const createCaseOptions = (hot) => {
                 compilerType: type_1.ECompilerType.Rspack
             })
         ],
-        runner: runner_1.NormalRunnerFactory,
+        runner: runner_1.BasicRunnerFactory,
         concurrent: true
     };
 };

package/dist/case/stats-output.js

@@ -10,6 +10,7 @@ const creator = new creator_1.BasicCaseCreator({
     steps: ({ name }) => [
         new stats_1.StatsProcessor({
             name,
+            snapshotName: "stats.txt",
             writeStatsOuptut: false,
             compilerType: type_1.ECompilerType.Rspack,
             configFiles: ["rspack.config.js", "webpack.config.js"]

package/dist/helper/directory.js

@@ -54,7 +54,7 @@ function describeByWalk(testFile, createCase, options = {}) {
                 describeDirectory(caseName, currentLevel - 1);
             }
             else {
-                const name = (0, _1.escapeSep)(node_path_1.default.join(testId, caseName).split(".").shift());
+                const name = (0, _1.escapeSep)(node_path_1.default.join(`${testId}Cases`, caseName).split(".").shift());
                 describeFn(name, () => {
                     const source = node_path_1.default.join(sourceBase, caseName);
                     let dist = "";

package/dist/processor/stats.d.ts

@@ -1,12 +1,12 @@
 import type { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
 import { type IMultiTaskProcessorOptions, MultiTaskProcessor } from "./multi";
 export interface IStatsProcessorOptions<T extends ECompilerType> extends Omit<IMultiTaskProcessorOptions<T>, "runable"> {
-    snapshotName?: string;
+    snapshotName: string;
     writeStatsOuptut?: boolean;
 }
 export declare class StatsProcessor<T extends ECompilerType> extends MultiTaskProcessor<T> {
     private stderr;
-    private snapshotName?;
+    private snapshotName;
     private writeStatsOuptut?;
     constructor(_statsOptions: IStatsProcessorOptions<T>);
     before(context: ITestContext): Promise<void>;

package/dist/processor/stats.js

@@ -137,12 +137,10 @@ class StatsProcessor extends multi_1.MultiTaskProcessor {
                 // CHANGE: Replace bundle size, since bundle sizes may differ between platforms
                 .replace(/[0-9]+\.?[0-9]+ KiB/g, "xx KiB");
         }
-        if (this.snapshotName) {
-            env.expect(new RspackStats(actual)).toMatchSnapshot(this.snapshotName);
-        }
-        else {
-            env.expect(new RspackStats(actual)).toMatchSnapshot();
-        }
+        const snapshotPath = node_path_1.default.isAbsolute(this.snapshotName)
+            ? this.snapshotName
+            : node_path_1.default.resolve(context.getSource(), `./__snapshots__/${this.snapshotName}`);
+        env.expect(new RspackStats(actual)).toMatchFileSnapshot(snapshotPath);
         const testConfig = context.getTestConfig();
         if (typeof testConfig?.validate === "function") {
             testConfig.validate(stats, this.stderr.toString());

package/dist/runner/basic.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BasicRunnerFactory = void 0;
 const type_1 = require("../type");
-const esm_1 = require("./runner/esm");
+const node_1 = require("./runner/node");
 const web_1 = require("./runner/web");
 class BasicRunnerFactory {
     constructor(name, context) {
@@ -40,6 +40,8 @@ class BasicRunnerFactory {
     }
     createRunner(file, stats, compilerOptions, env) {
         const runnerOptions = {
+            runInNewContext: false,
+            cachable: true,
             env,
             stats,
             name: this.name,
@@ -53,11 +55,10 @@ class BasicRunnerFactory {
             return new web_1.WebRunner({
                 ...runnerOptions,
                 runInNewContext: true,
-                cachable: true,
                 dom: this.context.getValue(this.name, "documentType") || type_1.EDocumentType.Fake
             });
         }
-        return new esm_1.EsmRunner(runnerOptions);
+        return new node_1.NodeRunner(runnerOptions);
     }
 }
 exports.BasicRunnerFactory = BasicRunnerFactory;

package/dist/runner/hot.js

@@ -26,6 +26,12 @@ class HotRunnerFactory extends basic_1.BasicRunnerFactory {
                 const jsonStats = stats.toJson({
                 // errorDetails: true
                 });
+                const checker = this.context.getValue(this.name, jsonStats.errors?.length
+                    ? "hotUpdateStepErrorChecker"
+                    : "hotUpdateStepChecker");
+                if (checker) {
+                    checker(hotUpdateContext, stats, runner.getGlobal("__HMR_UPDATED_RUNTIME__"));
+                }
                 await (0, checkArrayExpectation_1.default)(source, jsonStats, "error", `errors${hotUpdateContext.updateIndex}`, "Error");
                 await (0, checkArrayExpectation_1.default)(source, jsonStats, "warning", `warnings${hotUpdateContext.updateIndex}`, "Warning");
                 if (usePromise) {
@@ -54,7 +60,7 @@ class HotRunnerFactory extends basic_1.BasicRunnerFactory {
             }
             return jsonStats;
         };
-        return new web_1.WebRunner({
+        const runner = new web_1.WebRunner({
             dom: this.context.getValue(this.name, "documentType") || type_1.EDocumentType.JSDOM,
             env,
             stats: this.createStatsGetter(),
@@ -78,6 +84,7 @@ class HotRunnerFactory extends basic_1.BasicRunnerFactory {
             dist,
             compilerOptions
         });
+        return runner;
     }
 }
 exports.HotRunnerFactory = HotRunnerFactory;

package/dist/runner/index.d.ts

@@ -1,9 +1,7 @@
 export * from "./basic";
 export * from "./cache";
 export * from "./hot";
-export * from "./hot-step";
 export * from "./multiple";
-export * from "./normal";
-export * from "./runner";
+export * from "./runner/node";
 export * from "./type";
 export * from "./watch";

package/dist/runner/index.js

@@ -17,9 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./basic"), exports);
 __exportStar(require("./cache"), exports);
 __exportStar(require("./hot"), exports);
-__exportStar(require("./hot-step"), exports);
 __exportStar(require("./multiple"), exports);
-__exportStar(require("./normal"), exports);
-__exportStar(require("./runner"), exports);
+__exportStar(require("./runner/node"), exports);
 __exportStar(require("./type"), exports);
 __exportStar(require("./watch"), exports);

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

@@ -1,8 +1,2 @@
-export * from "./basic";
-export * from "./cjs";
-export * from "./esm";
-export * from "./normal";
-export * from "./watch";
+export * from "./node";
 export * from "./web";
-export * from "./web/fake";
-export * from "./web/jsdom";

package/dist/runner/runner/index.js

@@ -14,11 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./basic"), exports);
-__exportStar(require("./cjs"), exports);
-__exportStar(require("./esm"), exports);
-__exportStar(require("./normal"), exports);
-__exportStar(require("./watch"), exports);
+__exportStar(require("./node"), exports);
 __exportStar(require("./web"), exports);
-__exportStar(require("./web/fake"), exports);
-__exportStar(require("./web/jsdom"), exports);

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

@@ -0,0 +1,38 @@
+import type { ECompilerType, ITestEnv, ITestRunner, TCompilerOptions, TCompilerStatsCompilation, TTestConfig } from "../../../type";
+import { type IGlobalContext, type IModuleScope, type TModuleObject, type TRunnerFile, type TRunnerRequirer } from "../../type";
+declare global {
+    var printLogger: boolean;
+}
+export interface INodeRunnerOptions<T extends ECompilerType> {
+    env: ITestEnv;
+    stats?: () => TCompilerStatsCompilation<T>;
+    name: string;
+    runInNewContext?: boolean;
+    testConfig: TTestConfig<T>;
+    source: string;
+    dist: string;
+    compilerOptions: TCompilerOptions<T>;
+    cachable?: boolean;
+}
+export declare class NodeRunner<T extends ECompilerType = ECompilerType.Rspack> implements ITestRunner {
+    protected _options: INodeRunnerOptions<T>;
+    protected requireCache: any;
+    protected globalContext: IGlobalContext | null;
+    protected baseModuleScope: IModuleScope | null;
+    protected requirers: Map<string, TRunnerRequirer>;
+    constructor(_options: INodeRunnerOptions<T>);
+    run(file: string): Promise<unknown>;
+    getRequire(): TRunnerRequirer;
+    getGlobal(name: string): unknown;
+    protected createGlobalContext(): IGlobalContext;
+    protected createBaseModuleScope(): IModuleScope;
+    protected createModuleScope(requireFn: TRunnerRequirer, m: TModuleObject, file: TRunnerFile): IModuleScope;
+    protected getFile(modulePath: string[] | string, currentDirectory: string): TRunnerFile | null;
+    protected preExecute(code: string, file: TRunnerFile): void;
+    protected postExecute(m: Object, file: TRunnerFile): void;
+    protected createRunner(): void;
+    protected createMissRequirer(): TRunnerRequirer;
+    protected createJsonRequirer(): TRunnerRequirer;
+    protected createCjsRequirer(): TRunnerRequirer;
+    protected createEsmRequirer(): TRunnerRequirer;
+}

package/dist/runner/runner/node/index.js

@@ -0,0 +1,396 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+const node_vm_1 = __importStar(require("node:vm"));
+const asModule_1 = __importDefault(require("../../../helper/legacy/asModule"));
+const urlToRelativePath_1 = __importDefault(require("../../../helper/legacy/urlToRelativePath"));
+const type_1 = require("../../type");
+const isRelativePath = (p) => /^\.\.?\//.test(p);
+const getSubPath = (p) => {
+    const lastSlash = p.lastIndexOf("/");
+    let firstSlash = p.indexOf("/");
+    if (lastSlash !== -1 && firstSlash !== lastSlash) {
+        if (firstSlash !== -1) {
+            let next = p.indexOf("/", firstSlash + 1);
+            let dir = p.slice(firstSlash + 1, next);
+            while (dir === ".") {
+                firstSlash = next;
+                next = p.indexOf("/", firstSlash + 1);
+                dir = p.slice(firstSlash + 1, next);
+            }
+        }
+        return p.slice(firstSlash + 1, lastSlash + 1);
+    }
+    return "";
+};
+const cached = new Map();
+class NodeRunner {
+    constructor(_options) {
+        this._options = _options;
+        this.requireCache = Object.create(null);
+        this.globalContext = null;
+        this.baseModuleScope = null;
+        this.requirers = new Map();
+    }
+    run(file) {
+        if (!this.globalContext) {
+            this.globalContext = this.createGlobalContext();
+        }
+        this.baseModuleScope = this.createBaseModuleScope();
+        if (typeof this._options.testConfig.moduleScope === "function") {
+            this._options.testConfig.moduleScope(this.baseModuleScope, this._options.stats, this._options.compilerOptions);
+        }
+        this.createRunner();
+        const res = this.getRequire()(this._options.dist, file.startsWith("./") || file.startsWith("https://test.cases/")
+            ? file
+            : `./${file}`);
+        if (typeof res === "object" && "then" in res) {
+            return res;
+        }
+        return Promise.resolve(res);
+    }
+    getRequire() {
+        const entryRequire = this.requirers.get("entry");
+        return (currentDirectory, modulePath, context = {}) => {
+            const p = Array.isArray(modulePath)
+                ? modulePath
+                : modulePath.split("?")[0];
+            return entryRequire(currentDirectory, p, context);
+        };
+    }
+    getGlobal(name) {
+        return (this.globalContext || {})[name];
+    }
+    createGlobalContext() {
+        return {
+            console: {
+                log: (...args) => {
+                    if (printLogger) {
+                        console.log(...args);
+                    }
+                },
+                warn: (...args) => {
+                    if (printLogger) {
+                        console.warn(...args);
+                    }
+                },
+                error: (...args) => {
+                    console.error(...args);
+                },
+                info: (...args) => {
+                    if (printLogger) {
+                        console.info(...args);
+                    }
+                },
+                debug: (...args) => {
+                    if (printLogger) {
+                        console.info(...args);
+                    }
+                },
+                trace: (...args) => {
+                    if (printLogger) {
+                        console.info(...args);
+                    }
+                },
+                assert: (...args) => {
+                    console.assert(...args);
+                },
+                clear: () => {
+                    console.clear();
+                }
+            },
+            setTimeout: ((cb, ms, ...args) => {
+                const timeout = setTimeout(cb, ms, ...args);
+                timeout.unref();
+                return timeout;
+            }),
+            clearTimeout: clearTimeout
+        };
+    }
+    createBaseModuleScope() {
+        const baseModuleScope = {
+            console: this.globalContext.console,
+            setTimeout: this.globalContext.setTimeout,
+            clearTimeout: this.globalContext.clearTimeout,
+            nsObj: (m) => {
+                Object.defineProperty(m, Symbol.toStringTag, {
+                    value: "Module"
+                });
+                return m;
+            },
+            process,
+            URL,
+            Blob,
+            Symbol,
+            Buffer,
+            setImmediate,
+            __MODE__: this._options.compilerOptions.mode,
+            __SNAPSHOT__: node_path_1.default.join(this._options.source, "__snapshot__"),
+            ...this._options.env
+        };
+        return baseModuleScope;
+    }
+    createModuleScope(requireFn, m, file) {
+        const requirer = requireFn.bind(null, node_path_1.default.dirname(file.path));
+        requirer.webpackTestSuiteRequire = true;
+        return {
+            ...this.baseModuleScope,
+            require: requirer,
+            module: m,
+            exports: m.exports,
+            __dirname: node_path_1.default.dirname(file.path),
+            __filename: file.path,
+            _globalAssign: {
+                expect: this._options.env.expect
+            }
+        };
+    }
+    getFile(modulePath, currentDirectory) {
+        const cacheKey = `${currentDirectory}|${modulePath}`;
+        if (this._options.cachable && cached.has(cacheKey)) {
+            return cached.get(cacheKey);
+        }
+        let res = null;
+        if (Array.isArray(modulePath)) {
+            res = {
+                path: node_path_1.default.join(currentDirectory, ".array-require.js"),
+                content: `module.exports = (${modulePath
+                    .map(arg => {
+                    return `require(${JSON.stringify(`./${arg}`)})`;
+                })
+                    .join(", ")});`,
+                subPath: ""
+            };
+        }
+        else if (modulePath.startsWith("https://test.cases/")) {
+            const relativePath = (0, urlToRelativePath_1.default)(modulePath);
+            const absPath = node_path_1.default.join(currentDirectory, relativePath);
+            res = {
+                path: absPath,
+                content: node_fs_1.default.readFileSync(absPath, "utf-8"),
+                subPath: ""
+            };
+        }
+        else if (isRelativePath(modulePath)) {
+            const p = node_path_1.default.join(currentDirectory, modulePath);
+            res = {
+                path: p,
+                content: node_fs_1.default.readFileSync(p, "utf-8"),
+                subPath: getSubPath(modulePath)
+            };
+        }
+        else if (node_path_1.default.isAbsolute(modulePath)) {
+            res = {
+                path: modulePath,
+                content: node_fs_1.default.readFileSync(modulePath, "utf-8"),
+                subPath: "absolute_path"
+            };
+        }
+        if (this._options.cachable && res) {
+            cached.set(cacheKey, res);
+        }
+        return res;
+    }
+    preExecute(code, file) { }
+    postExecute(m, file) { }
+    createRunner() {
+        this.requirers.set("cjs", this.createCjsRequirer());
+        this.requirers.set("esm", this.createEsmRequirer());
+        this.requirers.set("miss", this.createMissRequirer());
+        this.requirers.set("json", this.createJsonRequirer());
+        this.requirers.set("entry", (currentDirectory, modulePath, context) => {
+            const file = this.getFile(modulePath, currentDirectory);
+            if (!file) {
+                return this.requirers.get("miss")(currentDirectory, modulePath);
+            }
+            if (file.path.endsWith(".json")) {
+                return this.requirers.get("json")(currentDirectory, modulePath, {
+                    ...context,
+                    file
+                });
+            }
+            if (file.path.endsWith(".mjs") &&
+                this._options.compilerOptions.experiments?.outputModule) {
+                return this.requirers.get("esm")(currentDirectory, modulePath, {
+                    ...context,
+                    file
+                });
+            }
+            return this.requirers.get("cjs")(currentDirectory, modulePath, {
+                ...context,
+                file
+            });
+        });
+    }
+    createMissRequirer() {
+        return (currentDirectory, modulePath, context = {}) => {
+            const modulePathStr = modulePath;
+            const modules = this._options.testConfig.modules;
+            if (modules && modulePathStr in modules) {
+                return modules[modulePathStr];
+            }
+            return require(modulePathStr.startsWith("node:")
+                ? modulePathStr.slice(5)
+                : modulePathStr);
+        };
+    }
+    createJsonRequirer() {
+        return (currentDirectory, modulePath, context = {}) => {
+            if (Array.isArray(modulePath)) {
+                throw new Error("Array module path is not supported in hot cases");
+            }
+            const file = context.file || this.getFile(modulePath, currentDirectory);
+            if (!file) {
+                return this.requirers.get("miss")(currentDirectory, modulePath);
+            }
+            return JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(this._options.dist, modulePath), "utf-8"));
+        };
+    }
+    createCjsRequirer() {
+        return (currentDirectory, modulePath, context = {}) => {
+            if (modulePath === "@rspack/test-tools") {
+                return require("@rspack/test-tools");
+            }
+            const file = context.file || this.getFile(modulePath, currentDirectory);
+            if (!file) {
+                return this.requirers.get("miss")(currentDirectory, modulePath);
+            }
+            if (file.path in this.requireCache) {
+                return this.requireCache[file.path].exports;
+            }
+            const m = {
+                exports: {},
+                webpackTestSuiteModule: true
+            };
+            this.requireCache[file.path] = m;
+            if (!this._options.runInNewContext) {
+                file.content = `Object.assign(global, _globalAssign);\n ${file.content}`;
+            }
+            const currentModuleScope = this.createModuleScope(this.getRequire(), m, file);
+            if (this._options.testConfig.moduleScope) {
+                this._options.testConfig.moduleScope(currentModuleScope, this._options.stats, this._options.compilerOptions);
+            }
+            if (file.content.includes("__STATS__") && this._options.stats) {
+                currentModuleScope.__STATS__ = this._options.stats();
+            }
+            if (file.content.includes("__STATS_I__")) {
+                const statsIndex = this._options.stats?.()?.__index__;
+                if (typeof statsIndex === "number") {
+                    currentModuleScope.__STATS_I__ = statsIndex;
+                }
+            }
+            const args = Object.keys(currentModuleScope);
+            const argValues = args.map(arg => currentModuleScope[arg]);
+            const code = `(function(${args.join(", ")}) {
+        ${file.content}
+      })`;
+            this.preExecute(code, file);
+            const fn = this._options.runInNewContext
+                ? node_vm_1.default.runInNewContext(code, this.globalContext, file.path)
+                : node_vm_1.default.runInThisContext(code, file.path);
+            fn.call(this._options.testConfig.nonEsmThis
+                ? this._options.testConfig.nonEsmThis(modulePath)
+                : m.exports, ...argValues);
+            this.postExecute(m, file);
+            return m.exports;
+        };
+    }
+    createEsmRequirer() {
+        const esmContext = node_vm_1.default.createContext(this.baseModuleScope, {
+            name: "context for esm"
+        });
+        const esmCache = new Map();
+        const esmIdentifier = this._options.name;
+        return (currentDirectory, modulePath, context = {}) => {
+            if (!node_vm_1.SourceTextModule) {
+                throw new Error("Running this test requires '--experimental-vm-modules'.\nRun with 'node --experimental-vm-modules node_modules/jest-cli/bin/jest'.");
+            }
+            const _require = this.getRequire();
+            const file = context.file || this.getFile(modulePath, currentDirectory);
+            if (!file) {
+                return this.requirers.get("miss")(currentDirectory, modulePath);
+            }
+            if (file.content.includes("__STATS__")) {
+                esmContext.__STATS__ = this._options.stats?.();
+            }
+            let esm = esmCache.get(file.path);
+            if (!esm) {
+                esm = new node_vm_1.SourceTextModule(file.content, {
+                    identifier: `${esmIdentifier}-${file.path}`,
+                    // no attribute
+                    url: `${(0, node_url_1.pathToFileURL)(file.path).href}?${esmIdentifier}`,
+                    context: esmContext,
+                    initializeImportMeta: (meta, _) => {
+                        meta.url = (0, node_url_1.pathToFileURL)(file.path).href;
+                    },
+                    importModuleDynamically: async (specifier, module) => {
+                        const result = await _require(node_path_1.default.dirname(file.path), specifier, {
+                            esmMode: type_1.EEsmMode.Evaluated
+                        });
+                        return await (0, asModule_1.default)(result, module.context);
+                    }
+                });
+                esmCache.set(file.path, esm);
+            }
+            if (context.esmMode === type_1.EEsmMode.Unlinked)
+                return esm;
+            return (async () => {
+                await esm.link(async (specifier, referencingModule) => {
+                    return await (0, asModule_1.default)(await _require(node_path_1.default.dirname(referencingModule.identifier
+                        ? referencingModule.identifier.slice(esmIdentifier.length + 1)
+                        : (0, node_url_1.fileURLToPath)(referencingModule.url)), specifier, {
+                        esmMode: type_1.EEsmMode.Unlinked
+                    }), referencingModule.context, true);
+                });
+                if (esm.instantiate)
+                    esm.instantiate();
+                await esm.evaluate();
+                if (context.esmMode === type_1.EEsmMode.Evaluated) {
+                    return esm;
+                }
+                const ns = esm.namespace;
+                return ns.default && ns.default instanceof Promise ? ns.default : ns;
+            })();
+        };
+    }
+}
+exports.NodeRunner = NodeRunner;

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

@@ -1,18 +1,16 @@
 import type { ECompilerType } from "../../../type";
-import { type TBasicRunnerFile, type TRunnerRequirer } from "../../type";
-import type { IBasicRunnerOptions } from "../basic";
-import { CommonJsRunner } from "../cjs";
-export declare class FakeDocumentWebRunner<T extends ECompilerType = ECompilerType.Rspack> extends CommonJsRunner<T> {
-    protected _webOptions: IBasicRunnerOptions<T>;
+import { type TRunnerFile, type TRunnerRequirer } from "../../type";
+import { type INodeRunnerOptions, NodeRunner } from "../node";
+export declare class FakeDocumentWebRunner<T extends ECompilerType = ECompilerType.Rspack> extends NodeRunner<T> {
+    protected _webOptions: INodeRunnerOptions<T>;
     private document;
     private oldCurrentScript;
-    constructor(_webOptions: IBasicRunnerOptions<T>);
+    constructor(_webOptions: INodeRunnerOptions<T>);
     run(file: string): Promise<unknown>;
-    protected createGlobalContext(): import("../../type").IBasicGlobalContext;
-    protected createModuleScope(requireFn: TRunnerRequirer, m: any, file: TBasicRunnerFile): import("../../type").IBasicModuleScope;
-    protected createBaseModuleScope(): import("../../type").IBasicModuleScope;
-    protected createRunner(): void;
-    protected preExecute(_: string, file: TBasicRunnerFile): void;
-    protected postExecute(_: Object, file: TBasicRunnerFile): void;
-    private createESMRequirer;
+    protected createGlobalContext(): import("../../type").IGlobalContext;
+    protected createModuleScope(requireFn: TRunnerRequirer, m: any, file: TRunnerFile): import("../../type").IModuleScope;
+    protected createBaseModuleScope(): import("../../type").IModuleScope;
+    protected preExecute(_: string, file: TRunnerFile): void;
+    protected postExecute(_: Object, file: TRunnerFile): void;
+    protected createEsmRequirer(): TRunnerRequirer;
 }