qunitx-cli 0.22.3 → 0.23.0

package/dist/cli.js

@@ -287,14 +287,35 @@ var init_perf_logger = __esm({
   }
 });
 
+// lib/utils/daemon-socket-path.ts
+import { createHash } from "node:crypto";
+import os2 from "node:os";
+import path2 from "node:path";
+function cwdHash(cwd) {
+  return createHash("sha256").update(cwd).digest("hex").slice(0, 12);
+}
+function daemonSocketPath(cwd = process.cwd(), platform = process.platform) {
+  const name = `qunitx-daemon-${cwdHash(cwd)}`;
+  if (platform === "win32") return `\\\\.\\pipe\\${name}`;
+  return path2.join(os2.tmpdir(), `${name}.sock`);
+}
+function daemonInfoPath(cwd = process.cwd()) {
+  return path2.join(os2.tmpdir(), `qunitx-daemon-${cwdHash(cwd)}.json`);
+}
+var init_daemon_socket_path = __esm({
+  "lib/utils/daemon-socket-path.ts"() {
+  }
+});
+
 // lib/utils/chrome-prelaunch.ts
+import { existsSync } from "node:fs";
 async function shutdownPrelaunch() {
   if (!earlyChrome) return;
   const { shutdown } = earlyChrome;
   earlyChrome = null;
   await shutdown();
 }
