@rspack-canary/test-tools 1.6.0-canary-6cd722f4-20251022123039 → 1.6.0-canary-4ad8b49f-20251023175711

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 { ECompilerType, type ITestCompilerManager, type ITestContext, type ITestEnv, type ITesterConfig, type ITestRunner, type TTestConfig } from "../type";
-export type TTestContextOptions = Omit<ITesterConfig, "name" | "steps">;
+import type { ITestCompilerManager, ITestContext, ITestEnv, ITesterConfig, ITestRunner, TTestConfig } from "../type";
+export type TTestContextOptions = Omit<ITesterConfig, "steps">;
 export declare class TestContext implements ITestContext {
     private config;
-    protected errors: Map<string, Error[]>;
-    protected compilers: Map<string, ITestCompilerManager<ECompilerType>>;
-    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<T extends ECompilerType>(name: string, type: T | void): ITestCompilerManager<T>;
-    getRunner(name: string, file: string, env: ITestEnv): ITestRunner;
-    getTestConfig<T extends ECompilerType>(): TTestConfig<T>;
-    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>;
+    getCompiler(): ITestCompilerManager;
+    getRunner(file: string, env: ITestEnv): ITestRunner;
+    getTestConfig(): TTestConfig;
+    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,12 +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 type_1 = require("../type");
+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();
     }
@@ -35,83 +35,68 @@ class TestContext {
         }
         return this.config.temp;
     }
