@rspack-canary/test-tools 1.5.7-canary-a3406c0a-20250922173625 → 1.5.8-canary-e350b761-20250924173613

package/dist/case/hot-step.js

@@ -8,8 +8,9 @@ const node_path_1 = __importDefault(require("node:path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const helper_1 = require("../helper");
 const placeholder_1 = require("../helper/expect/placeholder");
-const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
+const type_1 = require("../type");
+const common_1 = require("./common");
 const hot_1 = require("./hot");
 const NOOP_SET = new Set();
 const escapeLocalName = (str) => str.split(/[-<>:"/|?*.]/).join("_");
@@ -261,7 +262,7 @@ ${runtime.javascript.disposedModules.map(i => `- ${i}`).join("\n")}
                             : Array.from(entry.runtime);
                 }
             }
-            const compiler = this.getCompiler(context);
+            const compiler = context.getCompiler(name, type_1.ECompilerType.Rspack);
             const compilerOptions = compiler.getOptions();
             matchStepSnapshot(env, context, hotUpdateContext.updateIndex, compilerOptions, statsJson, runtime);
             hashes.push(stats.hash);
@@ -269,10 +270,10 @@ ${runtime.javascript.disposedModules.map(i => `- ${i}`).join("\n")}
         context.setValue(name, "hotUpdateStepErrorChecker", (_, stats, runtime) => {
             hashes.push(stats.hash);
         });
-        await originRun.call(this, env, context);
+        await originRun(env, context);
     };
     processor.check = async function (env, context) {
-        const compiler = this.getCompiler(context);
+        const compiler = (0, common_1.getCompiler)(context, name);
         const stats = compiler.getStats();
         if (!stats || !stats.hash) {
             env.expect(false);
@@ -314,7 +315,10 @@ function getCreator(target) {
             steps: ({ name, target }) => [
                 createHotStepProcessor(name, target)
             ],
-            runner: runner_1.HotRunnerFactory,
+            runner: {
+                key: (context, name, file) => name,
+                runner: hot_1.createHotRunner
+            },
             concurrent: true
         }));
     }

package/dist/case/hot.d.ts

@@ -1,9 +1,9 @@
-import { BasicProcessor } from "../processor";
-import { ECompilerType, type TCompilerOptions, type THotUpdateContext } from "../type";
+import { type ECompilerType, type ITestContext, type ITestEnv, type ITestProcessor, type ITestRunner, type TCompilerOptions, type THotUpdateContext } from "../type";
 type TTarget = TCompilerOptions<ECompilerType.Rspack>["target"];
-type THotProcessor = BasicProcessor<ECompilerType.Rspack> & {
-    hotUpdateContext: THotUpdateContext;
-};
 export declare function createHotProcessor(name: string, target: TTarget, incremental?: boolean): THotProcessor;
 export declare function createHotCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"]): void;
+type THotProcessor = ITestProcessor & {
+    hotUpdateContext: THotUpdateContext;
+};
+export declare function createHotRunner<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, file: string, env: ITestEnv): ITestRunner;
 export {};

package/dist/case/hot.js

@@ -5,16 +5,84 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHotProcessor = createHotProcessor;
 exports.createHotCase = createHotCase;
+exports.createHotRunner = createHotRunner;
 const node_path_1 = __importDefault(require("node:path"));
 const core_1 = __importDefault(require("@rspack/core"));
 const helper_1 = require("../helper");
+const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
 const plugins_1 = require("../helper/plugins");
 const plugin_1 = require("../plugin");
-const processor_1 = require("../processor");
 const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
+const common_1 = require("./common");
+const runner_2 = require("./runner");
 const creators = new Map();
