local-test-runner 0.0.0-stage → 0.0.0

package/dist/index.js

@@ -0,0 +1,1141 @@
+'use strict';
+
+var querystring = require('querystring');
+var pc = require('picocolors');
+var child_process = require('child_process');
+var fs = require('fs');
+var os = require('os');
+var path = require('path');
+var events = require('events');
+var picomatch = require('picomatch');
+var tinyglobby = require('tinyglobby');
+var connect = require('connect');
+var serveStatic = require('serve-static');
+var escapeHTML = require('escape-html');
+var MagicString = require('magic-string');
+var parse5 = require('parse5');
+var HttpProxy = require('http-proxy');
+
+// 按 ?ie=X 注入 X-UA-Compatible，配合 EdgeIEMode preset（msedge --ie-mode-test）
+// 让页面在指定 IE 文档模式下渲染。注意必须用 http-equiv，name 会被 IE 忽略。
+var EmulateIE = {
+    transformHtml(html, ctx) {
+        var params = querystring.parse(ctx.filename.split('?')[1] || '');
+        if (params.ie) {
+            return [{
+                    injectTo: 'head-prepend',
+                    tag: 'meta',
+                    attrs: {
+                        'http-equiv': 'X-UA-Compatible',
+                        content: `IE=${params.ie}`
+                    }
+                }];
+        }
+    }
+};
+
+/**
+ * 把 MultiTestResult 归一化为扁平的 settled 结果数组，支持任意层级：
+ *  - 数组 → 逐项递归展开
+ *  - settled 对象 → fulfilled 递归解包 value（可能是 TestResult、数组或再嵌套的 settled），
+ *    rejected 原样保留（对应被拒绝的任务或整个 runQueue）
+ *  - 普通 TestResult（无 status）→ 包装成 { status: "fulfilled", value }
+ */
+function flattenResults$1(input) {
+    if (Array.isArray(input)) {
+        return input.reduce(function (acc, item) {
+            return acc.concat(flattenResults$1(item));
+        }, []);
+    }
+    const node = input;
+    if (node && (node.status === "fulfilled" || node.status === "rejected")) {
+        if (node.status === "fulfilled") {
+            return flattenResults$1(node.value);
+        }
+        return [node];
+    }
+    return [{ status: "fulfilled", value: node }];
+}
+/**
+ * 裁断是否通过：没有任何任务被拒绝、且每个已完成任务的用例全部通过（且至少跑了 1 条）时为 true。
+ *
+ * 用 some + 取反，而不是 every：
+ *  - some 在空数组上返回 false，取反后为 true，空队列视为通过（不跑 = 不失败）；
+ *  - 语义上即"不存在失败项"，比"所有项都通过"更贴合"不中断队列"的整体判定。
+ *
+ * 入支持嵌套数组（如多次 runQueue 的结果合并），内部会先扁平化。
+ */
+function judge(results) {
+    var list = flattenResults$1(results);
+    return !list.some(function (settled) {
+        if (settled.status !== "fulfilled") {
+            return true;
+        }
+        return settled.value.total === 0 || settled.value.passed !== settled.value.total;
+    });
+}
+
+// 注入到测试页的结果上报脚本。
+// 除 total/passed/runtime 外，还收集失败断言明细（测试名/消息/期望/实际），
+// 以 fail0..failN 字段一并 POST 回服务器。
+// 保持 ES3 兼容：不用 JSON、不用 ES5，IE6+ / Firefox1.5+ / 老 Presto Opera 可用。
+const apiScript$1 = `
+(function(){
+var fails = [];
+var current = '';
+function fmt(v){
+	var t;
+	try { t = String(v); } catch(e) { t = '?'; }
+	if(t.length > 300) { t = t.substring(0, 300) + '...'; }
+	return t;
+}
+function onTestStart(t){ current = (t && t.name) || ''; }
+function onLog(d){
+	if(d && d.result === false){
+		fails.push(current + ' :: ' + fmt(d.message) + ' (expected: ' + fmt(d.expected) + ', actual: ' + fmt(d.actual) + ')');
+	}
+}
+function finish(result){
+	setTimeout(function(){
+		var form = document.createElement('form');
+		form.method = 'POST';
+		form.action = '/';
+		form.style.display = 'none';
+		function add(name, value){
+			var input = document.createElement('input');
+			input.name = name;
+			input.value = value;
+			form.appendChild(input);
+		}
+		add('total', result.total);
+		add('passed', result.passed);
+		add('runtime', result.runtime);
+		add('failures', fails.length);
+		for(var i = 0; i < fails.length && i < 50; i++){ add('fail' + i, fails[i]); }
+		document.body.appendChild(form);
+		form.submit();
+	}, 500);
+}
+// QUnit 2.x 有 QUnit.version，支持 QUnit.done(callback) 注册；
+// QUnit 1.x 没有 version，且它的 runLoggingCallbacks 会优先直接调用 QUnit.done/log/testStart，
+// 注册式回调根本不会被遍历到，只能覆盖赋值。
+if(QUnit.version){
+	QUnit.testStart(onTestStart);
+	QUnit.log(onLog);
+	QUnit.done(finish);
+} else {
+	QUnit.testStart = onTestStart;
+	QUnit.log = onLog;
+	QUnit.done = finish;
+}
+})();
+`;
+var QUnit = {
+    transformHtml() {
+        return [{
+                injectTo: 'body',
+                tag: 'script',
+                children: apiScript$1
+            }];
+    }
+};
+
+// 注入到测试页的结果上报脚本。
+// 监听 Mocha Runner 的 fail / end 事件，把 total / passed / runtime 与失败明细
+// 以 fail0..failN 字段 POST 回服务器。
+// 保持 ES3 兼容：不用 JSON、不用 ES5，IE6+ / Firefox1.5+ / 老 Presto Opera 可用。
+const apiScript = `
+(function(){
+var fails = [];
+var startTime = 0;
+function nowTime(){ return new Date().getTime(); }
+function fmt(v){
+	var t;
+	try { t = String(v); } catch(e) { t = '?'; }
+	if(t.length > 300) { t = t.substring(0, 300) + '...'; }
+	return t;
+}
+function testTitle(test){
+	var title = '';
+	try {
+		if(test){
+			if(typeof test.fullTitle === 'function'){ title = test.fullTitle(); }
+			else if(test.title){ title = test.title; }
+		}
+	} catch(e) {}
+	return title || '';
+}
+function onFail(test, err){
+	var msg = '';
+	try { msg = (err && (err.message || String(err))) || ''; } catch(e) {}
+	fails.push(testTitle(test) + ' :: ' + fmt(msg));
+}
+function finish(total, passed, runtime){
+	setTimeout(function(){
+		var form = document.createElement('form');
+		form.method = 'POST';
+		form.action = '/';
+		form.style.display = 'none';
+		function add(name, value){
+			var input = document.createElement('input');
+			input.name = name;
+			input.value = value;
+			form.appendChild(input);
+		}
+		add('total', total);
+		add('passed', passed);
+		add('runtime', runtime);
+		add('failures', fails.length);
+		for(var i = 0; i < fails.length && i < 50; i++){ add('fail' + i, fails[i]); }
+		document.body.appendChild(form);
+		form.submit();
+	}, 500);
+}
+function attach(runner){
+	if(!runner || runner.__localTestRunnerAttached){ return; }
+	runner.__localTestRunnerAttached = true;
+	var tests = 0;
+	var passes = 0;
+	runner.on('test end', function(){ tests++; });
+	runner.on('pass', function(){ passes++; });
+	runner.on('fail', onFail);
+	runner.on('end', function(){
+		var stats = runner.stats || {};
+		var total = stats.tests != null ? stats.tests : tests;
+		var passed = stats.passes != null ? stats.passes : passes;
+		var runtime = stats.duration;
+		if(runtime == null){ runtime = startTime ? (nowTime() - startTime) : 0; }
+		finish(total, passed, runtime);
+	});
+}
+// 直接劫持 Runner.prototype.run：Mocha 的同步测试会在 run() 返回前全部跑完，
+// 只有在这里提前挂事件，才能拿到完整的 fail / end。
+var Runner = window.Mocha && window.Mocha.Runner;
+if(Runner && Runner.prototype && typeof Runner.prototype.run === 'function' && !Runner.prototype.__localTestRunnerHooked){
+	var origRun = Runner.prototype.run;
+	Runner.prototype.run = function(){
+		if(!startTime){ startTime = nowTime(); }
+		attach(this);
+		return origRun.apply(this, arguments);
+	};
+	Runner.prototype.__localTestRunnerHooked = true;
+} else if(window.mocha && typeof mocha.run === 'function'){
+	// 兜底：无法劫持 Runner 时，只能捕获 run() 返回之后的异步事件。
+	var origMochaRun = mocha.run;
+	mocha.run = function(){
+		startTime = nowTime();
+		var runner = origMochaRun.apply(mocha, arguments);
+		attach(runner);
+		return runner;
+	};
+}
+})();
+`;
+var Mocha = {
+    transformHtml() {
+        return [{
+                injectTo: 'body',
+                tag: 'script',
+                children: apiScript
+            }];
+    }
+};
+
+/**
+ * 把 MultiTestResult 归一化为扁平的 settled 结果数组，支持任意层级：
+ *  - 数组 → 逐项递归展开
+ *  - settled 对象 → fulfilled 递归解包 value（可能是 TestResult、数组或再嵌套的 settled），
+ *    rejected 原样保留（对应被拒绝的任务或整个 runQueue）
+ *  - 普通 TestResult（无 status）→ 包装成 { status: "fulfilled", value }
+ */
+function flattenResults(input) {
+    if (Array.isArray(input)) {
+        return input.reduce(function (acc, item) {
+            return acc.concat(flattenResults(item));
+        }, []);
+    }
+    const node = input;
+    if (node && (node.status === "fulfilled" || node.status === "rejected")) {
+        if (node.status === "fulfilled") {
+            return flattenResults(node.value);
+        }
+        return [node];
+    }
+    return [{ status: "fulfilled", value: node }];
+}
+/**
+ * 输出测试结果：逐行汇总每个任务的通过情况与失败明细，末尾输出总计。
+ * results 为 MultiTestResult（单个 TestResult、runQueue 的 settled 数组、并行 allSettled 结果等），
+ * 内部统一扁平化；tasks 与扁平化后的结果按下标一一对应，用于显示浏览器名称/版本，缺省时以 Task#N 标识。
+ * 返回统计对象供程序化使用。
+ */
+function report(results, tasks) {
+    var list = flattenResults(results);
+    const summary = {
+        tasks: list.length,
+        tasksPassed: 0,
+        tasksFailed: 0,
+        tasksErrored: 0,
+        passed: 0,
+        failed: 0,
+        tests: 0,
+        runtime: 0
+    };
+    if (!list.length) {
+        console.log(pc.yellow("No test results."));
+        return summary;
+    }
+    const lines = [];
+    list.forEach(function (settled, index) {
+        const task = tasks && tasks[index];
+        const label = ((task && (task.browser || task.preset)) || "Task#" + (index + 1))
+            + (task && task.version ? " v" + task.version : "");
+        if (settled.status === "fulfilled") {
+            const result = settled.value;
+            summary.passed += result.passed;
+            summary.tests += result.total;
+            summary.failed += result.total - result.passed;
+            summary.runtime += result.runtime || 0;
+            if (result.total === 0) {
+                summary.tasksFailed++;
+                lines.push(pc.yellow("⚠") + " " + pc.yellow(pc.bold(label + ":")) + " " + pc.yellow("0 tests executed"));
+            }
+            else if (result.passed === result.total) {
+                summary.tasksPassed++;
+                lines.push(pc.green("✓") + " " +
+                    pc.green(pc.bold(label + ":")) + " " +
+                    pc.green(result.passed + "/" + result.total + " passed") + " " +
+                    pc.dim("(" + result.runtime + "ms)"));
+            }
+            else {
+                summary.tasksFailed++;
+                lines.push(pc.red("✗") + " " +
+                    pc.red(pc.bold(label + ":")) + " " +
+                    pc.red(result.passed + "/" + result.total + " failed") + " " +
+                    pc.dim("(" + result.runtime + "ms)"));
+            }
+            appendFailureDetails(lines, result);
+        }
+        else {
+            summary.tasksErrored++;
+            summary.tasksFailed++;
+            const reason = (settled.reason && settled.reason.message) || String(settled.reason);
+            lines.push(pc.red("✗") + " " + pc.red(pc.bold(label + ":")) + " " + pc.red(String(reason)));
+        }
+    });
+    console.log(lines.join("\n"));
+    console.log(pc.dim("-".repeat(60)));
+    console.log("Total: " + summary.tasks + " tasks, " +
+        summary.tasksPassed + " passed, " +
+        summary.tasksFailed + " failed" +
+        (summary.tasksErrored ? " (" + summary.tasksErrored + " errors)" : "") + ", " +
+        summary.passed + "/" + summary.tests + " tests, " +
+        summary.runtime + "ms");
+    return summary;
+}
+function appendFailureDetails(lines, result) {
+    const details = result.failureDetails || [];
+    for (let i = 0; i < details.length; i++) {
+        lines.push(pc.red("    ✗ " + details[i]));
+    }
+    if (result.failures && result.failures > details.length) {
+        lines.push(pc.red("    ... and " + (result.failures - details.length) + " more"));
+    }
+}
+
+const testStartEmitter = new events.EventEmitter();
+const testEndEmitter = new events.EventEmitter();
+var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus[TaskStatus["Waiting"] = 0] = "Waiting";
+    TaskStatus[TaskStatus["Running"] = 1] = "Running";
+    TaskStatus[TaskStatus["Finished"] = 2] = "Finished";
+})(TaskStatus || (TaskStatus = {}));
+
+// Edge 的固定安装路径（按常见位置探测，找不到时退回 PATH 里的 msedge）
+const EDGE_PATH = [
+    "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
+    "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe"
+].find(function (p) {
+    try {
+        return fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}) || "msedge";
+function genPresetOptions(preset, version) {
+    switch (preset) {
+        case "Chrome":
+            return {
+                command: "chrome",
+                flags: [
+                    '--user-data-dir=' + path.resolve(os.tmpdir(), "test-chrome-" + Date.now()),
+                    // 一次性空缓存目录：no-store 响应头救不了已存在的缓存条目，
+                    // 空缓存启动才能保证每次拿到的都是服务器上的最新产物
+                    '--disk-cache-dir=' + path.resolve(os.tmpdir(), "test-chrome-cache-" + Date.now()),
+                    '--enable-automation',
+                    '--no-default-browser-check',
+                    '--no-first-run',
+                    '--disable-default-apps',
+                    '--disable-popup-blocking',
+                    '--disable-translate',
+                    '--disable-background-timer-throttling',
+                    '--disable-renderer-backgrounding',
+                    '--disable-device-discovery-notifications'
+                ]
+            };
+        case "Firefox":
+            const tempProfileDir = path.resolve(os.tmpdir(), "test-firefox-" + Date.now());
+            fs.mkdirSync(tempProfileDir, { recursive: true });
+            const userJsContent = `
+// ===== 核心防干扰配置 =====
+user_pref("browser.shell.checkDefaultBrowser", false);
+user_pref("browser.bookmarks.restore_default_bookmarks", false);
+user_pref("browser.startup.homepage_override.mstone", "ignore");
+user_pref("browser.sessionstore.resume_from_crash", false);
+user_pref("dom.disable_open_during_load", false);
+user_pref("dom.max_script_run_time", 0); // 防止脚本执行慢被强杀
+user_pref("dom.max_chrome_script_run_time", 0);
+
+// ===== 直连，不走系统代理（测试服务器在 127.0.0.1） =====
+user_pref("network.proxy.type", 0);
+
+// ===== 屏蔽所有更新 =====
+user_pref("app.update.enabled", false);
+user_pref("app.update.auto", false);
+user_pref("app.update.mode", 0);
+user_pref("app.update.service.enabled", false);
+user_pref("extensions.update.enabled", false);
+user_pref("extensions.update.autoUpdateDefault", false);
+user_pref("extensions.getAddons.showPane", false);
+user_pref("extensions.checkCompatibility", false);
+
+// ===== 屏蔽遥测与安全拦截 =====
+user_pref("datareporting.healthreport.service.enabled", false);
+user_pref("datareporting.healthreport.uploadEnabled", false);
+user_pref("datareporting.policy.dataSubmissionEnabled", false);
+user_pref("toolkit.telemetry.enabled", false);
+user_pref("browser.safebrowsing.enabled", false);
+user_pref("browser.safebrowsing.malware.enabled", false);
+`;
+            // 写入 user.js
+            fs.writeFileSync(path.join(tempProfileDir, 'user.js'), userJsContent);
+            return {
+                command: "firefox",
+                flags: [
+                    // -profile 与路径必须拆成两个参数，合在一起会被当成单个 argv
+                    '-no-remote',
+                    '-profile',
+                    tempProfileDir
+                ]
+            };
+        case "Edge":
+            return {
+                command: EDGE_PATH,
+                flags: [
+                    '--user-data-dir=' + path.resolve(os.tmpdir(), "test-edge-" + Date.now()),
+                ]
+            };
+        case "EdgeIEMode":
+            return {
+                command: EDGE_PATH,
+                flags: [
+                    '--user-data-dir=' + path.resolve(os.tmpdir(), "test-ie-" + Date.now()),
+                    '--ie-mode-test'
+                ]
+            };
+        case "Opera": {
+            const v = parseFloat(version || '99');
+            if (v < 12.6) {
+                return {
+                    command: "opera"
+                };
+            }
+            if (v < 13) {
+                // Opera Classic（12.60 < Presto，< v13）需要在 -pd 指定的 profile 目录下写 operaprefs.ini，
+                // 否则首次启动会弹出初始化许可对话框阻塞在前台，导致加载超时。
+                /**
+                 * Opera Classic（Presto 内核，v12 及以下）的 operaprefs.ini。
+                 * 作用：关闭所有初始化弹窗、设置启动类型为空白页、接受许可协议，
+                 * 让浏览器在自动启动时不阻塞在首次启动对话框上。
+                 * 内容来源：karma-opera-launcher 的 config/prefs.ini。
+                 */
+                const OPERA_CLASSIC_PREFS = [
+                    'Opera Preferences version 2.1',
+                    '',
+                    '[User Prefs]',
+                    'Show Default Browser Dialog = 0',
+                    'Startup Type = 4',
+                    'Home URL = about:blank',
+                    'Show Close All But Active Dialog = 0',
+                    'Show Close All Dialog = 0',
+                    'Show Crash Log Upload Dialog = 0',
+                    'Show Delete Mail Dialog = 0',
+                    'Show Download Manager Selection Dialog = 0',
+                    'Show Geolocation License Dialog = 0',
+                    'Show Mail Error Dialog = 0',
+                    'Show New Opera Dialog = 0',
+                    'Show Problem Dialog = 0',
+                    'Show Progress Dialog = 0',
+                    'Show Validation Dialog = 0',
+                    'Show Widget Debug Info Dialog = 0',
+                    'Show Startup Dialog = 0',
+                    'Show E-mail Client = 0',
+                    'Show Mail Header Toolbar = 0',
+                    'Show Setupdialog On Start = 0',
+                    'Ask For Usage Stats Percentage = 0',
+                    'Enable Usage Statistics = 0',
+                    'Disable Opera Package AutoUpdate = 1',
+                    'Browser JavaScript = 0',
+                    '',
+                    '[Install]',
+                    'Newest Used Version = 1.00.0000',
+                    '',
+                    '[State]',
+                    'Accept License = 1',
+                    'Run = 0',
+                ].join('\n');
+                // Opera Classic（Presto 内核，≤ v12）：用 -pd 指定 profile 目录，-nomail 禁邮件客户端。
+                // 与 Chromium 风格的 --user-data-dir 完全不同。
+                const profileDir = path.resolve(os.tmpdir(), "test-opera-" + Date.now());
+                fs.mkdirSync(profileDir, { recursive: true });
+                fs.writeFileSync(path.join(profileDir, 'operaprefs.ini'), OPERA_CLASSIC_PREFS, 'utf8');
+                return {
+                    command: "opera",
+                    flags: [
+                        '-pd', profileDir,
+                        '-nomail'
+                    ]
+                };
+            }
+            // Opera（Chromium 内核，≥ v15）
+            return {
+                command: "opera",
+                flags: [
+                    '--user-data-dir=' + path.resolve(os.tmpdir(), "test-opera-" + Date.now()),
+                    '--no-default-browser-check',
+                    '--no-first-run',
+                    '--disable-default-apps'
+                ]
+            };
+        }
+        default:
+            return {};
+    }
+}
+function killBrowser(child, command) {
+    try {
+        if (process.platform === 'win32') {
+            try {
+                child_process.execSync(`taskkill /pid ${child.pid} /T /F`, { stdio: 'ignore' });
+            }
+            catch (e) {
+                if (command.includes('\\')) {
+                    const psCommand = `Get-Process firefox | Where-Object { $_.Path -eq '${command}' } | Stop-Process -Force`;
+                    console.log(`powershell -Command "${psCommand}"`);
+                    child_process.execSync(`powershell -Command "${psCommand}"`, { stdio: 'ignore' });
+                    console.log(`已成功杀掉路径为 ${command} 的 Firefox`);
+                }
+                else {
+                    child_process.execSync(`taskkill /im ${command} /T /F`, { stdio: 'ignore' });
+                }
+            }
+        }
+        else {
+            child.kill('SIGKILL');
+        }
+    }
+    catch (e) {
+        // taskkill 找不到进程 = 进程已经自己死了 = 不需要清理
+        // 这不是错误，这是好事！静默忽略即可。
+        console.log('进程已自行退出，无需清理');
+    }
+}
+/**
+ * 激活浏览器窗口：并行跑多个浏览器时，部分浏览器弹出后在后台不加载页面，
+ * 手动激活才会开始加载（Windows 前台锁机制），导致启动超时。
+ * 启动后延时激活一次窗口可避免。
+ */
+function activateWindow(child) {
+    if (process.platform !== 'win32' || !child.pid)
+        return;
+    setTimeout(() => {
+        try {
+            child_process.exec(`powershell -NoProfile -Command "(New-Object -ComObject WScript.Shell).AppActivate(${child.pid})"`, { stdio: 'ignore', windowsHide: true });
+        }
+        catch (e) { /* 激活失败不影响测试，超时兜底 */ }
+    }, 2000);
+}
+/**
+ * 清除老版本 Opera（< 12.6）上次的会话记录与"未正常退出"状态。
+ *
+ * 这些版本不支持 -pd（参数会被当成 URL 打开成标签页），没法用临时 profile 隔离；
+ * 浏览器被强杀后 profile 里会留下两处痕迹，导致下次启动弹窗询问是否从上次会话继续：
+ *   1. sessions/autosave.win（崩溃恢复会话）—— 改名备份即可
+ *   2. operaprefs.ini 里的 [State] Run=1（标记上次未正常退出）—— 重置为 0
+ * 启动前清理这两处，下次启动就不会再询问，也不会恢复上次的标签页。
+ */
+function clearOperaSessionRecords(version, command) {
+    const appData = process.env.APPDATA;
+    const roots = [];
+    if (appData && version) {
+        roots.push(path.join(appData, 'Opera', version), // 10.x–12.x
+        path.join(appData, 'Opera', version, 'profile') // 9.x
+        );
+    }
+    // Multi User=0 的安装（如 12.17）把 profile 放在安装目录下，不受 -pd 控制
+    if (command && path.isAbsolute(command)) {
+        const installDir = path.dirname(command);
+        roots.push(path.join(installDir, 'profile'), installDir);
+    }
+    for (const root of roots) {
+        const sessions = path.join(root, 'sessions');
+        for (const name of ['autosave.win', 'autosave.win.bak']) {
+            const file = path.join(sessions, name);
+            try {
+                fs.unlinkSync(file + '.cleared');
+            }
+            catch {
+                // 上一次的备份不存在，忽略
+            }
+            try {
+                fs.renameSync(file, file + '.cleared');
+            }
+            catch {
+                // 文件不存在（从未异常退出）或被占用时忽略
+            }
+        }
+        // 9.x 的配置文件叫 opera6.ini，10.x–12.x 才叫 operaprefs.ini
+        for (const name of ['operaprefs.ini', 'opera6.ini']) {
+            const prefs = path.join(root, name);
+            try {
+                const text = fs.readFileSync(prefs, 'utf8');
+                const fixed = text.replace(/^Run=1\r?$/m, 'Run=0');
+                if (fixed !== text)
+                    fs.writeFileSync(prefs, fixed, 'utf8');
+            }
+            catch {
+                // prefs 读取失败时不影响启动
+            }
+        }
+    }
+}
+function run(options) {
+    var url, command, child;
+    var timeout;
+    return new Promise(function (resolve, reject) {
+        let resolvedOptions = {};
+        if (options.preset) {
+            let presetOptions = genPresetOptions(options.preset, options.version);
+            resolvedOptions = {
+                ...presetOptions,
+                ...options,
+            };
+            if (options.flags && presetOptions.flags) {
+                resolvedOptions.flags = [...presetOptions.flags, ...options.flags];
+            }
+        }
+        else {
+            resolvedOptions = options;
+        }
+        let { flags } = resolvedOptions;
+        url = resolvedOptions.url;
+        command = resolvedOptions.command;
+        timeout = resolvedOptions.timeout || 10000;
+        // Opera（含 -pd 被忽略的单用户安装，如 12.17）启动前清理上次未正常退出留下的
+        // 会话与 Run=1 状态，否则会弹出"继续上次会话"/欢迎对话框，阻塞页面加载
+        if (options.preset === 'Opera') {
+            clearOperaSessionRecords(options.version, command);
+        }
+        // 老版本 Opera 会把 URL 之后的参数当成额外 URL 各开一个标签页，
+        // 所以 flags 必须放在 URL 前面（例如 `opera -pd <dir> -nomail <url>`）
+        let args = [];
+        if (flags)
+            args.push(...flags);
+        args.push(url);
+        child = child_process.spawn(command, args);
+        // 后台窗口可能不加载页面，延时激活一次
+        activateWindow(child);
+        let startTimer = setTimeout(() => {
+            // 超时的浏览器也要杀掉，否则残留进程会一直占住父进程的事件循环
+            killBrowser(child, command);
+            reject(new Error("Browser run timed out on: " + command));
+        }, timeout);
+        testStartEmitter.once(url, function () {
+            clearTimeout(startTimer);
+            resolve();
+        });
+    }).then(function () {
+        return new Promise(function (resolve, reject) {
+            let runTimer = setTimeout(() => {
+                killBrowser(child, command);
+                reject(new Error("Test run timed out on: " + url));
+            }, timeout);
+            testEndEmitter.once(url, function (data) {
+                clearTimeout(runTimer);
+                var result = toTestResult(data);
+                resolve(result);
+                logTestResult(options, result);
+                killBrowser(child, command);
+            });
+        });
+    });
+}
+function toTestResult(data) {
+    // 表单 POST 上来的都是字符串，统一转成数字，
+    // 防止上层 report 求和/比较时变成字符串拼接
+    var result = {
+        passed: Number(data.passed) || 0,
+        total: Number(data.total) || 0,
+        runtime: Number(data.runtime) || 0
+    };
+    if (data.failures != null) {
+        result.failures = Number(data.failures) || 0;
+        var details = [];
+        for (var i = 0; i < result.failures && i < 50; i++) {
+            var detail = data["fail" + i];
+            if (detail != null)
+                details.push(String(detail));
+        }
+        if (details.length)
+            result.failureDetails = details;
+    }
+    return result;
+}
+function logTestResult(options, result) {
+    const browser = options.browser || options.preset || 'Unknown';
+    const version = options.version || '';
+    const failed = result.total - result.passed;
+    const isSuccess = failed === 0;
+    const timeStr = `${result.runtime}ms`;
+    if (isSuccess) {
+        // 🟢 全部通过：绿色高亮，粗体强调通过数
+        console.log(pc.green('✓') + ' ' +
+            pc.green(pc.bold(`${browser} v${version}:`)) + ' ' +
+            pc.green(`${result.passed}/${result.total} passed`) + ' ' +
+            pc.dim(`(${timeStr})`));
+    }
+    else {
+        // 🔴 存在失败：红色高亮，粗体强调失败数
+        console.log(pc.red('✗') + ' ' +
+            pc.red(pc.bold(`${browser} v${version}:`)) + ' ' +
+            pc.red(`${result.passed}/${result.total} failed`) + ' ' +
+            pc.dim(`(${timeStr})`));
+    }
+}
+
+function runQueue(tasks) {
+    if (tasks.length) {
+        let [task, ...rest] = tasks;
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve();
+            }, 200);
+        }).then(() => {
+            return runNext(task, rest);
+        });
+    }
+    else {
+        return Promise.resolve([]);
+    }
+}
+function runNext(task, tasks) {
+    var r;
+    return run(task).then(function (result) {
+        r = { status: "fulfilled", value: result };
+        return runQueue(tasks);
+    }, function (err) {
+        // 单个任务失败（浏览器启动失败/超时）不中断队列，
+        // 错误以 { status: "rejected", reason } 记入结果，继续后面的任务
+        r = { status: "rejected", reason: err };
+        return runQueue(tasks);
+    }).then(function (results) {
+        results.unshift(r);
+        return results;
+    });
+}
+
+async function scan(pattern, options) {
+    let paths = await tinyglobby.glob(pattern, {
+        cwd: options.cwd || process.cwd(),
+        absolute: true,
+        caseSensitiveMatch: true,
+    });
+    let regex = picomatch.makeRe(pattern, { capture: true, nocase: false });
+    let results = paths.map(fake => {
+        let result = fake.match(regex);
+        let [real, ...args] = result;
+        real = fs.realpathSync.native(real);
+        return [real, ...args];
+    });
+    if (options.filter) {
+        results = results.filter(function (result, index) {
+            return options.filter.apply(null, result);
+        });
+    }
+    let tasks = results.map(function (result, index) {
+        return options.map.apply(null, result);
+    });
+    return tasks;
+}
+
+function callMiddleware() {
+    return function (req, res, next) {
+        if (req.method === "GET") {
+            const protocol = req.socket?.encrypted ? 'https' : 'http';
+            const host = req.headers.host;
+            const fullUrl = `${protocol}://${host}${req.originalUrl}`;
+            testStartEmitter.emit(fullUrl);
+        }
+        else if (req.method === "POST") {
+            if (req.url === "/") {
+                let body = '';
+                req.on('data', (chunk) => {
+                    body += chunk.toString();
+                });
+                req.on('end', () => {
+                    // 保持原始 querystring 对象直接下发；
+                    // 字段归一化（数字转换 + failN → failureDetails）统一在 run() 的 toTestResult 里做
+                    const data = querystring.parse(body);
+                    let referer = req.headers.referer;
+                    res.statusCode = 200;
+                    res.setHeader('Content-Type', 'text/html');
+                    res.end('<html><body><script>window.close()</script><body></html>');
+                    setTimeout(() => {
+                        testEndEmitter.emit(referer, data);
+                    }, 1000);
+                });
+                return;
+            }
+        }
+        next();
+    };
+}
+
+const unaryTags = new Set(['link', 'meta', 'base', 'br', 'hr', 'input', 'img']);
+function serializeTags(tags) {
+    return tags.map((tag) => `${serializeTag(tag)}`).join('');
+}
+function serializeTag({ tag, attrs, children }) {
+    if (unaryTags.has(tag)) {
+        return `<${tag}${serializeAttrs(attrs)}>`;
+    }
+    else {
+        if (Array.isArray(children)) {
+            return `<${tag}${serializeAttrs(attrs)}>${serializeTags(children)}</${tag}>`;
+        }
+        else if (children) {
+            return `<${tag}${serializeAttrs(attrs)}>${children}</${tag}>`;
+        }
+        else {
+            return `<${tag}${serializeAttrs(attrs)}></${tag}>`;
+        }
+    }
+}
+function serializeAttrs(attrs) {
+    let res = '';
+    for (const key in attrs) {
+        if (typeof attrs[key] === 'boolean') {
+            res += attrs[key] ? ` ${key}` : ``;
+        }
+        else {
+            res += ` ${escapeHTML(key)}="${escapeHTML(attrs[key])}"`;
+        }
+    }
+    return res;
+}
+function insertHtmlNode(html, tags) {
+    // 处理入口（html）
+    var dom = parse5.parse(html, { sourceCodeLocationInfo: true });
+    let magicString = new MagicString.default(html);
+    /** 遍历树处理JS */
+    const eachJSNode = (node) => {
+        if (node.tagName == "head") {
+            tags.forEach((tag) => {
+                if (tag.injectTo == "head-prepend" || !tag.injectTo) {
+                    magicString.appendRight(node.sourceCodeLocation.startTag.endOffset, serializeTag(tag));
+                }
+                else if (tag.injectTo == "head") {
+                    magicString.appendRight(node.sourceCodeLocation.endTag.startOffset, serializeTag(tag));
+                }
+            });
+        }
+        else if (node.tagName == "body") {
+            tags.forEach((tag) => {
+                if (tag.injectTo == "body-prepend") {
+                    magicString.appendRight(node.sourceCodeLocation.startTag.endOffset, serializeTag(tag));
+                }
+                else if (tag.injectTo == "body") {
+                    magicString.appendRight(node.sourceCodeLocation.endTag.startOffset, serializeTag(tag));
+                }
+            });
+        }
+        if (node.childNodes && node.childNodes.length) {
+            for (let child of node.childNodes) {
+                eachJSNode.call(node, child);
+            }
+        }
+    };
+    eachJSNode(dom);
+    return magicString.toString();
+}
+/**
+ * 解析请求 URL，确定对应的 HTML 文件路径：
+ * - /page.html       → root/page.html
+ * - /subdir/         → root/subdir/index.html
+ * - /subdir          → root/subdir/index.html
+ * - /                → root/index.html
+ * - 其他（.js/.css）  → null（跳过，交给 serve-static）
+ */
+function resolveHtmlPath(url, root) {
+    const ext = path.extname(url);
+    if (ext === '.html') {
+        return path.join(root, url);
+    }
+    if (!ext || url.endsWith('/')) {
+        return path.join(root, url, 'index.html');
+    }
+    return null;
+}
+async function fileExists(filePath) {
+    try {
+        await fs.promises.access(filePath, fs.constants.R_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * HTML 中间件：
+ * 1. 判断请求是否为 HTML（.html 或目录/index.html）
+ * 2. 依次调用 loadHtml 钩子；首个返回非空字符串者直接作为 HTML（跳过磁盘读取）
+ * 3. 无钩子命中时回退到读取磁盘文件
+ * 4. 如果提供了 transformHtml 自定义转换规则，执行它（支持异步）
+ */
+function htmlMiddleware(root, htmlTransformers, loadHtmlHooks) {
+    return async function (req, res, next) {
+        const url = req.url;
+        const filePath = resolveHtmlPath(url, root);
+        // 非 HTML 请求，交给后续中间件处理
+        if (!filePath) {
+            return next();
+        }
+        try {
+            // Step 1: 调用 loadHtml 钩子，首个命中即采用
+            let html;
+            if (loadHtmlHooks) {
+                for (const hook of loadHtmlHooks) {
+                    const result = await hook(url);
+                    if (result != null) {
+                        html = result;
+                        break;
+                    }
+                }
+            }
+            // Step 2: 无钩子命中，回退到磁盘文件
+            if (html == null) {
+                // 文件不存在，交给 serve-static 返回 404
+                if (!(await fileExists(filePath))) {
+                    return next();
+                }
+                html = await fs.promises.readFile(filePath, 'utf-8');
+            }
+            // Step 3: 执行 transformHtml 转换规则（支持异步）
+            if (htmlTransformers) {
+                let ctx = { filename: url };
+                for (let hook of htmlTransformers) {
+                    let r = await hook(html, ctx);
+                    if (r) {
+                        if (typeof r === "string") {
+                            html = r;
+                        }
+                        else if (Array.isArray(r) || r instanceof Array) {
+                            html = insertHtmlNode(html, r);
+                        }
+                        else {
+                            html = insertHtmlNode(r.html, r.tags);
+                        }
+                    }
+                }
+            }
+            res.setHeader('Content-Type', 'text/html; charset=utf-8');
+            res.end(html);
+        }
+        catch (err) {
+            console.error('HTML transform error:', err);
+            res.statusCode = 500;
+            res.end('HTML transform error');
+        }
+    };
+}
+
+function proxyMiddleware(proxyTable) {
+    const proxies = {};
+    Object.keys(proxyTable).forEach(function (context) {
+        let opts = proxyTable[context];
+        if (!opts) {
+            return;
+        }
+        if (typeof opts === 'string') {
+            opts = { target: opts, changeOrigin: true };
+        }
+        let { rewrite, configure, bypass, ...proxyOptions } = opts;
+        const proxy = HttpProxy.createProxyServer(proxyOptions);
+        if (opts.configure) {
+            opts.configure(proxy, opts);
+        }
+        proxy.on('error', (err, req, res) => {
+            // When it is ws proxy, res is net.Socket
+            // originalRes can be falsy if the proxy itself errored
+            if (!res) {
+                console.error(`${pc.red(`http proxy error: ${err.message}`)}\n${err.stack}`);
+            }
+            else if ('req' in res) {
+                console.error(`${pc.red(`http proxy error at ${res.req.url}:`)}\n${err.stack}`);
+                if (!res.headersSent && !res.writableEnded) {
+                    res
+                        .writeHead(500, {
+                        'Content-Type': 'text/plain',
+                    })
+                        .end();
+                }
+            }
+            else {
+                console.error(`${pc.red(`ws proxy error:`)}\n${err.stack}`);
+                res.end();
+            }
+        });
+        proxies[context] = [proxy, opts];
+    });
+    return function (req, res, next) {
+        const url = req.url;
+        for (const context in proxies) {
+            if (doesProxyContextMatchUrl(context, url)) {
+                const [proxy, opts] = proxies[context];
+                const { rewrite, configure, bypass, ...proxyOptions } = opts;
+                const options = {};
+                if (bypass) {
+                    const bypassResult = bypass(req, res, proxyOptions);
+                    if (typeof bypassResult === 'string') {
+                        req.url = bypassResult;
+                        console.debug(`bypass: ${req.url} -> ${bypassResult}`);
+                        return next();
+                    }
+                    else if (typeof bypassResult === 'object') {
+                        Object.assign(options, bypassResult);
+                        console.debug(`bypass: ${req.url} use modified options: %O ` + JSON.stringify(options));
+                        return next();
+                    }
+                    else if (bypassResult === false) {
+                        console.debug(`bypass: ${req.url} -> 404`);
+                        return res.end(404);
+                    }
+                }
+                console.debug(`${req.url} -> ${opts.target || opts.forward}`);
+                if (rewrite) {
+                    req.url = rewrite(req.url);
+                }
+                proxy.web(req, res, options);
+                return;
+            }
+        }
+        next();
+    };
+}
+function doesProxyContextMatchUrl(context, url) {
+    return ((context.charAt(0) === '^' && new RegExp(context).test(url)) ||
+        url.startsWith(context));
+}
+
+function queryMiddleware() {
+    return function (req, res, next) {
+        let url = req.originalUrl;
+        if (url) {
+            var index = url.indexOf("?");
+            if (index >= 0) {
+                req.url = url.substring(0, index);
+                req.query = querystring.parse(url.substring(index + 1));
+            }
+        }
+        next();
+    };
+}
+
+// 禁缓存响应头：测试服务器每次都应返回最新构建产物。
+// no-store 只能阻止新的缓存写入，浏览器已存在的缓存条目不受影响，
+// 需要彻底干净的场合配合浏览器的空缓存目录（见 run.ts 的 Chrome preset）。
+const DEFAULT_HEADERS = {
+    "Cache-Control": "no-store",
+    "Pragma": "no-cache",
+    "Expires": "0"
+};
+async function serve(options = {}) {
+    const resolvedOptions = {
+        root: process.cwd(),
+        port: 80,
+        host: "localhost",
+        https: false,
+        contextPath: "/",
+        ...options
+    };
+    const { root, port, host, https, cors, contextPath, proxy, plugins, headers } = resolvedOptions;
+    const htmlTransformers = resolvedOptions.htmlTransformers
+        || (plugins && plugins.map(p => p.transformHtml).filter(Boolean));
+    const loadHtmlHooks = plugins && plugins.map(p => p.loadHtml).filter(Boolean);
+    let app = connect();
+    // configureServer：内置中间件 use 之前运行（支持异步）。
+    // 返回的函数被收集，等内置中间件 use 完之后再依次运行。
+    const configureServerHooks = plugins && plugins.map(p => p.configureServer).filter(Boolean);
+    const ctx = { middlewares: app };
+    const postHooks = [];
+    if (configureServerHooks) {
+        for (const hook of configureServerHooks) {
+            const result = await hook(ctx);
+            if (typeof result === "function") {
+                postHooks.push(result);
+            }
+        }
+    }
+    // 响应头：默认禁缓存，headers 选项可覆盖/追加同名头以外的自定义头
+    const mergedHeaders = Object.assign({}, DEFAULT_HEADERS, headers);
+    app.use(function (_req, res, next) {
+        for (const key in mergedHeaders) {
+            res.setHeader(key, mergedHeaders[key]);
+        }
+        next();
+    });
+    if (proxy) {
+        app.use(proxyMiddleware(proxy));
+    }
+    app.use(queryMiddleware());
+    app.use(callMiddleware());
+    app.use(contextPath, htmlMiddleware(root, htmlTransformers, loadHtmlHooks));
+    app.use(contextPath, serveStatic(root, { index: ['index.html'] }));
+    // configureServer 返回的回调：内置中间件 use 之后运行（支持异步）
+    for (const hook of postHooks) {
+        await hook(ctx);
+    }
+    return new Promise((resolve, reject) => {
+        let httpServer = app.listen(port, host, function (error) {
+            if (error) {
+                reject(error);
+                return;
+            }
+            let fullUrl = (https ? "https" : "http") + "://" + (host || "localhost") + ":" + port + contextPath;
+            console.info(`Server is running at ${pc.cyan(fullUrl)}`);
+            resolve(httpServer);
+        });
+    });
+}
+
+exports.EmulateIE = EmulateIE;
+exports.Mocha = Mocha;
+exports.QUnit = QUnit;
+exports.judge = judge;
+exports.report = report;
+exports.run = run;
+exports.runQueue = runQueue;
+exports.scan = scan;
+exports.serve = serve;