-    getCompiler(name, type) {
-        let compiler = this.compilers.get(name);
-        if (!compiler) {
-            if (!type) {
-                throw new Error("Compiler does not exists");
-            }
-            compiler = new compiler_1.TestCompilerManager(type, this.config.compilerFactories);
-            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;
+    setValue(key, value) {
+        this.store.set(key, value);
     }
-    getValue(name, key) {
-        if (!this.store.has(name)) {
-            this.store.set(name, {});
-        }
-        const scope = this.store.get(name);
-        return scope[key];
+    getValue(key) {
+        return this.store.get(key);
     }
-    hasError(name) {
-        if (name) {
-            return this.getError(name).length > 0;
-        }
-        return !!Array.from(this.errors.values()).reduce((res, arr) => res + arr.length, 0);
+    hasError() {
+        return this.errors.length > 0;
     }
-    emitError(name, err) {
-        const errors = this.errors.get(name) || [];
-        errors.push(typeof err === "string" ? new Error(err) : err);
-        this.errors.set(name, errors);
+    emitError(err) {
+        this.errors.push(typeof err === "string" ? new Error(err) : err);
     }
-    getNames() {
-        return Array.from(this.compilers.keys());
+    getError() {
+        return this.errors;
     }
-    getError(name) {
-        if (name) {
-            return this.errors.get(name) || [];
-        }
-        return Array.prototype.concat(...this.errors.values());
+    clearError() {
+        this.errors.length = 0;
     }
-    clearError(name) {
-        if (name) {
-            this.errors.delete(name);
-        }
-        else {
-            this.errors.clear();
-        }
-    }
-    async closeCompiler(name) {
-        const rspackCompiler = this.getCompiler(name, type_1.ECompilerType.Rspack);
-        if (rspackCompiler) {
-            await rspackCompiler.close();
-        }
-        const webpackCompiler = this.getCompiler(name, type_1.ECompilerType.Webpack);
-        if (webpackCompiler) {
-            await webpackCompiler.close();
+    async closeCompiler() {
+        if (this.compiler) {
+            await this.compiler.close();
         }
     }
 }

package/dist/test/creator.d.ts

@@ -1,4 +1,4 @@
-import type { ECompilerType, ITestContext, ITestEnv, ITester, ITesterConfig, ITestProcessor, TTestConfig, TTestRunnerCreator } from "../type";
+import type { ITestContext, ITestEnv, ITester, ITesterConfig, ITestProcessor, TTestConfig, TTestRunnerCreator } from "../type";
 declare global {
     var testFilter: string | undefined;
 }
@@ -6,40 +6,40 @@ interface IConcurrentTestEnv {
     clear: () => void;
     run: () => Promise<void>;
 }
-export interface IBasicCaseCreatorOptions<T extends ECompilerType> {
+export interface IBasicCaseCreatorOptions {
     clean?: boolean;
     describe?: boolean;
     timeout?: number;
     contextValue?: Record<string, unknown>;
-    steps: (creatorConfig: IBasicCaseCreatorOptions<T> & {
+    steps: (creatorConfig: IBasicCaseCreatorOptions & {
         name: string;
         src: string;
         dist: string;
         temp: string | void;
     }) => ITestProcessor[];
-    testConfig?: (testConfig: TTestConfig<T>) => void;
+    testConfig?: (testConfig: TTestConfig) => void;
     description?: (name: string, step: number) => string;
     runner?: TTestRunnerCreator;
     createContext?: (config: ITesterConfig) => ITestContext;
     concurrent?: boolean | number;
     [key: string]: unknown;
 }
-export declare class BasicCaseCreator<T extends ECompilerType> {
-    protected _options: IBasicCaseCreatorOptions<T>;
+export declare class BasicCaseCreator {
+    protected _options: IBasicCaseCreatorOptions;
     protected currentConcurrent: number;
     protected tasks: [string, () => void][];
-    constructor(_options: IBasicCaseCreatorOptions<T>);
-    create(name: string, src: string, dist: string, temp?: string, caseOptions?: Partial<IBasicCaseCreatorOptions<T>>): ITester | undefined;
+    constructor(_options: IBasicCaseCreatorOptions);
+    create(name: string, src: string, dist: string, temp?: string, caseOptions?: Partial<IBasicCaseCreatorOptions>): ITester | undefined;
     protected shouldRun(name: string): boolean;
-    protected describeConcurrent(name: string, tester: ITester, testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): void;
-    protected describe(name: string, tester: ITester, testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): void;
+    protected describeConcurrent(name: string, tester: ITester, testConfig: TTestConfig, options: IBasicCaseCreatorOptions): void;
+    protected describe(name: string, tester: ITester, testConfig: TTestConfig, options: IBasicCaseCreatorOptions): void;
     protected createConcurrentEnv(): ITestEnv & IConcurrentTestEnv;
-    protected createEnv(testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): ITestEnv;
+    protected createEnv(testConfig: TTestConfig, options: IBasicCaseCreatorOptions): ITestEnv;
     protected clean(folders: string[]): void;
     protected skip(name: string, reason: string | boolean): void;
-    protected readTestConfig(src: string): TTestConfig<T>;
-    protected checkSkipped(src: string, testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): boolean | string;
-    protected createTester(name: string, src: string, dist: string, temp: string | undefined, testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): ITester;
+    protected readTestConfig(src: string): TTestConfig;
+    protected checkSkipped(src: string, testConfig: TTestConfig, options: IBasicCaseCreatorOptions): boolean | string;
+    protected createTester(name: string, src: string, dist: string, temp: string | undefined, testConfig: TTestConfig, options: IBasicCaseCreatorOptions): ITester;
     protected tryRunTask(concurrent?: number): void;
     protected getMaxConcurrent(concurrent?: number): number;
     protected registerConcurrentTask(name: string, starter: () => void, concurrent?: number): () => void;

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()) {
@@ -255,7 +255,8 @@ class BasicCaseCreator {
             it,
             beforeEach,
             afterEach,
-            jest
+            jest: global.jest || global.rstest,
+            rstest: global.rstest
         };
     }
     clean(folders) {
@@ -264,9 +265,7 @@ class BasicCaseCreator {
         }
     }
     skip(name, reason) {
-        describe.skip(name, () => {
-            it(typeof reason === "string" ? `filtered by ${reason}` : "filtered", () => { });
-        });
+        it(typeof reason === "string" ? `filtered by ${reason}` : "filtered", () => { });
     }
     readTestConfig(src) {
         const testConfigFile = node_path_1.default.join(src, "test.config.js");

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"
+};