+function createHotProcessor(name, target, incremental = false) {
+    const hotUpdateContext = {
+        updateIndex: 0,
+        totalUpdates: 1,
+        changedFiles: []
+    };
+    const processor = {
+        config: async (context) => {
+            const compiler = (0, common_1.getCompiler)(context, name);
+            let options = defaultOptions(context, target, hotUpdateContext);
+            options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"], options);
+            overrideOptions(context, options, target, hotUpdateContext);
+            if (incremental) {
+                options.experiments ??= {};
+                options.experiments.incremental ??= "advance-silent";
+            }
+            compiler.setOptions(options);
+        },
+        compiler: async (context) => {
+            await (0, common_1.compiler)(context, name);
+        },
+        build: async (context) => {
+            await (0, common_1.build)(context, name);
+        },
+        run: async (env, context) => {
+            context.setValue(name, "hotUpdateContext", hotUpdateContext);
+            await (0, common_1.run)(env, context, name, context => findBundle(context, name, target, hotUpdateContext));
+        },
+        check: async (env, context) => {
+            await (0, common_1.check)(env, context, name);
+        },
+        afterAll: async (context) => {
+            if (context.getTestConfig().checkSteps === false) {
+                return;
+            }
+            if (hotUpdateContext.updateIndex + 1 !== hotUpdateContext.totalUpdates) {
+                throw new Error(`Should run all hot steps (${hotUpdateContext.updateIndex + 1} / ${hotUpdateContext.totalUpdates}): ${name}`);
+            }
+        }
+    };
+    processor.hotUpdateContext = hotUpdateContext;
+    return processor;
+}
+function getCreator(target) {
+    if (!creators.has(target)) {
+        creators.set(target, new creator_1.BasicCaseCreator({
+            clean: true,
+            describe: true,
+            target,
+            steps: ({ name, target }) => [
+                createHotProcessor(name, target)
+            ],
+            runner: {
+                key: (context, name, file) => name,
+                runner: createHotRunner
+            },
+            concurrent: true
+        }));
+    }
+    return creators.get(target);
+}
+function createHotCase(name, src, dist, target) {
+    const creator = getCreator(target);
+    creator.create(name, src, dist);
+}
 function defaultOptions(context, target, updateOptions) {
     const options = {
         context: context.getSource(),
@@ -110,63 +178,82 @@ function findBundle(context, name, target, updateOptions) {
     }
     return [...prefiles, ...files];
 }
-function createHotProcessor(name, target, incremental = false) {
-    const hotUpdateContext = {
-        updateIndex: 0,
-        totalUpdates: 1,
-        changedFiles: []
-    };
-    const processor = new processor_1.BasicProcessor({
-        name,
-        compilerType: type_1.ECompilerType.Rspack,
-        runable: true,
-        configFiles: ["rspack.config.js", "webpack.config.js"],
-        defaultOptions(context) {
-            return defaultOptions(context, target, hotUpdateContext);
-        },
-        overrideOptions(context, options) {
-            overrideOptions(context, options, target, hotUpdateContext);
-            if (incremental) {
-                options.experiments ??= {};
-                options.experiments.incremental ??= "advance-silent";
+function createHotRunner(context, name, file, env) {
+    const compiler = context.getCompiler(name);
+    const compilerOptions = compiler.getOptions();
+    const testConfig = context.getTestConfig();
+    const source = context.getSource();
+    const dist = context.getDist();
+    const hotUpdateContext = context.getValue(name, "hotUpdateContext");
+    const next = async (callback) => {
+        const usePromise = typeof callback === "function";
+        try {
+            hotUpdateContext.updateIndex++;
+            const stats = await compiler.build();
+            if (!stats) {
+                throw new Error("Should generate stats during build");
+            }
+            const jsonStats = stats.toJson({
+            // errorDetails: true
+            });
+            const compilerOptions = compiler.getOptions();
+            const checker = context.getValue(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", compilerOptions);
+            await (0, checkArrayExpectation_1.default)(source, jsonStats, "warning", `warnings${hotUpdateContext.updateIndex}`, "Warning", compilerOptions);
+            if (usePromise) {
+                // old callback style hmr cases
+                callback(null, jsonStats);
+            }
+            else {
+                // new promise style hmr cases
+                return jsonStats;
             }
-        },
-        findBundle(context, options) {
-            return findBundle(context, name, target, hotUpdateContext);
-        },
-        async compiler(context, compiler) {
-            context.setValue(name, "hotUpdateContext", hotUpdateContext);
         }
-    });
-    processor.hotUpdateContext = hotUpdateContext;
-    const originalAfterAll = processor.afterAll;
-    processor.afterAll = async function (context) {
-        await originalAfterAll.call(this, context);
-        if (context.getTestConfig().checkSteps === false) {
-            return;
+        catch (e) {
+            if (usePromise) {
+                callback(e);
+            }
+            else {
+                throw e;
+            }
         }
-        if (hotUpdateContext.updateIndex + 1 !== hotUpdateContext.totalUpdates) {
-            throw new Error(`Should run all hot steps (${hotUpdateContext.updateIndex + 1} / ${hotUpdateContext.totalUpdates}): ${name}`);
+    };
+    const nextHMR = async (m, options) => {
+        const jsonStats = await next();
+        const updatedModules = await m.hot.check(options || true);
+        if (!updatedModules) {
+            throw new Error("No update available");
         }
+        return jsonStats;
     };
-    return processor;
-}
-function getCreator(target) {
-    if (!creators.has(target)) {
-        creators.set(target, new creator_1.BasicCaseCreator({
-            clean: true,
-            describe: true,
-            target,
-            steps: ({ name, target }) => [
-                createHotProcessor(name, target)
-            ],
-            runner: runner_1.HotRunnerFactory,
-            concurrent: true
-        }));
-    }
-    return creators.get(target);
-}
-function createHotCase(name, src, dist, target) {
-    const creator = getCreator(target);
-    creator.create(name, src, dist);
+    const runner = new runner_1.WebRunner({
+        dom: context.getValue(name, "documentType") || type_1.EDocumentType.JSDOM,
+        env,
+        stats: (0, runner_2.cachedStats)(context, name),
+        name: name,
+        runInNewContext: false,
+        testConfig: {
+            documentType: testConfig.documentType || type_1.EDocumentType.Fake,
+            ...testConfig,
+            moduleScope(ms, stats, options) {
+                const moduleScope = ms;
+                if (typeof testConfig.moduleScope === "function") {
+                    testConfig.moduleScope(moduleScope, stats, compilerOptions);
+                }
+                moduleScope.NEXT = next;
+                moduleScope.NEXT_HMR = nextHMR;
+                return moduleScope;
+            }
+        },
+        cachable: true,
+        source,
+        dist,
+        compilerOptions
+    });
+    return runner;
 }

package/dist/case/incremental.d.ts

@@ -1,4 +1,4 @@
-import { ECompilerType, type TCompilerOptions } from "../type";
+import { type ECompilerType, type TCompilerOptions } from "../type";
 export declare function createHotIncrementalCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"], webpackCases: boolean): void;
 export type WatchIncrementalOptions = {
     ignoreNotFriendlyForIncrementalWarnings?: boolean;

package/dist/case/incremental.js

@@ -7,11 +7,10 @@ exports.createHotIncrementalCase = createHotIncrementalCase;
 exports.createWatchIncrementalCase = createWatchIncrementalCase;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const watch_1 = require("../processor/watch");
-const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
 const hot_1 = require("./hot");
+const watch_1 = require("./watch");
 const hotCreators = new Map();
 function createHotIncrementalProcessor(name, target, webpackCases) {
     const processor = (0, hot_1.createHotProcessor)(name, target, true);
@@ -21,7 +20,7 @@ function createHotIncrementalProcessor(name, target, webpackCases) {
     const originalAfterAll = processor.afterAll;
     processor.afterAll = async function (context) {
         try {
-            await originalAfterAll.call(this, context);
+            await originalAfterAll?.(context);
         }
         catch (e) {
             const isFake = context.getValue(name, "documentType") === type_1.EDocumentType.Fake;
@@ -42,7 +41,10 @@ function getHotCreator(target, webpackCases) {
             steps: ({ name, target }) => [
                 createHotIncrementalProcessor(name, target, webpackCases)
             ],
-            runner: runner_1.HotRunnerFactory,
+            runner: {
+                key: (context, name, file) => name,
+                runner: hot_1.createHotRunner
+            },
             concurrent: true
         }));
     }
@@ -58,7 +60,10 @@ function getWatchCreator(options) {
     if (!watchCreators.has(key)) {
         watchCreators.set(key, new creator_1.BasicCaseCreator({
             clean: true,
-            runner: runner_1.WatchRunnerFactory,
+            runner: {
+                key: watch_1.getWatchRunnerKey,
+                runner: watch_1.createWatchRunner
+            },
             description: (name, index) => {
                 return index === 0
                     ? `${name} should compile`
@@ -70,37 +75,17 @@ function getWatchCreator(options) {
                 const runs = node_fs_1.default
                     .readdirSync(src)
                     .sort()
-                    .filter(name => {
-                    return node_fs_1.default.statSync(node_path_1.default.join(src, name)).isDirectory();
-                })
+                    .filter(name => node_fs_1.default.statSync(node_path_1.default.join(src, name)).isDirectory())
                     .map(name => ({ name }));
                 return runs.map((run, index) => index === 0
-                    ? new watch_1.WatchProcessor({
-                        name,
-                        stepName: run.name,
-                        tempDir: temp,
-                        runable: true,
-                        compilerType: type_1.ECompilerType.Rspack,
-                        configFiles: ["rspack.config.js", "webpack.config.js"],
-                        defaultOptions(index, context) {
-                            return {
-                                experiments: {
-                                    incremental: "advance"
-                                },
-                                ignoreWarnings: options.ignoreNotFriendlyForIncrementalWarnings
-                                    ? [/is not friendly for incremental/]
-                                    : undefined
-                            };
-                        }
-                    }, watchState)
-                    : new watch_1.WatchStepProcessor({
-                        name,
-                        stepName: run.name,
-                        tempDir: temp,
-                        runable: true,
-                        compilerType: type_1.ECompilerType.Rspack,
-                        configFiles: ["rspack.config.js", "webpack.config.js"]
-                    }, watchState));
+                    ? (0, watch_1.createWatchInitialProcessor)(name, temp, run.name, watchState, {
+                        incremental: true,
+                        ignoreNotFriendlyForIncrementalWarnings: options.ignoreNotFriendlyForIncrementalWarnings
+                    })
+                    : (0, watch_1.createWatchStepProcessor)(name, temp, run.name, watchState, {
+                        incremental: true,
+                        ignoreNotFriendlyForIncrementalWarnings: options.ignoreNotFriendlyForIncrementalWarnings
+                    }));
             },
             concurrent: true
         }));

package/dist/case/native-watcher.js

@@ -6,13 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNativeWatcher = createNativeWatcher;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const watch_1 = require("../processor/watch");
-const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
+const watch_1 = require("./watch");
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
-    runner: runner_1.WatchRunnerFactory,
+    runner: {
+        key: watch_1.getWatchRunnerKey,
+        runner: watch_1.createWatchRunner
+    },
     description: (name, index) => {
         return index === 0
             ? `${name} should compile`
@@ -24,29 +25,15 @@ const creator = new creator_1.BasicCaseCreator({
         const runs = node_fs_1.default
             .readdirSync(src)
             .sort()
-            .filter(name => {
-            return node_fs_1.default.statSync(node_path_1.default.join(src, name)).isDirectory();
-        })
+            .filter(name => node_fs_1.default.statSync(node_path_1.default.join(src, name)).isDirectory())
             .map(name => ({ name }));
         return runs.map((run, index) => index === 0
-            ? new watch_1.WatchProcessor({
-                name,
-                stepName: run.name,
-                tempDir: temp,
-                runable: true,
-                compilerType: type_1.ECompilerType.Rspack,
-                configFiles: ["rspack.config.js", "webpack.config.js"],
+            ? (0, watch_1.createWatchInitialProcessor)(name, temp, run.name, watchState, {
                 nativeWatcher: true
-            }, watchState)
-            : new watch_1.WatchStepProcessor({
-                name,
-                stepName: run.name,
-                tempDir: temp,
-                runable: true,
-                compilerType: type_1.ECompilerType.Rspack,
-                configFiles: ["rspack.config.js", "webpack.config.js"],
+            })
+            : (0, watch_1.createWatchStepProcessor)(name, temp, run.name, watchState, {
                 nativeWatcher: true
-            }, watchState));
+            }));
     },
     concurrent: true
 });

package/dist/case/normal.js

@@ -8,11 +8,54 @@ exports.createHotNormalCase = createHotNormalCase;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const core_1 = require("@rspack/core");
-const processor_1 = require("../processor");
-const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
+const common_1 = require("./common");
+const runner_1 = require("./runner");
 const NORMAL_CASES_ROOT = node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/normalCases");
+const createCaseOptions = (hot) => {
+    return {
+        clean: true,
+        describe: false,
+        steps: ({ name }) => [
+            {
+                config: async (context) => {
+                    const compiler = (0, common_1.getCompiler)(context, name);
+                    let options = defaultOptions(context, {
+                        plugins: hot ? [new core_1.HotModuleReplacementPlugin()] : []
+                    });
+                    options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"], options);
+                    overrideOptions(context, options);
+                    compiler.setOptions(options);
+                },
+                compiler: async (context) => {
+                    await (0, common_1.compiler)(context, name);
+                },
+                build: async (context) => {
+                    await (0, common_1.build)(context, name);
+                },
+                run: async (env, context) => {
+                    await (0, common_1.run)(env, context, name, findBundle);
+                },
+                check: async (env, context) => {
+                    await (0, common_1.check)(env, context, name);
+                }
+            }
+        ],
+        runner: {
+            key: (context, name, file) => name,
+            runner: runner_1.createRunner
+        },
+        concurrent: true
+    };
+};
+const creator = new creator_1.BasicCaseCreator(createCaseOptions(false));
+function createNormalCase(name, src, dist) {
+    creator.create(name, src, dist);
+}
+const hotCreator = new creator_1.BasicCaseCreator(createCaseOptions(true));
+function createHotNormalCase(name, src, dist) {
+    hotCreator.create(name, src, dist);
+}
 function findBundle(context, options) {
     const testConfig = context.getTestConfig();
     if (typeof testConfig.findBundle === "function") {
@@ -158,31 +201,3 @@ function overrideOptions(context, options) {
         };
     }
 }
-const createCaseOptions = (hot) => {
-    return {
-        clean: true,
-        describe: false,
-        steps: ({ name }) => [
-            new processor_1.BasicProcessor({
-                name,
-                findBundle,
-                defaultOptions: context => defaultOptions(context, {
-                    plugins: hot ? [new core_1.HotModuleReplacementPlugin()] : []
-                }),
-                overrideOptions,
-                runable: true,
-                compilerType: type_1.ECompilerType.Rspack
-            })
-        ],
-        runner: runner_1.BasicRunnerFactory,
-        concurrent: true
-    };
-};
-const creator = new creator_1.BasicCaseCreator(createCaseOptions(false));
-function createNormalCase(name, src, dist) {
-    creator.create(name, src, dist);
-}
-const hotCreator = new creator_1.BasicCaseCreator(createCaseOptions(true));
-function createHotNormalCase(name, src, dist) {
-    hotCreator.create(name, src, dist);
-}

package/dist/case/runner.d.ts

@@ -0,0 +1,18 @@
+import { type ECompilerType, type ITestContext, type ITestEnv, type ITestRunner, type TCompilerStatsCompilation } from "../type";
+export type THotStepRuntimeLangData = {
+    outdatedModules: string[];
+    outdatedDependencies: Record<string, string[]>;
+    updatedModules: string[];
+    updatedRuntime: string[];
+    acceptedModules: string[];
+    disposedModules: string[];
+};
+export type THotStepRuntimeData = {
+    javascript: THotStepRuntimeLangData;
+    css: THotStepRuntimeLangData;
+    statusPath: string[];
+};
+export declare function cachedStats<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string): () => TCompilerStatsCompilation<T>;
+export declare function createRunner<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, file: string, env: ITestEnv): ITestRunner;
+export declare function getMultiCompilerRunnerKey(context: ITestContext, name: string, file: string): string;
+export declare function createMultiCompilerRunner<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, file: string, env: ITestEnv): ITestRunner;

package/dist/case/runner.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachedStats = cachedStats;
+exports.createRunner = createRunner;
+exports.getMultiCompilerRunnerKey = getMultiCompilerRunnerKey;
+exports.createMultiCompilerRunner = createMultiCompilerRunner;
+const runner_1 = require("../runner");
+const type_1 = require("../type");
+const common_1 = require("./common");
+function cachedStats(context, name) {
+    const compiler = context.getCompiler(name);
+    const statsGetter = (() => {
+        let cached = null;
+        return () => {
+            if (cached) {
+                return cached;
+            }
+            cached = compiler.getStats().toJson({
+                errorDetails: true
+            });
+            return cached;
+        };
+    })();
+    return statsGetter;
+}
+function createRunner(context, name, file, env) {
+    const compiler = (0, common_1.getCompiler)(context, name);
+    const compilerOptions = compiler.getOptions();
+    const runnerOptions = {
+        runInNewContext: false,
+        cachable: true,
+        env,
+        stats: cachedStats(context, name),
+        name,
+        testConfig: context.getTestConfig(),
+        source: context.getSource(),
+        dist: context.getDist(),
+        compilerOptions
+    };
+    if (compilerOptions.target === "web" ||
+        compilerOptions.target === "webworker") {
+        return new runner_1.WebRunner({
+            ...runnerOptions,
+            runInNewContext: true,
+            dom: context.getValue(name, "documentType") || type_1.EDocumentType.Fake
+        });
+    }
+    return new runner_1.NodeRunner(runnerOptions);
+}
+function getFileIndexHandler(context, name, file) {
+    const multiFileIndexMap = context.getValue(name, "multiFileIndexMap") || {};
+    const runned = context.getValue(name, "runned") || new Set();
+    if (typeof multiFileIndexMap[file] === "undefined") {
+        throw new Error("Unexpect file in multiple runner");
+    }
+    const indexList = multiFileIndexMap[file];
+    const seq = indexList.findIndex((index, n) => !runned.has(`${name}:${file}[${n}]`));
+    if (seq === -1) {
+        throw new Error(`File ${file} should run only ${indexList.length} times`);
+    }
+    const getIndex = () => [indexList[seq], seq];
+    const flagIndex = () => runned.add(`${name}:${file}[${seq}]`);
+    context.setValue(name, "runned", runned);
+    return { getIndex, flagIndex };
+}
+function getMultiCompilerRunnerKey(context, name, file) {
+    const { getIndex } = getFileIndexHandler(context, name, file);
+    const [index, seq] = getIndex();
+    return `${name}-${index}[${seq}]`;
+}
+function createMultiCompilerRunner(context, name, file, env) {
+    const { getIndex, flagIndex } = getFileIndexHandler(context, name, file);
+    const multiCompilerOptions = context.getValue(name, "multiCompilerOptions") || [];
+    const [index] = getIndex();
+    const compilerOptions = multiCompilerOptions[index];
+    let runner;
+    const runnerOptions = {
+        runInNewContext: false,
+        cachable: true,
+        env,
+        stats: () => {
+            const s = cachedStats(context, name)();
+            if (s.children?.length && s.children.length > 1) {
+                s.__index__ = index;
+                return s;
+            }
+            return s.children[index];
+        },
+        name,
+        testConfig: context.getTestConfig(),
+        source: context.getSource(),
+        dist: context.getDist(),
+        compilerOptions
+    };
+    if (compilerOptions.target === "web" ||
+        compilerOptions.target === "webworker") {
+        runner = new runner_1.WebRunner({
+            ...runnerOptions,
+            runInNewContext: true,
+            dom: context.getValue(name, "documentType") || type_1.EDocumentType.Fake
+        });
+    }
+    else {
+        runner = new runner_1.NodeRunner(runnerOptions);
+    }
+    flagIndex();
+    return runner;
+}

package/dist/case/serial.d.ts

@@ -1,3 +1,3 @@
-import { ECompilerType, type TTestConfig } from "../type";
+import type { ECompilerType, TTestConfig } from "../type";
 export type TSerialCaseConfig = Omit<TTestConfig<ECompilerType.Rspack>, "validate">;
 export declare function createSerialCase(name: string, src: string, dist: string): void;