-var NON_RUN_COMMANDS, isRunCommand, browserFromArgv, openFromArgv, watchFromArgv, openWatchMode, earlyChrome, prelaunchPromise;
+var NON_RUN_COMMANDS, cmd, isDaemonControlCmd, isRunCommand, browserFromArgv, openFromArgv, watchFromArgv, isDaemonClientRun, openWatchMode, earlyChrome, prelaunchPromise;
 var init_chrome_prelaunch = __esm({
   "lib/utils/chrome-prelaunch.ts"() {
     init_find_chrome();
@@ -302,8 +323,11 @@ var init_chrome_prelaunch = __esm({
     init_kill_process_group();
     init_chromium_args();
     init_perf_logger();
+    init_daemon_socket_path();
     NON_RUN_COMMANDS = /* @__PURE__ */ new Set(["help", "h", "p", "print", "new", "n", "g", "generate", "init"]);
-    isRunCommand = Boolean(process.argv[2]) && !NON_RUN_COMMANDS.has(process.argv[2]);
+    cmd = process.argv[2];
+    isDaemonControlCmd = cmd === "daemon" && process.argv[3] !== "_serve";
+    isRunCommand = Boolean(cmd) && !NON_RUN_COMMANDS.has(cmd) && !isDaemonControlCmd;
     ({ browserFromArgv, openFromArgv, watchFromArgv } = process.argv.reduce(
       (flags, arg) => {
         if (arg.startsWith("--browser=")) flags.browserFromArgv = arg.slice(10);
@@ -319,6 +343,10 @@ var init_chrome_prelaunch = __esm({
         watchFromArgv: false
       }
     ));
+    isDaemonClientRun = isRunCommand && cmd !== "daemon" && !watchFromArgv && !openFromArgv && !process.env.QUNITX_NO_DAEMON && !process.argv.includes("--no-daemon") && (!process.env.CI || Boolean(process.env.QUNITX_DAEMON)) && // Check the info file rather than the socket path: on Windows the socket is a named
+    // pipe (\\.\pipe\...), which existsSync cannot see. The info file is always a regular
+    // file in os.tmpdir() and is created/removed in lockstep with the daemon's lifetime.
+    (Boolean(process.env.QUNITX_DAEMON) || existsSync(daemonInfoPath()));
     openWatchMode = openFromArgv && watchFromArgv;
     earlyChrome = null;
     if (!openWatchMode) {
@@ -328,7 +356,7 @@ var init_chrome_prelaunch = __esm({
       });
     }
     perfLog("chrome-prelaunch.ts: module evaluated");
-    prelaunchPromise = isRunCommand && browserFromArgv === "chromium" && process.platform !== "darwin" ? findChrome().then((chromePath) => {
+    prelaunchPromise = isRunCommand && !isDaemonClientRun && browserFromArgv === "chromium" && process.platform !== "darwin" ? findChrome().then((chromePath) => {
       perfLog("chrome-prelaunch.ts: findChrome resolved", chromePath);
       return preLaunchChrome(chromePath, CHROMIUM_ARGS, !openWatchMode);
     }).then((info) => {
@@ -339,6 +367,91 @@ var init_chrome_prelaunch = __esm({
   }
 });
 
+// package.json
+var package_default;
+var init_package = __esm({
+  "package.json"() {
+    package_default = {
+      name: "qunitx-cli",
+      type: "module",
+      version: "0.23.0",
+      description: "Browser runner for QUnitx: run your qunitx tests in google-chrome",
+      author: "Izel Nakri",
+      license: "MIT",
+      keywords: [
+        "test runner",
+        "testing",
+        "browser",
+        "ci",
+        "qunit",
+        "qunitx"
+      ],
+      files: [
+        "bin/",
+        "dist/",
+        "templates/"
+      ],
+      scripts: {
+        build: "node scripts/build-cli.js",
+        bin: "chmod +x cli.ts && ./cli.ts",
+        prepublishOnly: "npm run build",
+        format: 'prettier --check "lib/**/*.ts" "test/**/*.ts" "scripts/**/*.js" "bin/**/*.js" "*.ts" "package.json" ".github/**/*.yml"',
+        "format:fix": 'prettier --write "lib/**/*.ts" "test/**/*.ts" "scripts/**/*.js" "bin/**/*.js" "*.ts" "package.json" ".github/**/*.yml"',
+        lint: "deno lint lib/ bin/ cli.ts",
+        "lint:docs": "node scripts/lint-docs.js",
+        docs: `deno doc --html --name="qunitx-cli" --output=docs/lib 'lib/**/*.ts' README.md`,
+        "changelog:unreleased": "git-cliff --unreleased --strip all",
+        "changelog:preview": "git-cliff",
+        "changelog:update": "git-cliff --output CHANGELOG.md",
+        postinstall: "PLAYWRIGHT_SKIP_DOWNLOAD=true deno install --allow-scripts=npm:playwright-core || true",
+        test: "node test/runner.ts",
+        "test:debug": "QUNITX_DEBUG=1 node test/runner.ts",
+        dev: "node test/runner.ts --watch",
+        "test:browser": "node test/runner.ts test/flags/*-test.ts test/inputs/*-test.ts",
+        "test:release": "bash scripts/test-release.sh",
+        "test:sanity-first": "./cli.ts test/helpers/failing-tests.js test/helpers/failing-tests.ts",
+        "test:sanity-second": "./cli.ts test/helpers/passing-tests.js test/helpers/passing-tests.ts"
+      },
+      engines: {
+        node: ">=24.0.0",
+        deno: ">=2.7.0"
+      },
+      bin: {
+        qunitx: "bin/qunitx.js"
+      },
+      repository: {
+        type: "git",
+        url: "git+https://github.com/izelnakri/qunitx-cli.git"
+      },
+      dependencies: {
+        esbuild: "^0.28.0",
+        "playwright-core": "^1.59.1",
+        ws: "^8.20.0"
+      },
+      devDependencies: {
+        "js-yaml": "^4.1.1",
+        prettier: "^3.8.3",
+        qunitx: "^1.2.9",
+        react: "^19.2.5",
+        "react-dom": "^19.2.5",
+        typescript: "^6.0.3",
+        vue: "^3.5.33"
+      },
+      volta: {
+        node: "24.14.0"
+      },
+      prettier: {
+        printWidth: 100,
+        singleQuote: true,
+        arrowParens: "always"
+      },
+      optionalDependencies: {
+        "qunitx-cli-linux-x64": "*"
+      }
+    };
+  }
+});
+
 // lib/utils/color.ts
 function createColors(enabled2) {
   const makeColor = (open, close) => (text) => enabled2 ? `\x1B[${open}m${text}\x1B[${close}m` : String(text);
@@ -377,18 +490,109 @@ var init_color = __esm({
   }
 });
 
-// lib/setup/default-project-config-values.ts
-var defaultProjectConfigValues;
-var init_default_project_config_values = __esm({
-  "lib/setup/default-project-config-values.ts"() {
-    defaultProjectConfigValues = {
-      output: "tmp",
-      timeout: 2e4,
-      failFast: false,
-      port: 1234,
-      extensions: ["js", "ts", "jsx", "tsx"],
-      browser: "chromium"
-    };
+// lib/commands/help.ts
+var help_exports = {};
+__export(help_exports, {
+  default: () => displayHelpOutput,
+  displayHelpOutput: () => displayHelpOutput
+});
+function displayHelpOutput() {
+  const config = package_default;
+  console.log(`${highlight("[qunitx v" + config.version + "] Usage:")} qunitx ${color("[targets] --$flags")}
+
+${highlight("Input options:")}
+- File: $ ${color("qunitx test/foo.js")}
+- Folder: $ ${color("qunitx test/login")}
+- Globs: $ ${color("qunitx test/**/*-test.js")}
+- Combination: $ ${color("qunitx test/foo.js test/bar.js test/*-test.js test/logout")}
+
+${highlight("Optional flags:")}
+${color("--debug")} : print console output when tests run in browser
+${color("--watch")} : run the target file or folders, watch them for continuous run and expose http server under localhost
+${color("--open")} : run tests in a visible browser window instead of headless; keeps the server alive (short: ${color("-o")})
+${color("--timeout")} : change default timeout per test case
+${color("--output")} : folder to distribute built qunitx html and js that a webservers can run[default: tmp]
+${color("--failFast")} : run the target file or folders with immediate abort if a single test fails
+${color("--port")} : HTTP server port (auto-selects a free port if the given port is taken)[default: 1234]
+${color("--extensions")} : comma-separated file extensions to track for discovery and watch-mode rebuilds[default: js,ts,jsx,tsx]
+${color("--browser")} : browser engine to run tests in: chromium, firefox, webkit[default: chromium]
+${color("--before")} : run a script before the tests(i.e start a new web server before tests)
+${color("--after")} : run a script after the tests(i.e save test results to a file)
+${color("--no-daemon")} : don't use the daemon for this run \u2014 skips a running daemon and prevents ${color("QUNITX_DAEMON")} auto-spawn
+
+${highlight("Example:")} $ ${color("qunitx test/foo.ts app/e2e --debug --watch --before=scripts/start-new-webserver.js --after=scripts/write-test-results.js")}
+
+${highlight("Commands:")}
+${color("$ qunitx init")}                            # Bootstraps qunitx base html and add qunitx config to package.json if needed
+${color("$ qunitx new $testFileName")}               # Creates a qunitx test file
+${color("$ qunitx daemon <start|stop|status>")}      # Optional persistent daemon \u2014 ~2\xD7 faster repeated runs
+
+${highlight("Environment:")}
+${color("QUNITX_DAEMON=1")}     : auto-spawn the daemon on the first qunitx run; reuse it on every run after (overrides the CI=1 bypass)
+${color("QUNITX_NO_DAEMON=1")}  : never use the daemon for this run
+`);
+}
+var highlight, color;
+var init_help = __esm({
+  "lib/commands/help.ts"() {
+    init_color();
+    init_package();
+    highlight = (text) => magenta().bold(text);
+    color = (text) => blue(text);
+  }
+});
+
+// lib/utils/path-exists.ts
+import fs2 from "node:fs/promises";
+async function pathExists(path14) {
+  try {
+    await fs2.access(path14);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_path_exists = __esm({
+  "lib/utils/path-exists.ts"() {
+  }
+});
+
+// lib/utils/search-in-parent-directories.ts
+async function searchInParentDirectories(directory, targetEntry) {
+  const resolvedDirectory = directory === "." ? process.cwd() : directory;
+  if (await pathExists(`${resolvedDirectory}/${targetEntry}`)) {
+    return `${resolvedDirectory}/${targetEntry}`;
+  } else if (resolvedDirectory === "") {
+    return;
+  }
+  return await searchInParentDirectories(
+    resolvedDirectory.slice(0, resolvedDirectory.lastIndexOf("/")),
+    targetEntry
+  );
+}
+var init_search_in_parent_directories = __esm({
+  "lib/utils/search-in-parent-directories.ts"() {
+    init_path_exists();
+  }
+});
+
+// lib/utils/find-project-root.ts
+import process2 from "node:process";
+async function findProjectRoot() {
+  try {
+    const absolutePath = await searchInParentDirectories(".", "package.json");
+    if (!absolutePath.includes("package.json")) {
+      throw new Error("package.json mising");
+    }
+    return absolutePath.replace("/package.json", "");
+  } catch (_error) {
+    console.log("couldnt find projects package.json, did you run $ npm init ??");
+    process2.exit(1);
+  }
+}
+var init_find_project_root = __esm({
+  "lib/utils/find-project-root.ts"() {
+    init_search_in_parent_directories();
   }
 });
 
@@ -415,90 +619,702 @@ var init_read_template = __esm({
   }
 });
 
-// lib/utils/find-internal-assets-from-html.ts
-function findInternalAssetsFromHTML(htmlContent) {
-  const links = [...htmlContent.matchAll(LINK_HREF_REGEX)].map((match) => match[1]).filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));
-  const scripts = [...htmlContent.matchAll(SCRIPT_SRC_REGEX)].map((match) => match[1]).filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));
-  return links.concat(scripts);
+// lib/utils/convert-to-pascal-case.ts
+function convertToPascalCase(str) {
+  return str.split(/[-_]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
 }
-var ABSOLUTE_URL_REGEX, SCRIPT_SRC_REGEX, LINK_HREF_REGEX;
-var init_find_internal_assets_from_html = __esm({
-  "lib/utils/find-internal-assets-from-html.ts"() {
-    ABSOLUTE_URL_REGEX = /^(?:[a-z]+:)?\/\//i;
-    SCRIPT_SRC_REGEX = /<script[^>]+\bsrc=['"]([^'"]+)['"]/gi;
-    LINK_HREF_REGEX = /<link[^>]+\bhref=['"]([^'"]+)['"]/gi;
+var init_convert_to_pascal_case = __esm({
+  "lib/utils/convert-to-pascal-case.ts"() {
   }
 });
 
-// lib/utils/html.ts
-function findScriptPlaceholder(html) {
-  return html.includes(SCRIPT_PLACEHOLDER) ? SCRIPT_PLACEHOLDER : void 0;
+// lib/commands/generate.ts
+var generate_exports = {};
+__export(generate_exports, {
+  default: () => generateTestFiles,
+  generateTestFiles: () => generateTestFiles
+});
+import fs4 from "node:fs/promises";
+async function generateTestFiles() {
+  const projectRoot = await findProjectRoot();
+  const moduleName = pathToModuleName(process.argv[3]);
+  const path14 = process.argv[3].endsWith(".js") || process.argv[3].endsWith(".ts") ? `${projectRoot}/${process.argv[3]}` : `${projectRoot}/${process.argv[3]}.js`;
+  if (await pathExists(path14)) {
+    console.log(`${path14} already exists!`);
+    return;
+  }
+  const testJSContent = await readTemplate("test.js");
+  const targetFolderPaths = path14.split("/");
+  targetFolderPaths.pop();
+  await fs4.mkdir(targetFolderPaths.join("/"), { recursive: true });
+  await fs4.writeFile(path14, testJSContent.replace("{{moduleName}}", moduleName));
+  console.log(green(`${path14} written`));
 }
-function isCustomTemplate(html) {
-  return !!findScriptPlaceholder(html) || HANDLEBARS_TOKEN_REGEX.test(html);
+function pathToModuleName(filePath) {
+  const withoutExt = filePath.replace(/\.(js|ts)$/, "");
+  const segments = withoutExt.split("/");
+  const targetNames = segments[0] === "test" || segments[0] === "tests" ? segments.slice(1) : segments;
+  return targetNames.map(convertToPascalCase).join(" | ");
 }
-function injectScript(html, content) {
-  const placeholder = findScriptPlaceholder(html);
-  if (placeholder) {
-    return html.replace(placeholder, content);
-  }
-  if (isCustomTemplate(html)) {
-    if (html.includes("</body>")) {
-      return html.replace("</body>", `${content}</body>`);
-    }
-    if (html.includes("</html>")) {
-      return html.replace("</html>", `${content}</html>`);
-    }
-    return `${html}${content}`;
+var init_generate = __esm({
+  "lib/commands/generate.ts"() {
+    init_color();
+    init_find_project_root();
+    init_path_exists();
+    init_read_template();
+    init_convert_to_pascal_case();
   }
-  return html;
-}
-var SCRIPT_PLACEHOLDER, HANDLEBARS_TOKEN_REGEX;
-var init_html = __esm({
-  "lib/utils/html.ts"() {
-    SCRIPT_PLACEHOLDER = "{{qunitxScript}}";
-    HANDLEBARS_TOKEN_REGEX = /{{\s*[^}]+\s*}}/;
+});
+
+// lib/setup/default-project-config-values.ts
+var defaultProjectConfigValues;
+var init_default_project_config_values = __esm({
+  "lib/setup/default-project-config-values.ts"() {
+    defaultProjectConfigValues = {
+      output: "tmp",
+      timeout: 2e4,
+      failFast: false,
+      port: 1234,
+      extensions: ["js", "ts", "jsx", "tsx"],
+      browser: "chromium"
+    };
   }
 });
 
-// lib/tap/dump-yaml.ts
-function dumpYaml({
-  name,
-  actual,
-  expected,
-  message,
-  stack,
-  source,
-  at
-}) {
-  return `name: ${dumpString(name, "")}
-` + yamlLine("actual", actual) + yamlLine("expected", expected) + (message !== null ? yamlLine("message", message) : "") + (stack !== null ? yamlLine("stack", stack) : "") + (source !== null ? yamlLine("source", source) : "") + (at !== null ? yamlLine("at", at) : "");
+// lib/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  default: () => initializeProject,
+  initializeProject: () => initializeProject
+});
+import fs5 from "node:fs/promises";
+import path3 from "node:path";
+async function initializeProject() {
+  const projectRoot = await findProjectRoot();
+  const oldPackageJSON = JSON.parse(await fs5.readFile(`${projectRoot}/package.json`));
+  const existingQunitx = oldPackageJSON.qunitx || {};
+  const cliHtmlPaths = process.argv.slice(2).filter((arg) => arg.endsWith(".html"));
+  const config = Object.assign({}, defaultProjectConfigValues, existingQunitx, {
+    htmlPaths: cliHtmlPaths.length > 0 ? cliHtmlPaths : existingQunitx.htmlPaths || ["test/tests.html"]
+  });
+  await Promise.all([
+    writeTestsHTML(projectRoot, config, oldPackageJSON),
+    rewritePackageJSON(projectRoot, config, oldPackageJSON),
+    writeTSConfigIfNeeded(projectRoot)
+  ]);
 }
-function needsQuoting(str) {
-  return NEEDS_QUOTING.test(str);
+async function writeTestsHTML(projectRoot, config, oldPackageJSON) {
+  const testHTMLTemplateBuffer = await readTemplate("setup/tests.hbs");
+  return await Promise.all(
+    config.htmlPaths.map(async (htmlPath) => {
+      const targetPath = `${projectRoot}/${htmlPath}`;
+      if (await pathExists(targetPath)) {
+        return console.log(`${htmlPath} already exists`);
+      } else {
+        const targetDirectory = path3.dirname(targetPath);
+        const _targetOutputPath = path3.relative(
+          targetDirectory,
+          path3.join(path3.resolve(projectRoot, config.output), "tests.js")
+        );
+        const testHTMLTemplate = testHTMLTemplateBuffer.replace(
+          "{{applicationName}}",
+          oldPackageJSON.name
+        );
+        await fs5.mkdir(targetDirectory, { recursive: true });
+        await fs5.writeFile(targetPath, testHTMLTemplate);
+        console.log(`${targetPath} written`);
+      }
+    })
+  );
 }
-function dumpString(str, indent) {
-  if (str === "") return "''";
-  if (str.includes("\n")) {
-    return "|-\n" + str.replace(/^/gm, `${indent}  `);
+async function rewritePackageJSON(projectRoot, config, oldPackageJSON) {
+  const newPackageJSON = Object.assign(oldPackageJSON, { qunitx: config });
+  await fs5.writeFile(`${projectRoot}/package.json`, JSON.stringify(newPackageJSON, null, 2));
+}
+async function writeTSConfigIfNeeded(projectRoot) {
+  const targetPath = `${projectRoot}/tsconfig.json`;
+  if (!await pathExists(targetPath)) {
+    const tsConfigTemplate = await readTemplate("setup/tsconfig.json");
+    await fs5.writeFile(targetPath, tsConfigTemplate);
+    console.log(`${targetPath} written`);
   }
-  if (needsQuoting(str)) return `'${str.replace(/'/g, "''")}'`;
-  return str;
 }
-function dumpValue(value, indent) {
-  if (value === null || value === void 0) return "null";
-  if (typeof value === "boolean" || typeof value === "number") return String(value);
-  if (typeof value === "string") return dumpString(value, indent);
-  if (Array.isArray(value)) {
-    if (value.length === 0) return "[]";
-    const next2 = `${indent}  `;
-    return "\n" + value.map((item) => {
-      const v = dumpValue(item, next2);
-      return v[0] === "\n" ? `${next2}-${v}` : `${next2}- ${v}`;
-    }).join("\n");
+var init_init = __esm({
+  "lib/commands/init.ts"() {
+    init_find_project_root();
+    init_path_exists();
+    init_default_project_config_values();
+    init_read_template();
   }
-  const entries = Object.entries(value);
-  if (entries.length === 0) return "{}";
+});
+
+// lib/utils/close-with-grace.ts
+function closeWithGrace(closes, graceMs = CLEANUP_GRACE_MS) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      process.stderr.write(`# qunitx: cleanup timed out after ${graceMs} ms \u2014 exiting anyway
+`);
+      resolve();
+    }, graceMs);
+    Promise.allSettled(closes).then(() => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
+var CLEANUP_GRACE_MS;
+var init_close_with_grace = __esm({
+  "lib/utils/close-with-grace.ts"() {
+    CLEANUP_GRACE_MS = 1e4;
+  }
+});
+
+// lib/commands/daemon/socket-utils.ts
+import net from "node:net";
+function attachLineParser(socket, onLine) {
+  let buf = "";
+  socket.on("data", (chunk) => {
+    buf += chunk.toString("utf8");
+    const lines = buf.split("\n");
+    buf = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line) continue;
+      try {
+        onLine(JSON.parse(line));
+      } catch {
+      }
+    }
+  });
+}
+function probeSocket(socketPath, timeoutMs) {
+  return new Promise((resolve) => {
+    const sock = net.createConnection(socketPath);
+    const timer = setTimeout(() => {
+      sock.destroy();
+      resolve(null);
+    }, timeoutMs);
+    sock.once("connect", () => {
+      clearTimeout(timer);
+      resolve(sock);
+    });
+    sock.once("error", () => {
+      clearTimeout(timer);
+      resolve(null);
+    });
+  });
+}
+var init_socket_utils = __esm({
+  "lib/commands/daemon/socket-utils.ts"() {
+  }
+});
+
+// lib/commands/daemon/client.ts
+var client_exports = {};
+__export(client_exports, {
+  pingDaemon: () => pingDaemon,
+  runViaDaemon: () => runViaDaemon,
+  shouldAutoSpawnDaemon: () => shouldAutoSpawnDaemon,
+  shouldUseDaemon: () => shouldUseDaemon,
+  shutdownDaemon: () => shutdownDaemon,
+  tryConnect: () => tryConnect
+});
+import fs6 from "node:fs/promises";
+import { existsSync as existsSync2 } from "node:fs";
+function isDaemonEligible() {
+  if (process.env.QUNITX_NO_DAEMON) return false;
+  if (process.env.CI && !process.env.QUNITX_DAEMON) return false;
+  for (const arg of process.argv) {
+    if (arg === "--no-daemon") return false;
+    if (arg === "--watch" || arg === "-w") return false;
+    if (arg === "--open" || arg === "-o" || arg.startsWith("--open=")) return false;
+  }
+  return true;
+}
+function shouldUseDaemon() {
+  return isDaemonEligible() && existsSync2(daemonInfoPath());
+}
+function shouldAutoSpawnDaemon() {
+  return Boolean(process.env.QUNITX_DAEMON) && isDaemonEligible() && !existsSync2(daemonInfoPath());
+}
+function tryConnect(cwd = process.cwd()) {
+  return probeSocket(daemonSocketPath(cwd), CONNECT_TIMEOUT_MS);
+}
+function send(socket, req) {
+  socket.write(JSON.stringify(req) + "\n");
+}
+function awaitClose(socket) {
+  return new Promise((resolve) => {
+    socket.once("end", () => resolve());
+    socket.once("close", () => resolve());
+    socket.once("error", () => resolve());
+  });
+}
+async function pingDaemon() {
+  const socket = await tryConnect();
+  if (!socket) return null;
+  const result = new Promise((resolve) => {
+    attachLineParser(socket, (chunk) => {
+      if (chunk.type === "pong") resolve(chunk);
+    });
+    socket.once("close", () => resolve(null));
+    socket.once("error", () => resolve(null));
+  });
+  send(socket, { type: "ping" });
+  const pong = await result;
+  socket.end();
+  return pong;
+}
+async function shutdownDaemon() {
+  const pid = await readDaemonPid();
+  const socket = await tryConnect();
+  if (!socket) return false;
+  attachLineParser(socket, () => {
+  });
+  send(socket, { type: "shutdown" });
+  await awaitClose(socket);
+  if (pid !== null) await waitForPidExit(pid, SHUTDOWN_PID_WAIT_MS);
+  return true;
+}
+async function readDaemonPid() {
+  try {
+    const info = JSON.parse(await fs6.readFile(daemonInfoPath(), "utf8"));
+    return typeof info.pid === "number" ? info.pid : null;
+  } catch {
+    return null;
+  }
+}
+function waitForPidExit(pid, timeoutMs) {
+  return new Promise((resolve) => {
+    const deadline = Date.now() + timeoutMs;
+    const poll = () => {
+      if (!pidIsAlive(pid) || Date.now() >= deadline) return resolve();
+      setTimeout(poll, SHUTDOWN_PID_POLL_MS);
+    };
+    poll();
+  });
+}
+function pidIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+async function runViaDaemon(argv) {
+  const socket = await tryConnect();
+  if (!socket) throw new Error("daemon connect failed");
+  const exitCode = new Promise((resolve) => {
+    attachLineParser(socket, (chunk) => {
+      if (chunk.type === "stdout") process.stdout.write(chunk.data);
+      else if (chunk.type === "stderr") process.stderr.write(chunk.data);
+      else if (chunk.type === "done") resolve(chunk.exitCode);
+      else if (chunk.type === "fatal") {
+        process.stderr.write(`# [qunitx daemon] ${chunk.message}
+`);
+        resolve(1);
+      }
+    });
+    socket.once("close", () => resolve(1));
+    socket.once("error", () => resolve(1));
+  });
+  const onSigint = () => {
+    socket.end();
+    process.exit(SIGINT_EXIT_CODE);
+  };
+  process.once("SIGINT", onSigint);
+  send(socket, {
+    type: "run",
+    argv,
+    cwd: process.cwd(),
+    env: { ...process.env },
+    nodeVersion: process.version
+  });
+  try {
+    return await exitCode;
+  } finally {
+    process.removeListener("SIGINT", onSigint);
+  }
+}
+var CONNECT_TIMEOUT_MS, SIGINT_EXIT_CODE, SHUTDOWN_PID_WAIT_MS, SHUTDOWN_PID_POLL_MS;
+var init_client = __esm({
+  "lib/commands/daemon/client.ts"() {
+    init_daemon_socket_path();
+    init_close_with_grace();
+    init_socket_utils();
+    CONNECT_TIMEOUT_MS = 1e3;
+    SIGINT_EXIT_CODE = 130;
+    SHUTDOWN_PID_WAIT_MS = CLEANUP_GRACE_MS;
+    SHUTDOWN_PID_POLL_MS = 50;
+  }
+});
+
+// lib/setup/fs-tree.ts
+import fs7, { glob as fsGlob } from "node:fs/promises";
+import path4 from "node:path";
+async function buildFSTree(fileAbsolutePaths, config = {}) {
+  const targetExtensions = config.extensions || defaultProjectConfigValues.extensions;
+  const fsTree = {};
+  await Promise.all(
+    fileAbsolutePaths.map(async (fileAbsolutePath) => {
+      try {
+        if (isGlob(fileAbsolutePath)) {
+          for await (const fileName of fsGlob(fileAbsolutePath)) {
+            if (targetExtensions.some((ext) => fileName.endsWith(`.${ext}`))) {
+              fsTree[fileName] = null;
+            }
+          }
+        } else {
+          const entry = await fs7.stat(fileAbsolutePath);
+          if (entry.isFile()) {
+            fsTree[fileAbsolutePath] = null;
+          } else if (entry.isDirectory()) {
+            const fileNames = await readDirRecursive(fileAbsolutePath, (name) => {
+              return targetExtensions.some((extension) => name.endsWith(`.${extension}`));
+            });
+            fileNames.forEach((fileName) => {
+              fsTree[fileName] = null;
+            });
+          }
+        }
+      } catch (error) {
+        console.error(error);
+        return process.exit(1);
+      }
+    })
+  );
+  return fsTree;
+}
+function isGlob(str) {
+  return /[*?{[]/.test(str);
+}
+async function readDirRecursive(dir, filter) {
+  const entries = await fs7.readdir(dir, { recursive: true, withFileTypes: true });
+  const candidates = entries.filter(
+    (dirent) => (dirent.isFile() || dirent.isSymbolicLink()) && filter(dirent.name)
+  );
+  const resolvedPaths = await Promise.all(
+    candidates.map(async (dirent) => {
+      const fullPath = path4.join(dirent.parentPath, dirent.name);
+      if (dirent.isFile()) return fullPath;
+      try {
+        const statResult = await fs7.stat(fullPath);
+        return statResult.isFile() ? fullPath : null;
+      } catch {
+        return null;
+      }
+    })
+  );
+  return resolvedPaths.filter((resolvedPath) => resolvedPath !== null);
+}
+var init_fs_tree = __esm({
+  "lib/setup/fs-tree.ts"() {
+    init_default_project_config_values();
+  }
+});
+
+// lib/setup/test-file-paths.ts
+import { matchesGlob } from "node:path";
+function setupTestFilePaths(inputs2) {
+  const folders = [];
+  const filesWithGlob = [];
+  const filesWithoutGlob = [];
+  inputs2.forEach((input) => {
+    if (!pathIsFile(input)) {
+      folders.push({ input, globFormat: `${input}/**` });
+    } else if (isGlob2(input)) {
+      filesWithGlob.push({ input, globFormat: input });
+    } else {
+      filesWithoutGlob.push({ input, globFormat: input });
+    }
+  });
+  const dedupedFolders = folders.filter((folder) => !isIncludedIn(folders, folder));
+  const dedupedGlobFiles = filesWithGlob.filter(
+    (file) => !isIncludedIn(dedupedFolders, file) && !isIncludedIn(filesWithGlob, file)
+  );
+  const dedupedPlainFiles = filesWithoutGlob.reduce((acc, file) => {
+    if (!isIncludedIn(dedupedFolders, file) && !isIncludedIn(dedupedGlobFiles, file) && !isIncludedIn(acc, file)) {
+      acc.push(file);
+    }
+    return acc;
+  }, []);
+  return dedupedFolders.concat(dedupedGlobFiles, dedupedPlainFiles).map((meta) => meta.input);
+}
+function pathIsFile(path14) {
+  return path14.includes(".", path14.lastIndexOf("/") + 1);
+}
+function isIncludedIn(paths, target) {
+  return paths.some((path14) => path14 !== target && matchesGlob(target.input, path14.globFormat));
+}
+function isGlob2(str) {
+  return GLOB_CHARS.test(str);
+}
+var GLOB_CHARS;
+var init_test_file_paths = __esm({
+  "lib/setup/test-file-paths.ts"() {
+    GLOB_CHARS = /[*?{[]/;
+  }
+});
+
+// lib/utils/parse-cli-flags.ts
+import path5 from "node:path";
+function parseCliFlags(projectRoot) {
+  const providedFlags = process.argv.slice(2).reduce(
+    (result, arg) => {
+      if (arg.startsWith("--debug")) {
+        return Object.assign(result, { debug: parseBoolean(arg.split("=")[1]) });
+      } else if (arg.startsWith("--watch")) {
+        return Object.assign(result, { watch: parseBoolean(arg.split("=")[1]) });
+      } else if (arg === "-o" || arg.startsWith("-o=") || arg.startsWith("--open")) {
+        const value = arg.split("=")[1];
+        const open = value === void 0 || value === "true" ? true : value === "false" ? false : value;
+        return Object.assign(result, { open });
+      } else if (arg.startsWith("--failfast") || arg.startsWith("--failFast")) {
+        return Object.assign(result, { failFast: parseBoolean(arg.split("=")[1]) });
+      } else if (arg.startsWith("--timeout")) {
+        return Object.assign(result, { timeout: Number(arg.split("=")[1]) || FALLBACK_TIMEOUT_MS });
+      } else if (arg.startsWith("--output")) {
+        return Object.assign(result, { output: arg.split("=")[1] });
+      } else if (arg.endsWith(".html")) {
+        if (result.htmlPaths) {
+          result.htmlPaths.push(arg);
+        } else {
+          result.htmlPaths = [arg];
+        }
+        return result;
+      } else if (arg.startsWith("--port")) {
+        return Object.assign(result, { port: Number(arg.split("=")[1]), portExplicit: true });
+      } else if (arg.startsWith("--extensions")) {
+        return Object.assign(result, {
+          extensions: arg.split("=")[1].split(",").map((extension) => extension.trim())
+        });
+      } else if (arg.startsWith("--browser")) {
+        const value = arg.split("=")[1];
+        if (!["chromium", "firefox", "webkit"].includes(value)) {
+          console.error(
+            `Invalid --browser value: "${value}". Must be one of: chromium, firefox, webkit`
+          );
+          process.exit(1);
+        }
+        return Object.assign(result, { browser: value });
+      } else if (arg.startsWith("--before")) {
+        return Object.assign(result, { before: parseModule(arg.split("=")[1]) });
+      } else if (arg.startsWith("--after")) {
+        return Object.assign(result, { after: parseModule(arg.split("=")[1]) });
+      } else if (arg === "--trace-perf") {
+        return result;
+      }
+      if (arg.startsWith("-")) {
+        console.warn(`# Warning: Unknown flag "${arg}" \u2014 ignored`);
+        return result;
+      }
+      result.inputs.add(
+        arg.startsWith(projectRoot) || arg.startsWith("/") ? arg : path5.join(process.cwd(), arg)
+      );
+      return result;
+    },
+    { inputs: /* @__PURE__ */ new Set([]) }
+  );
+  if (!providedFlags.browser && process.env.QUNITX_BROWSER) {
+    const envBrowser = process.env.QUNITX_BROWSER;
+    if (!["chromium", "firefox", "webkit"].includes(envBrowser)) {
+      console.error(
+        `Invalid QUNITX_BROWSER value: "${envBrowser}". Must be one of: chromium, firefox, webkit`
+      );
+      process.exit(1);
+    }
+    providedFlags.browser = envBrowser;
+  }
+  return { ...providedFlags, inputs: Array.from(providedFlags.inputs) };
+}
+function parseBoolean(result, defaultValue = true) {
+  if (result === "true") {
+    return true;
+  } else if (result === "false") {
+    return false;
+  }
+  return defaultValue;
+}
+function parseModule(value) {
+  if (["false", "'false'", '"false"', ""].includes(value)) {
+    return false;
+  }
+  return value;
+}
+var FALLBACK_TIMEOUT_MS;
+var init_parse_cli_flags = __esm({
+  "lib/utils/parse-cli-flags.ts"() {
+    FALLBACK_TIMEOUT_MS = 1e4;
+  }
+});
+
+// lib/setup/config.ts
+var config_exports = {};
+__export(config_exports, {
+  default: () => setupConfig,
+  setupConfig: () => setupConfig
+});
+import fs8 from "node:fs/promises";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+async function setupConfig() {
+  const projectRoot = await findProjectRoot();
+  const cliConfigFlags = parseCliFlags(projectRoot);
+  const projectPackageJSON = await readConfigFromPackageJSON(projectRoot);
+  const { plugins: rawPlugins, ...userQunitx } = projectPackageJSON.qunitx ?? {};
+  const pluginsPromise = resolvePlugins(rawPlugins, projectRoot);
+  const inputs2 = cliConfigFlags.inputs.concat(readInputsFromPackageJSON(projectPackageJSON));
+  const config = {
+    ...defaultProjectConfigValues,
+    htmlPaths: [],
+    ...userQunitx,
+    ...cliConfigFlags,
+    projectRoot,
+    inputs: inputs2,
+    testFileLookupPaths: setupTestFilePaths(inputs2),
+    lastFailedTestFiles: null,
+    lastRanTestFiles: null,
+    COUNTER: {
+      testCount: 0,
+      failCount: 0,
+      skipCount: 0,
+      todoCount: 0,
+      passCount: 0,
+      errorCount: 0
+    },
+    _testRunDone: null,
+    _resetTestTimeout: null,
+    _onWsOpen: null,
+    _onTestsJsServed: null
+  };
+  config.htmlPaths = normalizeHTMLPaths(config.projectRoot, config.htmlPaths);
+  [config.fsTree, config.plugins] = await Promise.all([
+    buildFSTree(config.testFileLookupPaths, config),
+    pluginsPromise
+  ]);
+  return config;
+}
+async function readConfigFromPackageJSON(projectRoot) {
+  const packageJSON = await fs8.readFile(`${projectRoot}/package.json`);
+  return JSON.parse(packageJSON.toString());
+}
+function normalizeHTMLPaths(projectRoot, htmlPaths) {
+  return Array.from(new Set(htmlPaths.map((htmlPath) => `${projectRoot}/${htmlPath}`)));
+}
+function readInputsFromPackageJSON(packageJSON) {
+  const qunitx = packageJSON.qunitx;
+  return qunitx && qunitx.inputs ? qunitx.inputs : [];
+}
+function resolvePlugins(raw, projectRoot) {
+  if (raw == null) return Promise.resolve([]);
+  if (!Array.isArray(raw)) {
+    console.error(`# qunitx: package.json#qunitx.plugins must be an array`);
+    process.exit(1);
+  }
+  const projectRequire = createRequire(`${projectRoot}/package.json`);
+  return Promise.all(
+    raw.map(async (entry) => {
+      const [spec, options] = Array.isArray(entry) ? entry : [entry];
+      const mod = await import(pathToFileURL(projectRequire.resolve(spec)).href);
+      const exported = mod.default ?? mod;
+      return typeof exported === "function" ? exported(options) : exported;
+    })
+  );
+}
+var init_config = __esm({
+  "lib/setup/config.ts"() {
+    init_default_project_config_values();
+    init_find_project_root();
+    init_fs_tree();
+    init_test_file_paths();
+    init_parse_cli_flags();
+  }
+});
+
+// lib/utils/find-internal-assets-from-html.ts
+function findInternalAssetsFromHTML(htmlContent) {
+  const links = [...htmlContent.matchAll(LINK_HREF_REGEX)].map((match) => match[1]).filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));
+  const scripts = [...htmlContent.matchAll(SCRIPT_SRC_REGEX)].map((match) => match[1]).filter((uri) => !ABSOLUTE_URL_REGEX.test(uri));
+  return links.concat(scripts);
+}
+var ABSOLUTE_URL_REGEX, SCRIPT_SRC_REGEX, LINK_HREF_REGEX;
+var init_find_internal_assets_from_html = __esm({
+  "lib/utils/find-internal-assets-from-html.ts"() {
+    ABSOLUTE_URL_REGEX = /^(?:[a-z]+:)?\/\//i;
+    SCRIPT_SRC_REGEX = /<script[^>]+\bsrc=['"]([^'"]+)['"]/gi;
+    LINK_HREF_REGEX = /<link[^>]+\bhref=['"]([^'"]+)['"]/gi;
+  }
+});
+
+// lib/utils/html.ts
+function findScriptPlaceholder(html) {
+  return html.includes(SCRIPT_PLACEHOLDER) ? SCRIPT_PLACEHOLDER : void 0;
+}
+function isCustomTemplate(html) {
+  return !!findScriptPlaceholder(html) || HANDLEBARS_TOKEN_REGEX.test(html);
+}
+function injectScript(html, content) {
+  const placeholder = findScriptPlaceholder(html);
+  if (placeholder) {
+    return html.replace(placeholder, content);
+  }
+  if (isCustomTemplate(html)) {
+    if (html.includes("</body>")) {
+      return html.replace("</body>", `${content}</body>`);
+    }
+    if (html.includes("</html>")) {
+      return html.replace("</html>", `${content}</html>`);
+    }
+    return `${html}${content}`;
+  }
+  return html;
+}
+var SCRIPT_PLACEHOLDER, HANDLEBARS_TOKEN_REGEX;
+var init_html = __esm({
+  "lib/utils/html.ts"() {
+    SCRIPT_PLACEHOLDER = "{{qunitxScript}}";
+    HANDLEBARS_TOKEN_REGEX = /{{\s*[^}]+\s*}}/;
+  }
+});
+
+// lib/tap/dump-yaml.ts
+function dumpYaml({
+  name,
+  actual,
+  expected,
+  message,
+  stack,
+  source,
+  at
+}) {
+  return `name: ${dumpString(name, "")}
+` + yamlLine("actual", actual) + yamlLine("expected", expected) + (message !== null ? yamlLine("message", message) : "") + (stack !== null ? yamlLine("stack", stack) : "") + (source !== null ? yamlLine("source", source) : "") + (at !== null ? yamlLine("at", at) : "");
+}
+function needsQuoting(str) {
+  return NEEDS_QUOTING.test(str);
+}
+function dumpString(str, indent) {
+  if (str === "") return "''";
+  if (str.includes("\n")) {
+    return "|-\n" + str.replace(/^/gm, `${indent}  `);
+  }
+  if (needsQuoting(str)) return `'${str.replace(/'/g, "''")}'`;
+  return str;
+}
+function dumpValue(value, indent) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "boolean" || typeof value === "number") return String(value);
+  if (typeof value === "string") return dumpString(value, indent);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    const next2 = `${indent}  `;
+    return "\n" + value.map((item) => {
+      const v = dumpValue(item, next2);
+      return v[0] === "\n" ? `${next2}-${v}` : `${next2}- ${v}`;
+    }).join("\n");
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 0) return "{}";
   const next = `${indent}  `;
   return "\n" + entries.map(([entryKey, entryValue]) => {
     const v = dumpValue(entryValue, next);
@@ -682,13 +1498,13 @@ function extractSourceLine(content, lineIndex) {
   const line = content.split("\n", lineIndex + 1)[lineIndex];
   return line?.trim() || null;
 }
-function normalizePosix(path10) {
-  const parts = path10.split("/").reduce((acc, part) => {
+function normalizePosix(path14) {
+  const parts = path14.split("/").reduce((acc, part) => {
     if (part === "..") acc.pop();
     else if (part && part !== ".") acc.push(part);
     return acc;
   }, []);
-  return (path10.startsWith("/") ? "/" : "") + parts.join("/");
+  return (path14.startsWith("/") ? "/" : "") + parts.join("/");
 }
 function toAbsolutePath(rawSource, outDir, sourceRoot) {
   if (rawSource.startsWith("file://")) return rawSource.slice(7);
@@ -696,8 +1512,8 @@ function toAbsolutePath(rawSource, outDir, sourceRoot) {
   const base = sourceRoot ? normalizePosix(`${outDir}/${sourceRoot}`) : outDir;
   return normalizePosix(`${base}/${rawSource}`);
 }
-function isNodeModulesPath(path10) {
-  return path10.includes("/node_modules/") || path10.includes("\\node_modules\\");
+function isNodeModulesPath(path14) {
+  return path14.includes("/node_modules/") || path14.includes("\\node_modules\\");
 }
 function makeDisplayPath(absolutePath, projectRoot) {
   const prefix = projectRoot + "/";
@@ -973,8 +1789,8 @@ var init_web = __esm({
         });
       }
       /** Registers a GET route handler. */
-      get(path10, handler) {
-        this.#registerRouteHandler("GET", path10, handler);
+      get(path14, handler) {
+        this.#registerRouteHandler("GET", path14, handler);
       }
       /**
        * Starts listening on the given port (0 = OS-assigned).
@@ -1005,32 +1821,32 @@ var init_web = __esm({
         });
       }
       /** Registers a POST route handler. */
-      post(path10, handler) {
-        this.#registerRouteHandler("POST", path10, handler);
+      post(path14, handler) {
+        this.#registerRouteHandler("POST", path14, handler);
       }
       /** Registers a DELETE route handler. */
-      delete(path10, handler) {
-        this.#registerRouteHandler("DELETE", path10, handler);
+      delete(path14, handler) {
+        this.#registerRouteHandler("DELETE", path14, handler);
       }
       /** Registers a PUT route handler. */
-      put(path10, handler) {
-        this.#registerRouteHandler("PUT", path10, handler);
+      put(path14, handler) {
+        this.#registerRouteHandler("PUT", path14, handler);
       }
       /** Adds a middleware function to the chain. */
       use(middleware) {
         this.middleware.push(middleware);
       }
-      #registerRouteHandler(method, path10, handler) {
+      #registerRouteHandler(method, path14, handler) {
         if (!this.routes[method]) {
           this.routes[method] = {};
         }
-        const paramNames = this.#extractParamNames(path10);
-        this.routes[method][path10] = {
-          path: path10,
+        const paramNames = this.#extractParamNames(path14);
+        this.routes[method][path14] = {
+          path: path14,
           handler,
           paramNames,
-          isWildcard: path10 === "/*",
-          compiledRegex: paramNames.length > 0 ? new RegExp(`^${this.#buildRegexPattern(path10, paramNames)}$`) : null
+          isWildcard: path14 === "/*",
+          compiledRegex: paramNames.length > 0 ? new RegExp(`^${this.#buildRegexPattern(path14, paramNames)}$`) : null
         };
       }
       #handleRequest(req, res) {
@@ -1068,11 +1884,11 @@ var init_web = __esm({
           return null;
         }
         return routes[url] || Object.values(routes).find((route) => {
-          const { path: path10, isWildcard } = route;
-          if (!isWildcard && !path10.includes(":")) {
+          const { path: path14, isWildcard } = route;
+          if (!isWildcard && !path14.includes(":")) {
             return false;
           }
-          if (isWildcard || this.#matchPathSegments(path10, url)) {
+          if (isWildcard || this.#matchPathSegments(path14, url)) {
             if (route.compiledRegex) {
               const regexMatches = route.compiledRegex.exec(url);
               if (regexMatches) {
@@ -1084,8 +1900,8 @@ var init_web = __esm({
           return false;
         }) || null;
       }
-      #matchPathSegments(path10, url) {
-        const pathSegments = path10.split("/");
+      #matchPathSegments(path14, url) {
+        const pathSegments = path14.split("/");
         const urlSegments = url.split("/");
         if (pathSegments.length !== urlSegments.length) {
           return false;
@@ -1102,14 +1918,14 @@ var init_web = __esm({
         }
         return true;
       }
-      #buildRegexPattern(path10, _paramNames) {
-        let regexPattern = path10.replace(/:[^/]+/g, "([^/]+)");
+      #buildRegexPattern(path14, _paramNames) {
+        let regexPattern = path14.replace(/:[^/]+/g, "([^/]+)");
         regexPattern = regexPattern.replace(/\//g, "\\/");
         return regexPattern;
       }
-      #extractParamNames(path10) {
+      #extractParamNames(path14) {
         const paramRegex = /:(\w+)/g;
-        const paramMatches = path10.match(paramRegex);
+        const paramMatches = path14.match(paramRegex);
         return paramMatches ? paramMatches.map((match) => match.slice(1)) : [];
       }
       #extractParams(route, _url) {
@@ -1125,10 +1941,10 @@ var init_web = __esm({
 });
 
 // lib/setup/web-server.ts
-import fs8 from "node:fs";
-import path5 from "node:path";
+import fs9 from "node:fs";
+import path6 from "node:path";
 function setupWebServer(config, cachedContent) {
-  const STATIC_FILES_PATH = path5.resolve(config.projectRoot, config.output);
+  const STATIC_FILES_PATH = path6.resolve(config.projectRoot, config.output);
   const server = new HTTPServer();
   const mainHTMLWithReplacedAssets = replaceAssetPaths(
     cachedContent.mainHTML.html,
@@ -1158,7 +1974,7 @@ function setupWebServer(config, cachedContent) {
         config._onWsOpen?.();
       } else if (event === "connection") {
         config._phase = "running";
-        if (!config._groupMode) process.stdout.write("TAP version 13\n");
+        if (!config._groupMode && !config._daemonMode) process.stdout.write("TAP version 13\n");
         if (config.debug && config._groupMode) debugGroupHeader(config);
         config._resetTestTimeout?.();
       } else if (event === "testEnd" && !abort) {
@@ -1266,7 +2082,7 @@ function setupWebServer(config, cachedContent) {
         config._testRunDone = null;
       }
       return saveHTML(
-        path5.join(path5.resolve(config.projectRoot, config.output), "index.html"),
+        path6.join(path6.resolve(config.projectRoot, config.output), "index.html"),
         htmlContent
       );
     }
@@ -1277,7 +2093,7 @@ function setupWebServer(config, cachedContent) {
     res.writeHead(200, HTML_HEADERS);
     res.end(mainIndexHTML);
     saveHTML(
-      path5.join(path5.resolve(config.projectRoot, config.output), "index.html"),
+      path6.join(path6.resolve(config.projectRoot, config.output), "index.html"),
       mainIndexHTML
     );
   });
@@ -1287,7 +2103,7 @@ function setupWebServer(config, cachedContent) {
       res.writeHead(200, HTML_HEADERS);
       res.end(htmlContent);
       return saveHTML(
-        path5.join(path5.resolve(config.projectRoot, config.output), "qunitx.html"),
+        path6.join(path6.resolve(config.projectRoot, config.output), "qunitx.html"),
         htmlContent
       );
     }
@@ -1298,7 +2114,7 @@ function setupWebServer(config, cachedContent) {
     res.writeHead(200, HTML_HEADERS);
     res.end(mainQunitxHTML);
     saveHTML(
-      path5.join(path5.resolve(config.projectRoot, config.output), "qunitx.html"),
+      path6.join(path6.resolve(config.projectRoot, config.output), "qunitx.html"),
       mainQunitxHTML
     );
   });
@@ -1312,14 +2128,14 @@ function setupWebServer(config, cachedContent) {
       );
       res.writeHead(200, HTML_HEADERS);
       res.end(htmlContent);
-      saveHTML(path5.join(path5.resolve(config.projectRoot, config.output), req.path), htmlContent);
+      saveHTML(path6.join(path6.resolve(config.projectRoot, config.output), req.path), htmlContent);
       return;
     }
     const url = req.url;
     const requestStartedAt = Date.now();
     const filePath = (url.endsWith("/") ? [STATIC_FILES_PATH, url, "index.html"] : [STATIC_FILES_PATH, url]).join("");
-    const contentType = req.headers.accept?.includes("text/html") ? MIME_TYPES.html : MIME_TYPES[path5.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html;
-    const stream = fs8.createReadStream(filePath);
+    const contentType = req.headers.accept?.includes("text/html") ? MIME_TYPES.html : MIME_TYPES[path6.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html;
+    const stream = fs9.createReadStream(filePath);
     stream.on("open", () => {
       res.writeHead(200, { "Content-Type": contentType });
       stream.pipe(res);
@@ -1572,7 +2388,7 @@ function registerGroupRoutes(server, groupConfig, groupCachedContent, groupId) {
     res.writeHead(200, HTML_HEADERS);
     res.end(mainGroupHTML);
     saveHTML(
-      path5.join(path5.resolve(groupConfig.projectRoot, groupConfig.output), "index.html"),
+      path6.join(path6.resolve(groupConfig.projectRoot, groupConfig.output), "index.html"),
       mainGroupHTML
     );
   });
@@ -1658,11 +2474,11 @@ function registerSharedStaticHandler(server, groupConfigs) {
       res.end("Not found");
       return;
     }
-    const STATIC_FILES_PATH = path5.resolve(groupConfig.projectRoot, groupConfig.output);
+    const STATIC_FILES_PATH = path6.resolve(groupConfig.projectRoot, groupConfig.output);
     const subPath = match[2] || "/";
     const filePath = (subPath.endsWith("/") ? [STATIC_FILES_PATH, subPath, "index.html"] : [STATIC_FILES_PATH, subPath]).join("");
-    const contentType = req.headers.accept?.includes("text/html") ? MIME_TYPES.html : MIME_TYPES[path5.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html;
-    const stream = fs8.createReadStream(filePath);
+    const contentType = req.headers.accept?.includes("text/html") ? MIME_TYPES.html : MIME_TYPES[path6.extname(filePath).substring(1).toLowerCase()] || MIME_TYPES.html;
+    const stream = fs9.createReadStream(filePath);
     stream.on("open", () => {
       res.writeHead(200, { "Content-Type": contentType });
       stream.pipe(res);
@@ -1677,7 +2493,7 @@ function replaceAssetPaths(html, htmlPath, projectRoot) {
   const assetPaths = findInternalAssetsFromHTML(html);
   const htmlDirectory = htmlPath.split("/").slice(0, -1).join("/");
   return assetPaths.reduce((result, assetPath) => {
-    const normalizedFullAbsolutePath = path5.normalize(`${htmlDirectory}/${assetPath}`);
+    const normalizedFullAbsolutePath = path6.normalize(`${htmlDirectory}/${assetPath}`);
     return result.replace(assetPath, normalizedFullAbsolutePath.replace(projectRoot, "."));
   }, html);
 }
@@ -1839,7 +2655,7 @@ var init_web_server = __esm({
     init_display_test_result();
     init_color();
     init_web();
-    fsPromise = fs8.promises;
+    fsPromise = fs9.promises;
     HTML_HEADERS = { "Content-Type": "text/html", "Cache-Control": "no-store" };
     WATCH_WS_RECONNECT_INTERVAL_MS = 1e3;
     WATCH_WS_RECONNECT_MAX_RETRIES = 120;
@@ -1875,13 +2691,13 @@ var init_web_server = __esm({
 });
 
 // lib/setup/browser.ts
-async function launchBrowser(config) {
+async function launchBrowser(config, skipPrelaunch = false) {
   const browserName = config.browser || "chromium";
   if (browserName === "chromium") {
     const waitStart = Date.now();
     const [playwrightCore2, prelaunch] = await Promise.all([
       playwrightCorePromise,
-      prelaunchPromise
+      skipPrelaunch ? Promise.resolve(null) : prelaunchPromise
     ]);
     perfLog(
       `browser.js: playwright-core + prelaunch resolved in ${Date.now() - waitStart}ms, prelaunch:`,
@@ -1999,65 +2815,6 @@ var init_browser = __esm({
   }
 });
 
-// lib/utils/open-output-in-browser.ts
-import { spawn as spawn2 } from "node:child_process";
-import path6 from "node:path";
-import { pathToFileURL as pathToFileURL2 } from "node:url";
-async function openOutputInBrowser(config) {
-  try {
-    const outputFile = config.watch ? `http://localhost:${config.port}` : pathToFileURL2(path6.join(path6.resolve(config.projectRoot, config.output), "index.html")).href;
-    if (typeof config.open === "string") {
-      spawnDetached(config.open, [outputFile]);
-      return;
-    }
-    const browserName = config.browser || "chromium";
-    if (browserName === "firefox") {
-      spawnDetached("firefox", [outputFile]);
-      return;
-    }
-    if (browserName === "webkit") {
-      if (process.platform === "darwin") spawnDetached("open", ["-a", "Safari", outputFile]);
-      return;
-    }
-    const chromePath = await findChrome() ?? (await import("playwright-core")).chromium.executablePath();
-    if (chromePath) spawnDetached(chromePath, [outputFile]);
-  } catch (err) {
-    console.error("# Warning: --open could not launch browser:", err);
-  }
-}
-function spawnDetached(cmd, args) {
-  const child = spawn2(cmd, args, { detached: true, stdio: "ignore" });
-  child.on("error", () => {
-  });
-  child.unref();
-}
-var init_open_output_in_browser = __esm({
-  "lib/utils/open-output-in-browser.ts"() {
-    init_find_chrome();
-  }
-});
-
-// lib/utils/close-with-grace.ts
-function closeWithGrace(closes, graceMs = CLEANUP_GRACE_MS) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(() => {
-      process.stderr.write(`# qunitx: cleanup timed out after ${graceMs} ms \u2014 exiting anyway
-`);
-      resolve();
-    }, graceMs);
-    Promise.allSettled(closes).then(() => {
-      clearTimeout(timer);
-      resolve();
-    });
-  });
-}
-var CLEANUP_GRACE_MS;
-var init_close_with_grace = __esm({
-  "lib/utils/close-with-grace.ts"() {
-    CLEANUP_GRACE_MS = 1e4;
-  }
-});
-
 // lib/utils/time-counter.ts
 function timeCounter() {
   const startTime = /* @__PURE__ */ new Date();
@@ -2072,10 +2829,10 @@ var init_time_counter = __esm({
 });
 
 // lib/utils/run-user-module.ts
-import { pathToFileURL as pathToFileURL3 } from "node:url";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
 async function runUserModule(modulePath, params, scriptPosition) {
   try {
-    const func = await import(pathToFileURL3(modulePath).href);
+    const func = await import(pathToFileURL2(modulePath).href);
     if (func) {
       func.default ? await func.default(params) : typeof func === "function" ? await func(params) : null;
     }
@@ -2117,7 +2874,7 @@ var init_display_final_result = __esm({
 });
 
 // lib/commands/run/tests-in-browser.ts
-import fs9 from "node:fs/promises";
+import fs10 from "node:fs/promises";
 import path7 from "node:path";
 import esbuild from "esbuild";
 function deriveBuildErrorType(error) {
@@ -2148,6 +2905,9 @@ function formatBuildErrors(error) {
   const raw = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
   return raw.replace(/\x1b\[[0-9;]*[mGKH]/g, "").replace(/\r\n/g, "\n");
 }
+function bundleCacheKey(opts, files) {
+  return JSON.stringify({ files, outfile: opts.outfile, target: opts.target });
+}
 async function buildTestBundle(config, cachedContent) {
   const { projectRoot, output } = config;
   const allTestFilePaths = Object.keys(config.fsTree);
@@ -2157,7 +2917,7 @@ async function buildTestBundle(config, cachedContent) {
   }
   const outDir = path7.resolve(projectRoot, output);
   const outfile = path7.join(outDir, "tests.js");
-  await fs9.mkdir(outDir, { recursive: true });
+  await fs10.mkdir(outDir, { recursive: true });
   const sourcemap = "inline";
   const needsDisk = true;
   const buildOptions = {
@@ -2189,15 +2949,17 @@ async function buildTestBundle(config, cachedContent) {
   };
   cachedContent._buildError = null;
   cachedContent._noTestsWarning = null;
+  const cacheHolder = config._daemonEsbuildCache ?? cachedContent;
+  const fileKey = bundleCacheKey(buildOptions, allTestFilePaths);
   try {
     const [allTestCode] = await Promise.all([
-      config.watch ? buildIncrementally(buildOptions, allTestFilePaths.join("\0"), cachedContent, needsDisk) : buildWithOverlayfsRetry(buildOptions, needsDisk),
+      config.watch || config._daemonMode ? buildIncrementally(buildOptions, fileKey, cacheHolder, needsDisk) : buildWithOverlayfsRetry(buildOptions, needsDisk),
       Promise.all(
         cachedContent.htmlPathsToRunTests.map(async (htmlPath) => {
           const targetPath = path7.join(outDir, htmlPath);
           if (htmlPath !== "/") {
-            await fs9.rm(targetPath, { force: true, recursive: true });
-            await fs9.mkdir(path7.dirname(targetPath), { recursive: true });
+            await fs10.rm(targetPath, { force: true, recursive: true });
+            await fs10.mkdir(path7.dirname(targetPath), { recursive: true });
           }
         })
       )
@@ -2209,7 +2971,7 @@ async function buildTestBundle(config, cachedContent) {
       type: deriveBuildErrorType(error),
       formatted: formatBuildErrors(error)
     };
-    await fs9.writeFile(path7.join(outDir, "index.html"), buildErrorHTML(cachedContent._buildError));
+    await fs10.writeFile(path7.join(outDir, "index.html"), buildErrorHTML(cachedContent._buildError));
     throw error;
   }
 }
@@ -2283,7 +3045,7 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
         console.log(
           `# Warning: 0 tests registered \u2014 no QUnit test cases found in ${allTestFilePaths.length} ${fileWord}`
         );
-        fs9.writeFile(path7.join(outDir, "index.html"), buildNoTestsHTML(displayFiles)).catch(
+        fs10.writeFile(path7.join(outDir, "index.html"), buildNoTestsHTML(displayFiles)).catch(
           () => {
           }
         );
@@ -2293,7 +3055,10 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
         await runUserModule(`${process.cwd()}/${config.after}`, config.COUNTER, "after");
       }
       if (!config.watch) {
-        await flushConsoleHandlers(config._pendingConsoleHandlers);
+        await flushConsoleHandlers(config._pendingConsoleHandlers, connections.page);
+        if (config._daemonMode) {
+          throw new DaemonRunError(config.COUNTER.failCount > 0 ? 1 : 0);
+        }
         await closeWithGrace([
           connections.server?.close(),
           connections.browser?.close(),
@@ -2303,6 +3068,7 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
       }
     }
   } catch (error) {
+    if (error instanceof DaemonRunError) throw error;
     cachedContent._activeRebuild = null;
     config.lastFailedTestFiles = config.lastRanTestFiles;
     const exception = new BundleError(error);
@@ -2311,7 +3077,7 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
         type: deriveBuildErrorType(error),
         formatted: formatBuildErrors(error)
       };
-      fs9.writeFile(
+      fs10.writeFile(
         path7.join(outDir, "qunitx.html"),
         buildErrorHTML(cachedContent._buildError)
       ).catch(
@@ -2327,12 +3093,14 @@ async function runTestsInBrowser(config, cachedContent = {}, connections, target
   }
   return connections;
 }
-async function flushConsoleHandlers(handlers, deadline = Date.now() + CONSOLE_FLUSH_TIMEOUT_MS) {
+async function flushConsoleHandlers(handlers, page, deadline = Date.now() + CONSOLE_FLUSH_TIMEOUT_MS) {
   if (!handlers || Date.now() >= deadline) return;
+  if (page) await page.evaluate(() => 0).catch(() => {
+  });
   await new Promise((resolve) => setImmediate(resolve));
   if (handlers.size === 0) return;
   await Promise.allSettled([...handlers]);
-  return flushConsoleHandlers(handlers, deadline);
+  return flushConsoleHandlers(handlers, page, deadline);
 }
 async function buildAllGroupBundles(groupConfigs, groupCachedContents) {
   groupCachedContents.forEach((cachedContent) => {
@@ -2360,7 +3128,7 @@ async function buildAllGroupBundles(groupConfigs, groupCachedContents) {
     );
   await Promise.all(
     activeGroups.map(
-      (group) => fs9.mkdir(path7.resolve(group.config.projectRoot, group.config.output), { recursive: true })
+      (group) => fs10.mkdir(path7.resolve(group.config.projectRoot, group.config.output), { recursive: true })
     )
   );
   const sourcemap = "inline";
@@ -2433,7 +3201,7 @@ async function buildAllGroupBundles(groupConfigs, groupCachedContents) {
             esbuildOutdir
           );
         }
-        return fs9.writeFile(destPath, outputFile.contents);
+        return fs10.writeFile(destPath, outputFile.contents);
       })
     );
   } catch (error) {
@@ -2442,7 +3210,7 @@ async function buildAllGroupBundles(groupConfigs, groupCachedContents) {
     await Promise.all(
       activeGroups.map((group) => {
         group.cachedContent._buildError = buildError;
-        return fs9.writeFile(
+        return fs10.writeFile(
           path7.join(path7.resolve(group.config.projectRoot, group.config.output), "index.html"),
           errorHtml
         ).catch(
@@ -2492,7 +3260,7 @@ async function runWithOverlayfsRetry(getContents, needsDisk) {
   }
   if (needsDisk) {
     await Promise.all(
-      result.outputFiles.map((outputFile) => fs9.writeFile(outputFile.path, outputFile.contents))
+      result.outputFiles.map((outputFile) => fs10.writeFile(outputFile.path, outputFile.contents))
     );
   }
   return js;
@@ -2505,15 +3273,15 @@ function buildWithOverlayfsRetry(options, needsDisk) {
     return { result, js: Buffer.from(jsFile.contents) };
   }, needsDisk);
 }
-async function buildIncrementally(options, fileKey, cachedContent, needsDisk) {
+async function buildIncrementally(options, fileKey, cache, needsDisk) {
   const buildOpts = { ...options, write: false };
-  if (!cachedContent._esbuildContext || cachedContent._esbuildContextKey !== fileKey) {
-    cachedContent._esbuildContext?.dispose().catch(() => {
+  if (!cache._esbuildContext || cache._esbuildContextKey !== fileKey) {
+    cache._esbuildContext?.dispose().catch(() => {
     });
-    cachedContent._esbuildContext = await esbuild.context(buildOpts);
-    cachedContent._esbuildContextKey = fileKey;
+    cache._esbuildContext = await esbuild.context(buildOpts);
+    cache._esbuildContextKey = fileKey;
   }
-  const ctx = cachedContent._esbuildContext;
+  const ctx = cache._esbuildContext;
   return runWithOverlayfsRetry(async () => {
     const result = await ctx.rebuild();
     const jsFile = result.outputFiles.find((f) => !f.path.endsWith(".map"));
@@ -2585,9 +3353,10 @@ async function runTestInsideHTMLFile(filePath, { page, server, browser }, config
     console.error("BROWSER: runtime error thrown during executing tests");
     await failOnNonWatchMode(
       config.watch,
-      { server, browser },
+      { server, browser, page },
       config._groupMode,
-      config._pendingConsoleHandlers
+      config._pendingConsoleHandlers,
+      config._daemonMode
     );
   } else if (QUNIT_RESULT.totalTests === 0) {
     return;
@@ -2600,27 +3369,30 @@ async function runTestInsideHTMLFile(filePath, { page, server, browser }, config
     console.error(`BROWSER: TEST TIMED OUT: ${QUNIT_RESULT.currentTest}`);
     await failOnNonWatchMode(
       config.watch,
-      { server, browser },
+      { server, browser, page },
       config._groupMode,
-      config._pendingConsoleHandlers
+      config._pendingConsoleHandlers,
+      config._daemonMode
     );
   } else if (QUNIT_RESULT.failedTests > config.COUNTER.failCount) {
     config.COUNTER.failCount = QUNIT_RESULT.failedTests;
   }
 }
-async function failOnNonWatchMode(watchMode = false, connections = {}, groupMode = false, pendingHandlers) {
-  if (!watchMode) {
-    if (groupMode) {
-      throw new Error("Browser test run failed");
-    }
-    await flushConsoleHandlers(pendingHandlers);
-    await closeWithGrace([
-      connections.server?.close(),
-      connections.browser?.close(),
-      shutdownPrelaunch()
-    ]);
-    process.exit(1);
+async function failOnNonWatchMode(watchMode = false, connections = {}, groupMode = false, pendingHandlers, daemonMode = false) {
+  if (watchMode) return;
+  if (groupMode) {
+    throw new Error("Browser test run failed");
   }
+  await flushConsoleHandlers(pendingHandlers, connections.page);
+  if (daemonMode) {
+    throw new DaemonRunError(1);
+  }
+  await closeWithGrace([
+    connections.server?.close(),
+    connections.browser?.close(),
+    shutdownPrelaunch()
+  ]);
+  process.exit(1);
 }
 function toEsbuildImportPath(filePath) {
   const rel = path7.relative(process.cwd(), filePath);
@@ -2628,7 +3400,7 @@ function toEsbuildImportPath(filePath) {
   if (path7.isAbsolute(rel)) return filePath.replace(/\\/g, "/");
   return normalized.startsWith(".") ? normalized : "./" + normalized;
 }
-var ancestorNodeModules, ANCESTOR_NODE_MODULES, RETRY_DELAY_MS, MAX_RETRIES, EMPTY_BUNDLE_THRESHOLD, NAV_GRACE_MS, MIN_NAV_MS, STARTUP_TIMEOUT_FACTOR, TESTS_JS_TIMEOUT_FACTOR, CONSOLE_FLUSH_TIMEOUT_MS, TEST_STALL_BUFFER_MS, GROUP_OUTPUT_REGEX, BundleError;
+var ancestorNodeModules, ANCESTOR_NODE_MODULES, RETRY_DELAY_MS, MAX_RETRIES, EMPTY_BUNDLE_THRESHOLD, NAV_GRACE_MS, MAX_NAV_SLOWDOWN_FACTOR, MIN_NAV_MS, STARTUP_TIMEOUT_FACTOR, TESTS_JS_TIMEOUT_FACTOR, CONSOLE_FLUSH_TIMEOUT_MS, TEST_STALL_BUFFER_MS, GROUP_OUTPUT_REGEX, BundleError, DaemonRunError;
 var init_tests_in_browser = __esm({
   "lib/commands/run/tests-in-browser.ts"() {
     init_color();
@@ -2647,7 +3419,8 @@ var init_tests_in_browser = __esm({
     MAX_RETRIES = 3;
     EMPTY_BUNDLE_THRESHOLD = 500;
     NAV_GRACE_MS = 1e4;
-    MIN_NAV_MS = 3e4;
+    MAX_NAV_SLOWDOWN_FACTOR = 6;
+    MIN_NAV_MS = NAV_GRACE_MS * MAX_NAV_SLOWDOWN_FACTOR;
     STARTUP_TIMEOUT_FACTOR = 3;
     TESTS_JS_TIMEOUT_FACTOR = 4;
     CONSOLE_FLUSH_TIMEOUT_MS = 2e3;
@@ -2660,13 +3433,61 @@ var init_tests_in_browser = __esm({
         this.message = `esbuild Bundle Error: ${message}`.split("\n").join("\n# ");
       }
     };
+    DaemonRunError = class extends Error {
+      /** The exit code that the run would have passed to `process.exit()` outside of daemon mode. */
+      exitCode;
+      /** Constructs a DaemonRunError carrying the run's exit code. */
+      constructor(exitCode) {
+        super(`daemon run finished with exit code ${exitCode}`);
+        this.name = "DaemonRunError";
+        this.exitCode = exitCode;
+      }
+    };
+  }
+});
+
+// lib/utils/open-output-in-browser.ts
+import { spawn as spawn2 } from "node:child_process";
+import path8 from "node:path";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
+async function openOutputInBrowser(config) {
+  try {
+    const outputFile = config.watch ? `http://localhost:${config.port}` : pathToFileURL3(path8.join(path8.resolve(config.projectRoot, config.output), "index.html")).href;
+    if (typeof config.open === "string") {
+      spawnDetached(config.open, [outputFile]);
+      return;
+    }
+    const browserName = config.browser || "chromium";
+    if (browserName === "firefox") {
+      spawnDetached("firefox", [outputFile]);
+      return;
+    }
+    if (browserName === "webkit") {
+      if (process.platform === "darwin") spawnDetached("open", ["-a", "Safari", outputFile]);
+      return;
+    }
+    const chromePath = await findChrome() ?? (await import("playwright-core")).chromium.executablePath();
+    if (chromePath) spawnDetached(chromePath, [outputFile]);
+  } catch (err) {
+    console.error("# Warning: --open could not launch browser:", err);
+  }
+}
+function spawnDetached(cmd2, args) {
+  const child = spawn2(cmd2, args, { detached: true, stdio: "ignore" });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+var init_open_output_in_browser = __esm({
+  "lib/utils/open-output-in-browser.ts"() {
+    init_find_chrome();
   }
 });
 
 // lib/setup/file-watcher.ts
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 import { readdir, stat, lstat } from "node:fs/promises";
-import path8 from "node:path";
+import path9 from "node:path";
 function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFunc) {
   const extensions = config.extensions || defaultProjectConfigValues.extensions;
   config._lastBuildEndMs ??= Date.now();
@@ -2679,7 +3500,7 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
     if (symlinkPollers.has(filePath)) return;
     const handler = (curr, prev) => {
       if (curr.nlink === 0) {
-        fs10.unwatchFile(filePath, handler);
+        fs11.unwatchFile(filePath, handler);
         symlinkPollers.delete(filePath);
         if (filePath in config.fsTree) {
           handleWatchEvent(config, extensions, "unlink", filePath, onEventFunc, onFinishFunc);
@@ -2690,8 +3511,8 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
         }
       }
     };
-    fs10.watchFile(filePath, { interval: SYMLINK_POLL_INTERVAL_MS, persistent: false }, handler);
-    symlinkPollers.set(filePath, () => fs10.unwatchFile(filePath, handler));
+    fs11.watchFile(filePath, { interval: SYMLINK_POLL_INTERVAL_MS, persistent: false }, handler);
+    symlinkPollers.set(filePath, () => fs11.unwatchFile(filePath, handler));
   }
   function untrackSymlink(filePath) {
     symlinkPollers.get(filePath)?.();
@@ -2702,7 +3523,7 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
     let rescanInProgress = false;
     const lastEventMs = {};
     const seenMtimeMs = {};
-    const childWatcher = fs10.watch(watchPath, { recursive: true }, async (eventType, filename) => {
+    const childWatcher = fs11.watch(watchPath, { recursive: true }, async (eventType, filename) => {
       if (!ready) return;
       if (!filename) {
         if (process.platform === "darwin" && !rescanInProgress) {
@@ -2720,7 +3541,7 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
         }
         return;
       }
-      const fullPath = filename === path8.basename(watchPath) ? watchPath : path8.join(watchPath, filename);
+      const fullPath = filename === path9.basename(watchPath) ? watchPath : path9.join(watchPath, filename);
       if (eventType === "change") {
         const now = Date.now();
         const last = lastEventMs[fullPath] ?? 0;
@@ -2749,10 +3570,10 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
       }
       handleWatchEvent(config, extensions, event, fullPath, onEventFunc, onFinishFunc);
     });
-    const parentDir = path8.dirname(watchPath);
-    const watchedBasename = path8.basename(watchPath);
+    const parentDir = path9.dirname(watchPath);
+    const watchedBasename = path9.basename(watchPath);
     let parentUnlinkFired = false;
-    const parentWatcher = fs10.watch(parentDir, async (eventType, filename) => {
+    const parentWatcher = fs11.watch(parentDir, async (eventType, filename) => {
       if (!ready || filename !== watchedBasename || eventType !== "rename") return;
       if (parentUnlinkFired) return;
       parentUnlinkFired = true;
@@ -2867,11 +3688,11 @@ async function rescanDirectoryForDelta(watchPath, config, extensions, onEventFun
     const trackedToRecheck = [];
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        presentDirs.add(path8.join(entry.parentPath, entry.name));
+        presentDirs.add(path9.join(entry.parentPath, entry.name));
         continue;
       }
       if (!entry.isFile() && !entry.isSymbolicLink()) continue;
-      const entryPath = path8.join(entry.parentPath, entry.name);
+      const entryPath = path9.join(entry.parentPath, entry.name);
       presentDirs.add(entry.parentPath);
       if (!extensions.some((ext) => entryPath.endsWith(`.${ext}`))) continue;
       presentPaths.add(entryPath);
@@ -2894,13 +3715,13 @@ async function rescanDirectoryForDelta(watchPath, config, extensions, onEventFun
         }
       })
     );
-    const watchPrefix = watchPath + path8.sep;
+    const watchPrefix = watchPath + path9.sep;
     const firedDirPrefixes = [];
     for (const trackedPath of Object.keys(config.fsTree)) {
       if (!trackedPath.startsWith(watchPrefix) || presentPaths.has(trackedPath)) continue;
-      if (firedDirPrefixes.some((p) => trackedPath.startsWith(p + path8.sep))) continue;
-      const parts = trackedPath.slice(watchPrefix.length).split(path8.sep);
-      const goneDirPath = parts.slice(0, -1).map((_, i) => watchPrefix + parts.slice(0, i + 1).join(path8.sep)).find((p) => !presentDirs.has(p)) ?? null;
+      if (firedDirPrefixes.some((p) => trackedPath.startsWith(p + path9.sep))) continue;
+      const parts = trackedPath.slice(watchPrefix.length).split(path9.sep);
+      const goneDirPath = parts.slice(0, -1).map((_, i) => watchPrefix + parts.slice(0, i + 1).join(path9.sep)).find((p) => !presentDirs.has(p)) ?? null;
       if (goneDirPath !== null) {
         firedDirPrefixes.push(goneDirPath);
         handleWatchEvent(config, extensions, "unlinkDir", goneDirPath, onEventFunc, onFinishFunc);
@@ -3032,48 +3853,90 @@ var init_keyboard_events = __esm({
 });
 
 // lib/setup/write-output-static-files.ts
-import fs11 from "node:fs/promises";
-import path9 from "node:path";
+import fs12 from "node:fs/promises";
+import path10 from "node:path";
 async function writeOutputStaticFiles({ projectRoot, output }, cachedContent) {
   const staticHTMLPromises = Object.keys(cachedContent.staticHTMLs).map(async (staticHTMLKey) => {
-    const htmlRelativePath = path9.relative(projectRoot, staticHTMLKey);
-    const outDir = path9.resolve(projectRoot, output);
-    await ensureFolderExists(path9.join(outDir, htmlRelativePath));
-    await fs11.writeFile(
-      path9.join(outDir, htmlRelativePath),
+    const htmlRelativePath = path10.relative(projectRoot, staticHTMLKey);
+    const outDir = path10.resolve(projectRoot, output);
+    await ensureFolderExists(path10.join(outDir, htmlRelativePath));
+    await fs12.writeFile(
+      path10.join(outDir, htmlRelativePath),
       cachedContent.staticHTMLs[staticHTMLKey]
     );
   });
   const assetPromises = Array.from(cachedContent.assets).map(async (assetAbsolutePath) => {
-    const assetRelativePath = path9.relative(projectRoot, assetAbsolutePath);
-    const outDir = path9.resolve(projectRoot, output);
-    await ensureFolderExists(path9.join(outDir, assetRelativePath));
-    await fs11.copyFile(assetAbsolutePath, path9.join(outDir, assetRelativePath));
+    const assetRelativePath = path10.relative(projectRoot, assetAbsolutePath);
+    const outDir = path10.resolve(projectRoot, output);
+    await ensureFolderExists(path10.join(outDir, assetRelativePath));
+    await fs12.copyFile(assetAbsolutePath, path10.join(outDir, assetRelativePath));
   });
   await Promise.all(staticHTMLPromises.concat(assetPromises));
 }
 async function ensureFolderExists(assetPath) {
-  await fs11.mkdir(path9.dirname(assetPath), { recursive: true });
+  await fs12.mkdir(path10.dirname(assetPath), { recursive: true });
 }
 var init_write_output_static_files = __esm({
   "lib/setup/write-output-static-files.ts"() {
   }
 });
 
+// lib/utils/daemon-hint.ts
+import fs13 from "node:fs/promises";
+import os3 from "node:os";
+import path11 from "node:path";
+function shouldShowDaemonHint(ctx) {
+  const env = ctx.env ?? process.env;
+  if (ctx.watch) return false;
+  if (ctx.daemonMode) return false;
+  if (env.CI) return false;
+  if (env.QUNITX_DAEMON) return false;
+  if (env.QUNITX_NO_DAEMON) return false;
+  if (env.QUNITX_HINT_SHOWN) return false;
+  if (ctx.durationMs < FAST_RUN_THRESHOLD_MS) return false;
+  if (ctx.isTTY === false) return false;
+  if (ctx.isTTY === void 0 && !process.stderr.isTTY) return false;
+  return true;
+}
+async function maybePrintDaemonHint(ctx, opts = {}) {
+  if (!shouldShowDaemonHint(ctx)) return;
+  const sentinel = opts.sentinelPath ?? DEFAULT_SENTINEL;
+  try {
+    await fs13.access(sentinel);
+    return;
+  } catch {
+  }
+  (opts.write ?? ((t) => process.stderr.write(t)))(HINT_TEXT);
+  try {
+    await fs13.mkdir(path11.dirname(sentinel), { recursive: true });
+    await fs13.writeFile(sentinel, (/* @__PURE__ */ new Date()).toISOString());
+  } catch {
+  }
+}
+var FAST_RUN_THRESHOLD_MS, HINT_TEXT, DEFAULT_SENTINEL;
+var init_daemon_hint = __esm({
+  "lib/utils/daemon-hint.ts"() {
+    FAST_RUN_THRESHOLD_MS = 500;
+    HINT_TEXT = "\n\x1B[34m\u2139\x1B[39m Tip: export QUNITX_DAEMON=1 for ~2\xD7 faster repeated runs (qunitx daemon --help)\n";
+    DEFAULT_SENTINEL = path11.join(os3.homedir(), ".cache", "qunitx", "hint-shown");
+  }
+});
+
 // lib/commands/run.ts
 var run_exports = {};
 __export(run_exports, {
+  buildCachedContent: () => buildCachedContent,
   computeFileTimes: () => computeFileTimes,
   default: () => run,
   readTimingCache: () => readTimingCache,
   run: () => run
 });
-import fs12 from "node:fs/promises";
+import fs14 from "node:fs/promises";
 import { join as join3, normalize } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 import { availableParallelism } from "node:os";
 async function run(config) {
-  const browserPromise = config.watch ? null : launchBrowser(config);
+  const browserPromise = config._daemonBrowser ? Promise.resolve(config._daemonBrowser) : config.watch ? null : launchBrowser(config);
   const [cachedContent, timings] = await Promise.all([
     buildCachedContent(config, config.htmlPaths),
     config.watch ? Promise.resolve(null) : readTimingCache(config.projectRoot)
@@ -3184,7 +4047,7 @@ async function run(config) {
     })() : null;
     process.stdout.write("TAP version 13\n");
     process.stdout.write(
-      `# Running ${allFiles.length} test file${allFiles.length === 1 ? "" : "s"} across ${groupCount} group${groupCount === 1 ? "" : "s"}
+      `# Running ${allFiles.length} test file${allFiles.length === 1 ? "" : "s"} across ${groupCount} group${groupCount === 1 ? "" : "s"}${config._daemonMode ? " (daemon)" : ""}
 `
     );
     const [browser] = await Promise.all([
@@ -3242,7 +4105,7 @@ async function run(config) {
           try {
             await runTestsInBrowser(groupConfig, groupCachedContents[i], connections);
           } finally {
-            await flushConsoleHandlers(groupConfig._pendingConsoleHandlers);
+            await flushConsoleHandlers(groupConfig._pendingConsoleHandlers, connections.page);
             await closeWithGrace([
               sharedServer ? void 0 : connections.server?.close(),
               connections.page?.close()
@@ -3279,6 +4142,17 @@ async function run(config) {
     if (config.after) {
       await runUserModule(`${process.cwd()}/${config.after}`, config.COUNTER, "after");
     }
+    if (config._daemonMode) {
+      clearInterval(keepAlive);
+      await closeWithGrace([
+        sharedServer?.close().catch(
+          (err) => config.debug && process.stderr.write(`# [qunitx] server.close: ${err.message}
+`)
+        )
+      ]);
+      throw new DaemonRunError(exitCode);
+    }
+    await maybePrintDaemonHint({ durationMs: process.uptime() * 1e3 });
     const exitTimer = setTimeout(() => process.exit(exitCode), STDOUT_FLUSH_GRACE_MS);
     exitTimer.unref();
     process.stdout.write("\n", async () => {
@@ -3301,7 +4175,7 @@ async function run(config) {
 }
 async function buildCachedContent(config, htmlPaths) {
   const htmlBuffers = await Promise.all(
-    config.htmlPaths.map((htmlPath) => fs12.readFile(htmlPath).catch(() => null))
+    config.htmlPaths.map((htmlPath) => fs14.readFile(htmlPath).catch(() => null))
   );
   const cachedContent = htmlPaths.reduce(
     (result, _htmlPath, index) => {
@@ -3356,7 +4230,7 @@ async function addCachedContentMainHTML(projectRoot, cachedContent) {
 }
 async function readTimingCache(projectRoot) {
   try {
-    const parsed = JSON.parse(await fs12.readFile(`${projectRoot}/tmp/test-timings.json`, "utf8"));
+    const parsed = JSON.parse(await fs14.readFile(`${projectRoot}/tmp/test-timings.json`, "utf8"));
     return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};
@@ -3375,7 +4249,7 @@ function computeFileTimes(groups, weights, wallTimes) {
   return result;
 }
 async function persistTimings(fileTimes, projectRoot) {
-  await fs12.writeFile(
+  await fs14.writeFile(
     `${projectRoot}/tmp/test-timings.json`,
     JSON.stringify(Object.fromEntries(fileTimes), null, 2)
   );
@@ -3390,7 +4264,7 @@ ${lines.join("\n")}
 async function splitIntoGroups(files, groupCount, timings) {
   const sizes = await Promise.all(
     files.map(
-      (f) => timings[f] > 0 ? Promise.resolve(0) : fs12.stat(f).then((s) => s.size).catch(() => 0)
+      (f) => timings[f] > 0 ? Promise.resolve(0) : fs14.stat(f).then((s) => s.size).catch(() => 0)
     )
   );
   const knownRates = files.map((f, i) => ({ ms: timings[f], size: sizes[i] })).filter(({ ms, size }) => ms > 0 && size > 0);
@@ -3450,539 +4324,485 @@ var init_run = __esm({
     init_read_template();
     init_html();
     init_close_with_grace();
-    WATCH_NAV_TIMEOUT_MS = 5e3;
-    STDOUT_FLUSH_GRACE_MS = 5e3;
-    KEEP_ALIVE_INTERVAL_MS = 1e4;
-    EXIT_CODE_SIGTERM = 128 + 15;
-  }
-});
-
-// cli.ts
-init_chrome_prelaunch();
-import process4 from "node:process";
-
-// lib/commands/help.ts
-init_color();
-
-// package.json
-var package_default = {
-  name: "qunitx-cli",
-  type: "module",
-  version: "0.22.3",
-  description: "Browser runner for QUnitx: run your qunitx tests in google-chrome",
-  author: "Izel Nakri",
-  license: "MIT",
-  keywords: [
-    "test runner",
-    "testing",
-    "browser",
-    "ci",
-    "qunit",
-    "qunitx"
-  ],
-  files: [
-    "bin/",
-    "dist/",
-    "templates/"
-  ],
-  scripts: {
-    build: "node scripts/build-cli.js",
-    bin: "chmod +x cli.ts && ./cli.ts",
-    prepublishOnly: "npm run build",
-    format: 'prettier --check "lib/**/*.ts" "test/**/*.ts" "scripts/**/*.js" "bin/**/*.js" "*.ts" "package.json" ".github/**/*.yml"',
-    "format:fix": 'prettier --write "lib/**/*.ts" "test/**/*.ts" "scripts/**/*.js" "bin/**/*.js" "*.ts" "package.json" ".github/**/*.yml"',
-    lint: "deno lint lib/ bin/ cli.ts",
-    "lint:docs": "node scripts/lint-docs.js",
-    docs: `deno doc --html --name="qunitx-cli" --output=docs/lib 'lib/**/*.ts' README.md`,
-    "changelog:unreleased": "git-cliff --unreleased --strip all",
-    "changelog:preview": "git-cliff",
-    "changelog:update": "git-cliff --output CHANGELOG.md",
-    postinstall: "PLAYWRIGHT_SKIP_DOWNLOAD=true deno install --allow-scripts=npm:playwright-core || true",
-    test: "node test/runner.ts",
-    "test:debug": "QUNITX_DEBUG=1 node test/runner.ts",
-    dev: "node test/runner.ts --watch",
-    "test:browser": "node test/runner.ts test/flags/*-test.ts test/inputs/*-test.ts",
-    "test:release": "bash scripts/test-release.sh",
-    "test:sanity-first": "./cli.ts test/helpers/failing-tests.js test/helpers/failing-tests.ts",
-    "test:sanity-second": "./cli.ts test/helpers/passing-tests.js test/helpers/passing-tests.ts"
-  },
-  engines: {
-    node: ">=24.0.0",
-    deno: ">=2.7.0"
-  },
-  bin: {
-    qunitx: "bin/qunitx.js"
-  },
-  repository: {
-    type: "git",
-    url: "git+https://github.com/izelnakri/qunitx-cli.git"
-  },
-  dependencies: {
-    esbuild: "^0.28.0",
-    "playwright-core": "^1.59.1",
-    ws: "^8.20.0"
-  },
-  devDependencies: {
-    "js-yaml": "^4.1.1",
-    prettier: "^3.8.3",
-    qunitx: "^1.2.9",
-    react: "^19.2.5",
-    "react-dom": "^19.2.5",
-    typescript: "^6.0.3",
-    vue: "^3.5.33"
-  },
-  volta: {
-    node: "24.14.0"
-  },
-  prettier: {
-    printWidth: 100,
-    singleQuote: true,
-    arrowParens: "always"
-  },
-  optionalDependencies: {
-    "qunitx-cli-linux-x64": "*"
-  }
-};
-
-// lib/commands/help.ts
-var highlight = (text) => magenta().bold(text);
-var color = (text) => blue(text);
-function displayHelpOutput() {
-  const config = package_default;
-  console.log(`${highlight("[qunitx v" + config.version + "] Usage:")} qunitx ${color("[targets] --$flags")}
-
-${highlight("Input options:")}
-- File: $ ${color("qunitx test/foo.js")}
-- Folder: $ ${color("qunitx test/login")}
-- Globs: $ ${color("qunitx test/**/*-test.js")}
-- Combination: $ ${color("qunitx test/foo.js test/bar.js test/*-test.js test/logout")}
-
-${highlight("Optional flags:")}
-${color("--debug")} : print console output when tests run in browser
-${color("--watch")} : run the target file or folders, watch them for continuous run and expose http server under localhost
-${color("--open")} : run tests in a visible browser window instead of headless; keeps the server alive (short: ${color("-o")})
-${color("--timeout")} : change default timeout per test case
-${color("--output")} : folder to distribute built qunitx html and js that a webservers can run[default: tmp]
-${color("--failFast")} : run the target file or folders with immediate abort if a single test fails
-${color("--port")} : HTTP server port (auto-selects a free port if the given port is taken)[default: 1234]
-${color("--extensions")} : comma-separated file extensions to track for discovery and watch-mode rebuilds[default: js,ts,jsx,tsx]
-${color("--browser")} : browser engine to run tests in: chromium, firefox, webkit[default: chromium]
-${color("--before")} : run a script before the tests(i.e start a new web server before tests)
-${color("--after")} : run a script after the tests(i.e save test results to a file)
-
-${highlight("Example:")} $ ${color("qunitx test/foo.ts app/e2e --debug --watch --before=scripts/start-new-webserver.js --after=scripts/write-test-results.js")}
-
-${highlight("Commands:")}
-${color("$ qunitx init")}               # Bootstraps qunitx base html and add qunitx config to package.json if needed
-${color("$ qunitx new $testFileName")}  # Creates a qunitx test file
-`);
-}
-
-// lib/commands/init.ts
-import fs4 from "node:fs/promises";
-import path2 from "node:path";
-
-// lib/utils/find-project-root.ts
-import process2 from "node:process";
-
-// lib/utils/path-exists.ts
-import fs2 from "node:fs/promises";
-async function pathExists(path10) {
-  try {
-    await fs2.access(path10);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// lib/utils/search-in-parent-directories.ts
-async function searchInParentDirectories(directory, targetEntry) {
-  const resolvedDirectory = directory === "." ? process.cwd() : directory;
-  if (await pathExists(`${resolvedDirectory}/${targetEntry}`)) {
-    return `${resolvedDirectory}/${targetEntry}`;
-  } else if (resolvedDirectory === "") {
-    return;
-  }
-  return await searchInParentDirectories(
-    resolvedDirectory.slice(0, resolvedDirectory.lastIndexOf("/")),
-    targetEntry
-  );
-}
-
-// lib/utils/find-project-root.ts
-async function findProjectRoot() {
-  try {
-    const absolutePath = await searchInParentDirectories(".", "package.json");
-    if (!absolutePath.includes("package.json")) {
-      throw new Error("package.json mising");
-    }
-    return absolutePath.replace("/package.json", "");
-  } catch (_error) {
-    console.log("couldnt find projects package.json, did you run $ npm init ??");
-    process2.exit(1);
-  }
-}
-
-// lib/commands/init.ts
-init_default_project_config_values();
-init_read_template();
-async function initializeProject() {
-  const projectRoot = await findProjectRoot();
-  const oldPackageJSON = JSON.parse(await fs4.readFile(`${projectRoot}/package.json`));
-  const existingQunitx = oldPackageJSON.qunitx || {};
-  const cliHtmlPaths = process.argv.slice(2).filter((arg) => arg.endsWith(".html"));
-  const config = Object.assign({}, defaultProjectConfigValues, existingQunitx, {
-    htmlPaths: cliHtmlPaths.length > 0 ? cliHtmlPaths : existingQunitx.htmlPaths || ["test/tests.html"]
-  });
-  await Promise.all([
-    writeTestsHTML(projectRoot, config, oldPackageJSON),
-    rewritePackageJSON(projectRoot, config, oldPackageJSON),
-    writeTSConfigIfNeeded(projectRoot)
-  ]);
-}
-async function writeTestsHTML(projectRoot, config, oldPackageJSON) {
-  const testHTMLTemplateBuffer = await readTemplate("setup/tests.hbs");
-  return await Promise.all(
-    config.htmlPaths.map(async (htmlPath) => {
-      const targetPath = `${projectRoot}/${htmlPath}`;
-      if (await pathExists(targetPath)) {
-        return console.log(`${htmlPath} already exists`);
-      } else {
-        const targetDirectory = path2.dirname(targetPath);
-        const _targetOutputPath = path2.relative(
-          targetDirectory,
-          path2.join(path2.resolve(projectRoot, config.output), "tests.js")
-        );
-        const testHTMLTemplate = testHTMLTemplateBuffer.replace(
-          "{{applicationName}}",
-          oldPackageJSON.name
-        );
-        await fs4.mkdir(targetDirectory, { recursive: true });
-        await fs4.writeFile(targetPath, testHTMLTemplate);
-        console.log(`${targetPath} written`);
-      }
-    })
-  );
-}
-async function rewritePackageJSON(projectRoot, config, oldPackageJSON) {
-  const newPackageJSON = Object.assign(oldPackageJSON, { qunitx: config });
-  await fs4.writeFile(`${projectRoot}/package.json`, JSON.stringify(newPackageJSON, null, 2));
-}
-async function writeTSConfigIfNeeded(projectRoot) {
-  const targetPath = `${projectRoot}/tsconfig.json`;
-  if (!await pathExists(targetPath)) {
-    const tsConfigTemplate = await readTemplate("setup/tsconfig.json");
-    await fs4.writeFile(targetPath, tsConfigTemplate);
-    console.log(`${targetPath} written`);
-  }
-}
-
-// lib/commands/generate.ts
-init_color();
-import fs5 from "node:fs/promises";
-init_read_template();
-
-// lib/utils/convert-to-pascal-case.ts
-function convertToPascalCase(str) {
-  return str.split(/[-_]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
-}
-
-// lib/commands/generate.ts
-async function generateTestFiles() {
-  const projectRoot = await findProjectRoot();
-  const moduleName = pathToModuleName(process.argv[3]);
-  const path10 = process.argv[3].endsWith(".js") || process.argv[3].endsWith(".ts") ? `${projectRoot}/${process.argv[3]}` : `${projectRoot}/${process.argv[3]}.js`;
-  if (await pathExists(path10)) {
-    console.log(`${path10} already exists!`);
-    return;
-  }
-  const testJSContent = await readTemplate("test.js");
-  const targetFolderPaths = path10.split("/");
-  targetFolderPaths.pop();
-  await fs5.mkdir(targetFolderPaths.join("/"), { recursive: true });
-  await fs5.writeFile(path10, testJSContent.replace("{{moduleName}}", moduleName));
-  console.log(green(`${path10} written`));
-}
-function pathToModuleName(filePath) {
-  const withoutExt = filePath.replace(/\.(js|ts)$/, "");
-  const segments = withoutExt.split("/");
-  const targetNames = segments[0] === "test" || segments[0] === "tests" ? segments.slice(1) : segments;
-  return targetNames.map(convertToPascalCase).join(" | ");
-}
-
-// lib/setup/config.ts
-init_default_project_config_values();
-import fs7 from "node:fs/promises";
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
-
-// lib/setup/fs-tree.ts
-init_default_project_config_values();
-import fs6, { glob as fsGlob } from "node:fs/promises";
-import path3 from "node:path";
-async function buildFSTree(fileAbsolutePaths, config = {}) {
-  const targetExtensions = config.extensions || defaultProjectConfigValues.extensions;
-  const fsTree = {};
-  await Promise.all(
-    fileAbsolutePaths.map(async (fileAbsolutePath) => {
-      try {
-        if (isGlob(fileAbsolutePath)) {
-          for await (const fileName of fsGlob(fileAbsolutePath)) {
-            if (targetExtensions.some((ext) => fileName.endsWith(`.${ext}`))) {
-              fsTree[fileName] = null;
-            }
-          }
-        } else {
-          const entry = await fs6.stat(fileAbsolutePath);
-          if (entry.isFile()) {
-            fsTree[fileAbsolutePath] = null;
-          } else if (entry.isDirectory()) {
-            const fileNames = await readDirRecursive(fileAbsolutePath, (name) => {
-              return targetExtensions.some((extension) => name.endsWith(`.${extension}`));
-            });
-            fileNames.forEach((fileName) => {
-              fsTree[fileName] = null;
-            });
-          }
-        }
-      } catch (error) {
-        console.error(error);
-        return process.exit(1);
-      }
-    })
-  );
-  return fsTree;
-}
-function isGlob(str) {
-  return /[*?{[]/.test(str);
-}
-async function readDirRecursive(dir, filter) {
-  const entries = await fs6.readdir(dir, { recursive: true, withFileTypes: true });
-  const candidates = entries.filter(
-    (dirent) => (dirent.isFile() || dirent.isSymbolicLink()) && filter(dirent.name)
-  );
-  const resolvedPaths = await Promise.all(
-    candidates.map(async (dirent) => {
-      const fullPath = path3.join(dirent.parentPath, dirent.name);
-      if (dirent.isFile()) return fullPath;
-      try {
-        const statResult = await fs6.stat(fullPath);
-        return statResult.isFile() ? fullPath : null;
-      } catch {
-        return null;
-      }
-    })
-  );
-  return resolvedPaths.filter((resolvedPath) => resolvedPath !== null);
-}
-
-// lib/setup/test-file-paths.ts
-import { matchesGlob } from "node:path";
-var GLOB_CHARS = /[*?{[]/;
-function setupTestFilePaths(inputs2) {
-  const folders = [];
-  const filesWithGlob = [];
-  const filesWithoutGlob = [];
-  inputs2.forEach((input) => {
-    if (!pathIsFile(input)) {
-      folders.push({ input, globFormat: `${input}/**` });
-    } else if (isGlob2(input)) {
-      filesWithGlob.push({ input, globFormat: input });
-    } else {
-      filesWithoutGlob.push({ input, globFormat: input });
-    }
+    init_daemon_hint();
+    WATCH_NAV_TIMEOUT_MS = 5e3;
+    STDOUT_FLUSH_GRACE_MS = 5e3;
+    KEEP_ALIVE_INTERVAL_MS = 1e4;
+    EXIT_CODE_SIGTERM = 128 + 15;
+  }
+});
+
+// lib/commands/daemon/server.ts
+var server_exports = {};
+__export(server_exports, {
+  runDaemonServer: () => runDaemonServer
+});
+import net2 from "node:net";
+import fs15 from "node:fs";
+import { writeFile, unlink, stat as stat2, chmod } from "node:fs/promises";
+import path12 from "node:path";
+async function runDaemonServer() {
+  const cwd = process.cwd();
+  const socketPath = daemonSocketPath(cwd);
+  const infoPath = daemonInfoPath(cwd);
+  if (fs15.existsSync(infoPath) && await isLiveSocket(socketPath)) process.exit(0);
+  await unlink(socketPath).catch(() => {
+  });
+  const logPath = process.env.QUNITX_DAEMON_LOG;
+  if (logPath) {
+    const log = fs15.createWriteStream(logPath, { flags: "a" });
+    log.on("error", () => {
+    });
+    const forward = log.write.bind(log);
+    process.stdout.write = forward;
+    process.stderr.write = forward;
+  }
+  const argvSnapshot = process.argv;
+  process.argv = [argvSnapshot[0], argvSnapshot[1] ?? "cli.ts"];
+  let baseConfig;
+  try {
+    baseConfig = await setupConfig();
+  } finally {
+    process.argv = argvSnapshot;
+  }
+  baseConfig._daemonMode = true;
+  baseConfig.watch = false;
+  baseConfig.open = false;
+  const [browser, pkgMtime] = await Promise.all([launchBrowser(baseConfig), readPkgMtime(cwd)]);
+  const state = {
+    browser,
+    baseConfig,
+    cwd,
+    startedAt: Date.now(),
+    pkgMtime,
+    runQueue: Promise.resolve(),
+    shuttingDown: false,
+    pendingClients: /* @__PURE__ */ new Set(),
+    socketServer: null,
+    idleTimer: null,
+    socketPath,
+    infoPath,
+    consecutiveCrashes: 0,
+    listenSucceeded: false,
+    esbuildCache: { _esbuildContext: null }
+  };
+  const shutdown = (reason) => shutdownDaemon2(state, reason);
+  process.on("SIGTERM", () => void shutdown("SIGTERM"));
+  process.on("SIGINT", () => void shutdown("SIGINT"));
+  process.on("unhandledRejection", (err) => {
+    process.stderr.write(`# [qunitx daemon] unhandledRejection: ${err}
+`);
+    void shutdown("unhandledRejection");
+  });
+  state.socketServer = net2.createServer((socket) => handleConnection(socket, state));
+  state.socketServer.on("error", (err) => {
+    process.stderr.write(`# [qunitx daemon] server error: ${err.message}
+`);
+    void shutdown("server error");
+  });
+  await listen(state.socketServer, socketPath);
+  state.listenSucceeded = true;
+  if (process.platform !== "win32") await chmod(socketPath, 384).catch(() => {
+  });
+  const info = {
+    pid: process.pid,
+    socketPath,
+    cwd,
+    nodeVersion: process.version,
+    startedAt: state.startedAt
+  };
+  await writeFile(infoPath, JSON.stringify(info, null, 2));
+  resetIdleTimer(state);
+  process.stderr.write(`# [qunitx daemon] listening on ${socketPath} (pid ${process.pid})
+`);
+  return new Promise(() => {
   });
-  const dedupedFolders = folders.filter((folder) => !isIncludedIn(folders, folder));
-  const dedupedGlobFiles = filesWithGlob.filter(
-    (file) => !isIncludedIn(dedupedFolders, file) && !isIncludedIn(filesWithGlob, file)
-  );
-  const dedupedPlainFiles = filesWithoutGlob.reduce((acc, file) => {
-    if (!isIncludedIn(dedupedFolders, file) && !isIncludedIn(dedupedGlobFiles, file) && !isIncludedIn(acc, file)) {
-      acc.push(file);
-    }
-    return acc;
-  }, []);
-  return dedupedFolders.concat(dedupedGlobFiles, dedupedPlainFiles).map((meta) => meta.input);
 }
-function pathIsFile(path10) {
-  return path10.includes(".", path10.lastIndexOf("/") + 1);
+function listen(server, socketPath) {
+  return new Promise((resolve, reject) => {
+    const onError = (err) => reject(err);
+    server.once("error", onError);
+    server.listen(socketPath, () => {
+      server.removeListener("error", onError);
+      resolve();
+    });
+  });
 }
-function isIncludedIn(paths, target) {
-  return paths.some((path10) => path10 !== target && matchesGlob(target.input, path10.globFormat));
+async function shutdownDaemon2(state, reason) {
+  if (state.shuttingDown) return;
+  state.shuttingDown = true;
+  process.stderr.write(`# [qunitx daemon] shutting down: ${reason}
+`);
+  if (state.idleTimer) clearTimeout(state.idleTimer);
+  for (const sock of state.pendingClients) {
+    writeChunk(sock, { type: "fatal", message: `daemon shutting down: ${reason}` });
+    sock.end();
+  }
+  await new Promise((resolve) => state.socketServer.close(() => resolve()));
+  await Promise.all([
+    state.listenSucceeded ? unlink(state.socketPath).catch(() => {
+    }) : null,
+    state.listenSucceeded ? unlink(state.infoPath).catch(() => {
+    }) : null,
+    state.browser.close().catch(() => {
+    }),
+    state.esbuildCache._esbuildContext?.dispose().catch(() => {
+    })
+  ]);
+  process.exit(0);
 }
-function isGlob2(str) {
-  return GLOB_CHARS.test(str);
+function resetIdleTimer(state) {
+  if (state.idleTimer) clearTimeout(state.idleTimer);
+  state.idleTimer = setTimeout(() => void shutdownDaemon2(state, "idle timeout"), IDLE_TIMEOUT_MS);
+  state.idleTimer.unref();
 }
-
-// lib/utils/parse-cli-flags.ts
-import path4 from "node:path";
-var FALLBACK_TIMEOUT_MS = 1e4;
-function parseCliFlags(projectRoot) {
-  const providedFlags = process.argv.slice(2).reduce(
-    (result, arg) => {
-      if (arg.startsWith("--debug")) {
-        return Object.assign(result, { debug: parseBoolean(arg.split("=")[1]) });
-      } else if (arg.startsWith("--watch")) {
-        return Object.assign(result, { watch: parseBoolean(arg.split("=")[1]) });
-      } else if (arg === "-o" || arg.startsWith("-o=") || arg.startsWith("--open")) {
-        const value = arg.split("=")[1];
-        const open = value === void 0 || value === "true" ? true : value === "false" ? false : value;
-        return Object.assign(result, { open });
-      } else if (arg.startsWith("--failfast") || arg.startsWith("--failFast")) {
-        return Object.assign(result, { failFast: parseBoolean(arg.split("=")[1]) });
-      } else if (arg.startsWith("--timeout")) {
-        return Object.assign(result, { timeout: Number(arg.split("=")[1]) || FALLBACK_TIMEOUT_MS });
-      } else if (arg.startsWith("--output")) {
-        return Object.assign(result, { output: arg.split("=")[1] });
-      } else if (arg.endsWith(".html")) {
-        if (result.htmlPaths) {
-          result.htmlPaths.push(arg);
-        } else {
-          result.htmlPaths = [arg];
-        }
-        return result;
-      } else if (arg.startsWith("--port")) {
-        return Object.assign(result, { port: Number(arg.split("=")[1]), portExplicit: true });
-      } else if (arg.startsWith("--extensions")) {
-        return Object.assign(result, {
-          extensions: arg.split("=")[1].split(",").map((extension) => extension.trim())
-        });
-      } else if (arg.startsWith("--browser")) {
-        const value = arg.split("=")[1];
-        if (!["chromium", "firefox", "webkit"].includes(value)) {
-          console.error(
-            `Invalid --browser value: "${value}". Must be one of: chromium, firefox, webkit`
-          );
-          process.exit(1);
-        }
-        return Object.assign(result, { browser: value });
-      } else if (arg.startsWith("--before")) {
-        return Object.assign(result, { before: parseModule(arg.split("=")[1]) });
-      } else if (arg.startsWith("--after")) {
-        return Object.assign(result, { after: parseModule(arg.split("=")[1]) });
-      } else if (arg === "--trace-perf") {
-        return result;
-      }
-      if (arg.startsWith("-")) {
-        console.warn(`# Warning: Unknown flag "${arg}" \u2014 ignored`);
-        return result;
-      }
-      result.inputs.add(
-        arg.startsWith(projectRoot) || arg.startsWith("/") ? arg : path4.join(process.cwd(), arg)
-      );
-      return result;
-    },
-    { inputs: /* @__PURE__ */ new Set([]) }
-  );
-  if (!providedFlags.browser && process.env.QUNITX_BROWSER) {
-    const envBrowser = process.env.QUNITX_BROWSER;
-    if (!["chromium", "firefox", "webkit"].includes(envBrowser)) {
-      console.error(
-        `Invalid QUNITX_BROWSER value: "${envBrowser}". Must be one of: chromium, firefox, webkit`
-      );
-      process.exit(1);
+function handleConnection(socket, state) {
+  state.pendingClients.add(socket);
+  socket.on("close", () => state.pendingClients.delete(socket));
+  socket.on("error", () => {
+  });
+  attachLineParser(socket, (req) => void dispatch(req, socket, state));
+}
+async function dispatch(req, socket, state) {
+  if (req.type === "ping") {
+    writeChunk(socket, {
+      type: "pong",
+      pid: process.pid,
+      nodeVersion: process.version,
+      cwd: state.cwd,
+      startedAt: state.startedAt
+    });
+    socket.end();
+  } else if (req.type === "shutdown") {
+    try {
+      fs15.unlinkSync(state.infoPath);
+    } catch {
     }
-    providedFlags.browser = envBrowser;
+    writeChunk(socket, { type: "done", exitCode: 0 });
+    socket.end();
+    void shutdownDaemon2(state, "shutdown request");
+  } else if (req.type === "run") {
+    state.runQueue = state.runQueue.then(() => handleRun(req, socket, state));
+    await state.runQueue;
   }
-  return { ...providedFlags, inputs: Array.from(providedFlags.inputs) };
 }
-function parseBoolean(result, defaultValue = true) {
-  if (result === "true") {
+function writeChunk(socket, chunk) {
+  if (socket.destroyed) return;
+  try {
+    socket.write(JSON.stringify(chunk) + "\n");
+  } catch {
+  }
+}
+function makeInterceptor(socket, type) {
+  return ((chunk, ...args) => {
+    if (!socket.destroyed) {
+      const str = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      writeChunk(socket, { type, data: str });
+    }
+    const cb = args[args.length - 1];
+    if (typeof cb === "function") queueMicrotask(cb);
     return true;
-  } else if (result === "false") {
-    return false;
+  });
+}
+async function handleRun(req, socket, state) {
+  if (state.shuttingDown) {
+    writeChunk(socket, { type: "fatal", message: "daemon shutting down" });
+    return void socket.end();
+  } else if (req.cwd !== state.cwd) {
+    writeChunk(socket, {
+      type: "fatal",
+      message: `cwd mismatch: daemon=${state.cwd} client=${req.cwd}`
+    });
+    return void socket.end();
+  } else if (req.nodeVersion !== process.version) {
+    writeChunk(socket, {
+      type: "fatal",
+      message: `node version mismatch: daemon=${process.version} client=${req.nodeVersion}`
+    });
+    socket.end();
+    return void shutdownDaemon2(state, "node version mismatch");
   }
-  return defaultValue;
+  const currentMtime = await readPkgMtime(state.cwd);
+  if (currentMtime !== state.pkgMtime) {
+    writeChunk(socket, { type: "fatal", message: "package.json changed; restarting daemon" });
+    socket.end();
+    return void shutdownDaemon2(state, "package.json changed");
+  }
+  if (state.idleTimer) clearTimeout(state.idleTimer);
+  if (!state.browser.isConnected()) {
+    await recoverBrowser(state);
+    if (state.shuttingDown) {
+      writeChunk(socket, { type: "fatal", message: "browser recovery failed" });
+      return void socket.end();
+    }
+  }
+  const origStdoutWrite = process.stdout.write.bind(process.stdout);
+  const origStderrWrite = process.stderr.write.bind(process.stderr);
+  process.stdout.write = makeInterceptor(socket, "stdout");
+  process.stderr.write = makeInterceptor(socket, "stderr");
+  let exitCode = 0;
+  try {
+    exitCode = await runOnce(req.argv, req.env, state);
+  } catch (err) {
+    process.stderr.write = origStderrWrite;
+    origStderrWrite(`# [qunitx daemon] run error: ${err.stack || err}
+`);
+    if (!socket.destroyed)
+      writeChunk(socket, { type: "fatal", message: err.message || String(err) });
+    exitCode = 1;
+  } finally {
+    process.stdout.write = origStdoutWrite;
+    process.stderr.write = origStderrWrite;
+  }
+  if (state.browser.isConnected()) state.consecutiveCrashes = 0;
+  else await recoverBrowser(state);
+  if (!socket.destroyed) {
+    writeChunk(socket, { type: "done", exitCode });
+    socket.end();
+  }
+  resetIdleTimer(state);
 }
-function parseModule(value) {
-  if (["false", "'false'", '"false"', ""].includes(value)) {
-    return false;
+async function recoverBrowser(state) {
+  if (++state.consecutiveCrashes > MAX_CONSECUTIVE_CRASHES) {
+    return void shutdownDaemon2(state, `${state.consecutiveCrashes} consecutive browser crashes`);
+  }
+  process.stderr.write(
+    `# [qunitx daemon] browser crashed; relaunching (${state.consecutiveCrashes}/${MAX_CONSECUTIVE_CRASHES})
+`
+  );
+  state.browser.close().catch(() => {
+  });
+  try {
+    state.browser = await launchBrowser(state.baseConfig, true);
+  } catch (err) {
+    void shutdownDaemon2(state, `browser relaunch failed: ${err.message || err}`);
   }
-  return value;
 }
-
-// lib/setup/config.ts
-async function setupConfig() {
-  const projectRoot = await findProjectRoot();
-  const cliConfigFlags = parseCliFlags(projectRoot);
-  const projectPackageJSON = await readConfigFromPackageJSON(projectRoot);
-  const { plugins: rawPlugins, ...userQunitx } = projectPackageJSON.qunitx ?? {};
-  const pluginsPromise = resolvePlugins(rawPlugins, projectRoot);
-  const inputs2 = cliConfigFlags.inputs.concat(readInputsFromPackageJSON(projectPackageJSON));
-  const config = {
-    ...defaultProjectConfigValues,
-    htmlPaths: [],
-    ...userQunitx,
-    ...cliConfigFlags,
-    projectRoot,
-    inputs: inputs2,
-    testFileLookupPaths: setupTestFilePaths(inputs2),
-    lastFailedTestFiles: null,
-    lastRanTestFiles: null,
-    COUNTER: {
-      testCount: 0,
-      failCount: 0,
-      skipCount: 0,
-      todoCount: 0,
-      passCount: 0,
-      errorCount: 0
-    },
-    _testRunDone: null,
-    _resetTestTimeout: null,
-    _onWsOpen: null,
-    _onTestsJsServed: null
-  };
-  config.htmlPaths = normalizeHTMLPaths(config.projectRoot, config.htmlPaths);
-  [config.fsTree, config.plugins] = await Promise.all([
-    buildFSTree(config.testFileLookupPaths, config),
-    pluginsPromise
-  ]);
-  return config;
+async function runOnce(argv, env, state) {
+  const envSnapshot = { ...process.env };
+  for (const [key, value] of Object.entries(env)) {
+    if (value !== void 0) process.env[key] = value;
+  }
+  const argvSnapshot = process.argv;
+  process.argv = ["node", argvSnapshot[1] ?? "cli.ts", ...argv];
+  let config;
+  try {
+    config = await setupConfig();
+  } finally {
+    process.argv = argvSnapshot;
+  }
+  config._daemonMode = true;
+  config._daemonBrowser = state.browser;
+  config._daemonEsbuildCache = state.esbuildCache;
+  config.watch = false;
+  config.open = false;
+  try {
+    await run(config);
+    return config.COUNTER.failCount > 0 ? 1 : 0;
+  } catch (err) {
+    if (err instanceof DaemonRunError) return err.exitCode;
+    throw err;
+  } finally {
+    for (const key of Object.keys(process.env)) {
+      if (!(key in envSnapshot)) delete process.env[key];
+    }
+    Object.assign(process.env, envSnapshot);
+  }
 }
-async function readConfigFromPackageJSON(projectRoot) {
-  const packageJSON = await fs7.readFile(`${projectRoot}/package.json`);
-  return JSON.parse(packageJSON.toString());
+async function isLiveSocket(socketPath) {
+  const sock = await probeSocket(socketPath, LIVENESS_PROBE_TIMEOUT_MS);
+  if (!sock) return false;
+  sock.destroy();
+  return true;
 }
-function normalizeHTMLPaths(projectRoot, htmlPaths) {
-  return Array.from(new Set(htmlPaths.map((htmlPath) => `${projectRoot}/${htmlPath}`)));
+async function readPkgMtime(cwd) {
+  try {
+    return (await stat2(path12.join(cwd, "package.json"))).mtimeMs;
+  } catch {
+    return 0;
+  }
 }
-function readInputsFromPackageJSON(packageJSON) {
-  const qunitx = packageJSON.qunitx;
-  return qunitx && qunitx.inputs ? qunitx.inputs : [];
+var IDLE_TIMEOUT_MS, LIVENESS_PROBE_TIMEOUT_MS, MAX_CONSECUTIVE_CRASHES;
+var init_server = __esm({
+  "lib/commands/daemon/server.ts"() {
+    init_daemon_socket_path();
+    init_socket_utils();
+    init_config();
+    init_browser();
+    init_tests_in_browser();
+    init_run();
+    IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
+    LIVENESS_PROBE_TIMEOUT_MS = 500;
+    MAX_CONSECUTIVE_CRASHES = 2;
+  }
+});
+
+// lib/commands/daemon/index.ts
+var daemon_exports = {};
+__export(daemon_exports, {
+  ensureDaemonRunning: () => ensureDaemonRunning,
+  runDaemonCommand: () => runDaemonCommand
+});
+import { spawn as spawn3 } from "node:child_process";
+import fs16, { existsSync as existsSync3 } from "node:fs";
+import path13 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function runDaemonCommand() {
+  const sub = process.argv[3];
+  if (sub === "_serve") return runServeMode();
+  if (sub === "start") return startDaemon();
+  if (sub === "stop") return stopDaemon();
+  if (sub === "status") return statusDaemon();
+  const helpRequested = !sub || sub === "--help" || sub === "-h" || sub === "help";
+  const out = helpRequested ? process.stdout : process.stderr;
+  out.write(USAGE);
+  return Promise.resolve(helpRequested ? 0 : 1);
+}
+async function runServeMode() {
+  const { runDaemonServer: runDaemonServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  await runDaemonServer2();
+  return 0;
+}
+function waitForFile(filePath, timeoutMs) {
+  if (existsSync3(filePath)) return Promise.resolve(true);
+  return new Promise((resolve) => {
+    const dir = path13.dirname(filePath);
+    const fileName = path13.basename(filePath);
+    const settle = (ok) => {
+      clearTimeout(timer);
+      watcher.close();
+      resolve(ok);
+    };
+    const timer = setTimeout(() => settle(false), timeoutMs);
+    const watcher = fs16.watch(dir, (_event, name) => {
+      if (name === fileName && existsSync3(filePath)) settle(true);
+    });
+    watcher.on("error", () => settle(false));
+    if (existsSync3(filePath)) settle(true);
+  });
 }
-function resolvePlugins(raw, projectRoot) {
-  if (raw == null) return Promise.resolve([]);
-  if (!Array.isArray(raw)) {
-    console.error(`# qunitx: package.json#qunitx.plugins must be an array`);
-    process.exit(1);
+async function spawnAndWaitForDaemon() {
+  spawn3(process.execPath, [CLI_ENTRY, "daemon", "_serve"], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env, QUNITX_DAEMON_CWD: process.cwd() }
+  }).unref();
+  if (!await waitForFile(daemonInfoPath(), SPAWN_TIMEOUT_MS)) return null;
+  const pong = await pingDaemon();
+  return pong?.type === "pong" ? { pid: pong.pid } : null;
+}
+async function ensureDaemonRunning() {
+  if ((await pingDaemon())?.type === "pong") return true;
+  return Boolean(await spawnAndWaitForDaemon());
+}
+async function startDaemon() {
+  const existing = await pingDaemon();
+  if (existing?.type === "pong") {
+    process.stdout.write(`Daemon already running (pid ${existing.pid})
+`);
+    return 0;
   }
-  const projectRequire = createRequire(`${projectRoot}/package.json`);
-  return Promise.all(
-    raw.map(async (entry) => {
-      const [spec, options] = Array.isArray(entry) ? entry : [entry];
-      const mod = await import(pathToFileURL(projectRequire.resolve(spec)).href);
-      const exported = mod.default ?? mod;
-      return typeof exported === "function" ? exported(options) : exported;
-    })
+  const result = await spawnAndWaitForDaemon();
+  if (result) {
+    process.stdout.write(`Daemon started (pid ${result.pid})
+`);
+    return 0;
+  }
+  process.stderr.write(`Daemon did not start within ${SPAWN_TIMEOUT_MS / 1e3}s
+`);
+  return 1;
+}
+async function stopDaemon() {
+  const stopped = await shutdownDaemon();
+  process.stdout.write(stopped ? "Daemon stopped\n" : "No daemon was running\n");
+  return 0;
+}
+async function statusDaemon() {
+  const pong = await pingDaemon();
+  if (pong?.type !== "pong") {
+    process.stdout.write("No daemon running for this project\n");
+    return 1;
+  }
+  const ageMin = Math.round((Date.now() - pong.startedAt) / 6e4);
+  process.stdout.write(
+    `Daemon running
+  pid:     ${pong.pid}
+  cwd:     ${pong.cwd}
+  node:    ${pong.nodeVersion}
+  uptime:  ${ageMin} min
+  socket:  ${daemonSocketPath(pong.cwd)}
+`
   );
+  return 0;
 }
+var SPAWN_TIMEOUT_MS, highlight2, color2, USAGE, __filename, CLI_ENTRY;
+var init_daemon = __esm({
+  "lib/commands/daemon/index.ts"() {
+    init_color();
+    init_daemon_socket_path();
+    init_client();
+    init_package();
+    SPAWN_TIMEOUT_MS = 3e4;
+    highlight2 = (text) => magenta().bold(text);
+    color2 = (text) => blue(text);
+    USAGE = `${highlight2(`[qunitx v${package_default.version}] Usage:`)} qunitx ${color2("daemon <subcommand>")}
+
+${highlight2("Subcommands:")}
+${color2("$ qunitx daemon start")}    # Spawn a persistent daemon for this project (~2\xD7 faster repeated runs)
+${color2("$ qunitx daemon stop")}     # Stop the running daemon
+${color2("$ qunitx daemon status")}   # Print pid, socket, and uptime
+
+${highlight2("Environment:")}
+${color2("QUNITX_DAEMON=1")}     : auto-spawn the daemon on the first qunitx run; reuse it on every run after (overrides the CI=1 bypass)
+${color2("QUNITX_NO_DAEMON=1")}  : never use the daemon for this run
+
+${highlight2("Tip:")} set ${color2("QUNITX_DAEMON=1")} to auto-spawn the daemon on the first qunitx run; ${color2("$ qunitx --help")} for top-level options.
+`;
+    __filename = fileURLToPath2(import.meta.url);
+    CLI_ENTRY = path13.resolve(path13.dirname(__filename), "..", "..", "..", "cli.ts");
+  }
+});
 
 // cli.ts
+init_chrome_prelaunch();
+init_package();
+import process4 from "node:process";
 process4.title = "qunitx";
 (async () => {
-  if (!process4.argv[2]) {
-    return await displayHelpOutput();
-  } else if (["--version", "-v", "version"].includes(process4.argv[2])) {
+  const cmd2 = process4.argv[2];
+  if (!cmd2) {
+    return await (await Promise.resolve().then(() => (init_help(), help_exports))).displayHelpOutput();
+  } else if (["--version", "-v", "version"].includes(cmd2)) {
     return process4.stdout.write(package_default.version + "\n");
-  } else if (["help", "h", "p", "print"].includes(process4.argv[2])) {
-    return await displayHelpOutput();
-  } else if (["new", "n", "g", "generate"].includes(process4.argv[2])) {
-    return await generateTestFiles();
-  } else if (["init"].includes(process4.argv[2])) {
-    return await initializeProject();
-  }
-  const [config, { run: run2 }] = await Promise.all([setupConfig(), Promise.resolve().then(() => (init_run(), run_exports))]);
+  } else if (["help", "h", "p", "print"].includes(cmd2)) {
+    return await (await Promise.resolve().then(() => (init_help(), help_exports))).displayHelpOutput();
+  } else if (["new", "n", "g", "generate"].includes(cmd2)) {
+    return await (await Promise.resolve().then(() => (init_generate(), generate_exports))).generateTestFiles();
+  } else if (cmd2 === "init") {
+    return await (await Promise.resolve().then(() => (init_init(), init_exports))).initializeProject();
+  } else if (cmd2 === "daemon") {
+    const { runDaemonCommand: runDaemonCommand2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+    process4.exit(await runDaemonCommand2());
+  }
+  const { shouldUseDaemon: shouldUseDaemon2, shouldAutoSpawnDaemon: shouldAutoSpawnDaemon2, runViaDaemon: runViaDaemon2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+  let useDaemon = shouldUseDaemon2();
+  if (!useDaemon && shouldAutoSpawnDaemon2()) {
+    const { ensureDaemonRunning: ensureDaemonRunning2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+    useDaemon = await ensureDaemonRunning2();
+  }
+  if (useDaemon) {
+    try {
+      const exitCode = await runViaDaemon2(process4.argv.slice(2));
+      process4.stdout.write("", () => process4.exit(exitCode));
+      return;
+    } catch {
+    }
+  }
+  const [{ setupConfig: setupConfig2 }, { run: run2 }] = await Promise.all([
+    Promise.resolve().then(() => (init_config(), config_exports)),
+    Promise.resolve().then(() => (init_run(), run_exports))
+  ]);
+  const config = await setupConfig2();
   try {
     return await run2(config);
   } catch (error) {