elit 3.6.6 → 3.6.7

package/dist/coverage.js

@@ -7,7 +7,7 @@
     throw Error('Dynamic require of "' + x + '" is not supported');
   });
 
-  // src/runtime.ts
+  // src/shares/runtime.ts
   var runtime = (() => {
     if (typeof Deno !== "undefined") return "deno";
     if (typeof Bun !== "undefined") return "bun";
@@ -17,7 +17,15 @@
   var isBun = runtime === "bun";
   var isDeno = runtime === "deno";
 
-  // src/fs.ts
+  // src/server/fs/node-modules.ts
+  var fs;
+  var fsPromises;
+  if (isNode || isBun) {
+    fs = __require("fs");
+    fsPromises = __require("fs/promises");
+  }
+
+  // src/server/fs/utils.ts
   function parseOptions(options, defaultValue) {
     return typeof options === "string" ? { encoding: options } : options || defaultValue;
   }
@@ -36,6 +44,18 @@
     }
     return data;
   }
+  function createDirentFromDenoEntry(entry) {
+    return {
+      name: entry.name,
+      isFile: () => entry.isFile,
+      isDirectory: () => entry.isDirectory,
+      isBlockDevice: () => false,
+      isCharacterDevice: () => false,
+      isSymbolicLink: () => entry.isSymlink || false,
+      isFIFO: () => false,
+      isSocket: () => false
+    };
+  }
   function processDenoEntries(iterator, withFileTypes) {
     const entries = [];
     for (const entry of iterator) {
@@ -47,12 +67,37 @@
     }
     return entries;
   }
-  var fs;
-  var fsPromises;
-  if (isNode || isBun) {
-    fs = __require("fs");
-    fsPromises = __require("fs/promises");
+  function createStatsFromDenoFileInfo(info) {
+    return {
+      isFile: () => info.isFile,
+      isDirectory: () => info.isDirectory,
+      isBlockDevice: () => false,
+      isCharacterDevice: () => false,
+      isSymbolicLink: () => info.isSymlink || false,
+      isFIFO: () => false,
+      isSocket: () => false,
+      dev: info.dev || 0,
+      ino: info.ino || 0,
+      mode: info.mode || 0,
+      nlink: info.nlink || 1,
+      uid: info.uid || 0,
+      gid: info.gid || 0,
+      rdev: 0,
+      size: info.size,
+      blksize: info.blksize || 4096,
+      blocks: info.blocks || Math.ceil(info.size / 512),
+      atimeMs: info.atime?.getTime() || Date.now(),
+      mtimeMs: info.mtime?.getTime() || Date.now(),
+      ctimeMs: info.birthtime?.getTime() || Date.now(),
+      birthtimeMs: info.birthtime?.getTime() || Date.now(),
+      atime: info.atime || /* @__PURE__ */ new Date(),
+      mtime: info.mtime || /* @__PURE__ */ new Date(),
+      ctime: info.birthtime || /* @__PURE__ */ new Date(),
+      birthtime: info.birthtime || /* @__PURE__ */ new Date()
+    };
   }
+
+  // src/server/fs/file-ops.ts
   function readFileSync(path, options) {
     const opts = parseOptions(options, {});
     if (isNode || isBun) {
@@ -88,6 +133,8 @@
     }
     throw new Error("Unsupported runtime");
   }
+
+  // src/server/fs/directory-ops.ts
   function mkdirSync(path, options) {
     const opts = typeof options === "number" ? { mode: options } : options || {};
     if (isNode || isBun) {
@@ -105,79 +152,87 @@
     }
     throw new Error("Unsupported runtime");
   }
-  function createStatsFromDenoFileInfo(info) {
-    return {
-      isFile: () => info.isFile,
-      isDirectory: () => info.isDirectory,
-      isBlockDevice: () => false,
-      isCharacterDevice: () => false,
-      isSymbolicLink: () => info.isSymlink || false,
-      isFIFO: () => false,
-      isSocket: () => false,
-      dev: info.dev || 0,
-      ino: info.ino || 0,
-      mode: info.mode || 0,
-      nlink: info.nlink || 1,
-      uid: info.uid || 0,
-      gid: info.gid || 0,
-      rdev: 0,
-      size: info.size,
-      blksize: info.blksize || 4096,
-      blocks: info.blocks || Math.ceil(info.size / 512),
-      atimeMs: info.atime?.getTime() || Date.now(),
-      mtimeMs: info.mtime?.getTime() || Date.now(),
-      ctimeMs: info.birthtime?.getTime() || Date.now(),
-      birthtimeMs: info.birthtime?.getTime() || Date.now(),
-      atime: info.atime || /* @__PURE__ */ new Date(),
-      mtime: info.mtime || /* @__PURE__ */ new Date(),
-      ctime: info.birthtime || /* @__PURE__ */ new Date(),
-      birthtime: info.birthtime || /* @__PURE__ */ new Date()
-    };
+
+  // src/test/coverage/tracking.ts
+  var executedLinesMap = /* @__PURE__ */ new Map();
+  var totalLinesMap = /* @__PURE__ */ new Map();
+  function getExecutableLines(filePath) {
+    const executableLines = /* @__PURE__ */ new Set();
+    try {
+      const sourceCode = readFileSync(filePath, "utf-8").toString();
+      const lines = sourceCode.split("\n");
+      for (let index = 0; index < lines.length; index++) {
+        const line = lines[index].trim();
+        if (!line || line.startsWith("//") || line.startsWith("*") || line.startsWith("/*") || line.startsWith("*/") || line === "{" || line === "}" || /^import\s+.*$/.test(line) || /^export\s+(interface|type|enum)\s+.*$/.test(line) || /^interface\s+.*$/.test(line) || /^type\s+.*$/.test(line) || /^enum\s+.*$/.test(line)) {
+          continue;
+        }
+        executableLines.add(index + 1);
+      }
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+    totalLinesMap.set(filePath, executableLines.size);
+    return executableLines;
   }
-  function createDirentFromDenoEntry(entry) {
-    return {
-      name: entry.name,
-      isFile: () => entry.isFile,
-      isDirectory: () => entry.isDirectory,
-      isBlockDevice: () => false,
-      isCharacterDevice: () => false,
-      isSymbolicLink: () => entry.isSymlink || false,
-      isFIFO: () => false,
-      isSocket: () => false
-    };
+  function markFileAsCovered(_filePath) {
+  }
+  function markLineExecuted(filePath, lineNumber) {
+    let executedLines = executedLinesMap.get(filePath);
+    if (!executedLines) {
+      executedLines = /* @__PURE__ */ new Set();
+      executedLinesMap.set(filePath, executedLines);
+    }
+    executedLines.add(lineNumber);
+  }
+  function getExecutedLines(filePath) {
+    return executedLinesMap.get(filePath) || /* @__PURE__ */ new Set();
+  }
+  function calculateUncoveredLines(filePath) {
+    const executableLines = getExecutableLines(filePath);
+    const executedLines = getExecutedLines(filePath);
+    const uncoveredLines = [];
+    for (const line of executableLines) {
+      if (!executedLines.has(line)) {
+        uncoveredLines.push(line);
+      }
+    }
+    return uncoveredLines.sort((left, right) => left - right);
+  }
+  function resetCoverageTracking() {
+    executedLinesMap.clear();
+    totalLinesMap.clear();
+  }
+  function initializeCoverageTracking() {
+    resetCoverageTracking();
   }
 
-  // src/path.ts
+  // src/server/path/platform.ts
   function getSeparator(isWin) {
     return isWin ? "\\" : "/";
   }
   function getCwd() {
     if (isNode || isBun) {
       return process.cwd();
-    } else if (isDeno) {
+    }
+    if (isDeno) {
       return Deno.cwd();
     }
     return "/";
   }
+  var isWindows = (() => {
+    if (isNode) {
+      return process.platform === "win32";
+    }
+    if (isDeno) {
+      return Deno.build.os === "windows";
+    }
+    return typeof process !== "undefined" && process.platform === "win32";
+  })();
+
+  // src/server/path/operations.ts
   function findLastSeparator(path) {
     return Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
   }
-  function createPathOps(isWin) {
-    return {
-      sep: getSeparator(isWin),
-      delimiter: isWin ? ";" : ":",
-      normalize: (path) => normalizePath(path, isWin),
-      join: (...paths) => joinPaths(paths, isWin),
-      resolve: (...paths) => resolvePaths(paths, isWin),
-      isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
-      relative: (from, to) => relativePath(from, to, isWin),
-      dirname: (path) => getDirname(path, isWin),
-      basename: (path, ext) => getBasename(path, ext, isWin),
-      extname: (path) => getExtname(path),
-      parse: (path) => parsePath(path, isWin),
-      format: (pathObject) => formatPath(pathObject, isWin)
-    };
-  }
   function isAbsolutePosix(path) {
     return path.length > 0 && path[0] === "/";
   }
@@ -198,28 +253,18 @@
     }
     return false;
   }
-  var isWindows = (() => {
-    if (isNode) {
-      return process.platform === "win32";
-    } else if (isDeno) {
-      return Deno.build.os === "windows";
-    }
-    return typeof process !== "undefined" && process.platform === "win32";
-  })();
-  var posix = createPathOps(false);
-  var win32 = createPathOps(true);
   function normalizePath(path, isWin) {
     if (path.length === 0) return ".";
     const separator = getSeparator(isWin);
     const isAbsolute = isWin ? isAbsoluteWin(path) : isAbsolutePosix(path);
     const trailingSeparator = path[path.length - 1] === separator || isWin && path[path.length - 1] === "/";
-    let normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
+    const normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
     const parts = normalized.split(separator);
     const result = [];
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i];
+    for (let index = 0; index < parts.length; index++) {
+      const part = parts[index];
       if (part === "" || part === ".") {
-        if (i === 0 && isAbsolute) result.push("");
+        if (index === 0 && isAbsolute) result.push("");
         continue;
       }
       if (part === "..") {
@@ -234,21 +279,21 @@
         result.push(part);
       }
     }
-    let final = result.join(separator);
-    if (final.length === 0) {
+    let finalPath = result.join(separator);
+    if (finalPath.length === 0) {
       return isAbsolute ? separator : ".";
     }
-    if (trailingSeparator && final[final.length - 1] !== separator) {
-      final += separator;
+    if (trailingSeparator && finalPath[finalPath.length - 1] !== separator) {
+      finalPath += separator;
     }
-    return final;
+    return finalPath;
   }
   function joinPaths(paths, isWin) {
     if (paths.length === 0) return ".";
     const separator = getSeparator(isWin);
     let joined = "";
-    for (let i = 0; i < paths.length; i++) {
-      const path = paths[i];
+    for (let index = 0; index < paths.length; index++) {
+      const path = paths[index];
       if (path && path.length > 0) {
         if (joined.length === 0) {
           joined = path;
@@ -263,43 +308,43 @@
   function resolvePaths(paths, isWin) {
     const separator = getSeparator(isWin);
     let resolved = "";
-    let isAbsolute = false;
-    for (let i = paths.length - 1; i >= 0 && !isAbsolute; i--) {
-      const path = paths[i];
+    let absolute = false;
+    for (let index = paths.length - 1; index >= 0 && !absolute; index--) {
+      const path = paths[index];
       if (path && path.length > 0) {
         resolved = path + (resolved.length > 0 ? separator + resolved : "");
-        isAbsolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
+        absolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
       }
     }
-    if (!isAbsolute) {
+    if (!absolute) {
       const cwd = getCwd();
       resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
     }
     return normalizePath(resolved, isWin);
   }
   function relativePath(from, to, isWin) {
-    from = resolvePaths([from], isWin);
-    to = resolvePaths([to], isWin);
-    if (from === to) return "";
+    const resolvedFrom = resolvePaths([from], isWin);
+    const resolvedTo = resolvePaths([to], isWin);
+    if (resolvedFrom === resolvedTo) return "";
     const separator = getSeparator(isWin);
-    const fromParts = from.split(separator).filter((p) => p.length > 0);
-    const toParts = to.split(separator).filter((p) => p.length > 0);
-    let commonLength = 0;
+    const fromParts = resolvedFrom.split(separator).filter((part) => part.length > 0);
+    const toParts = resolvedTo.split(separator).filter((part) => part.length > 0);
     const minLength = Math.min(fromParts.length, toParts.length);
-    for (let i = 0; i < minLength; i++) {
-      if (fromParts[i] === toParts[i]) {
+    let commonLength = 0;
+    for (let index = 0; index < minLength; index++) {
+      if (fromParts[index] === toParts[index]) {
         commonLength++;
       } else {
         break;
       }
     }
-    const upCount = fromParts.length - commonLength;
     const result = [];
-    for (let i = 0; i < upCount; i++) {
+    const upCount = fromParts.length - commonLength;
+    for (let index = 0; index < upCount; index++) {
       result.push("..");
     }
-    for (let i = commonLength; i < toParts.length; i++) {
-      result.push(toParts[i]);
+    for (let index = commonLength; index < toParts.length; index++) {
+      result.push(toParts[index]);
     }
     return result.join(separator) || ".";
   }
@@ -307,15 +352,15 @@
     if (path.length === 0) return ".";
     const separator = getSeparator(isWin);
     const normalized = normalizePath(path, isWin);
-    const lastSepIndex = normalized.lastIndexOf(separator);
-    if (lastSepIndex === -1) return ".";
-    if (lastSepIndex === 0) return separator;
-    return normalized.slice(0, lastSepIndex);
+    const lastSeparatorIndex = normalized.lastIndexOf(separator);
+    if (lastSeparatorIndex === -1) return ".";
+    if (lastSeparatorIndex === 0) return separator;
+    return normalized.slice(0, lastSeparatorIndex);
   }
   function getBasename(path, ext, isWin) {
     if (path.length === 0) return "";
-    const lastSepIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
-    let base = lastSepIndex === -1 ? path : path.slice(lastSepIndex + 1);
+    const lastSeparatorIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
+    let base = lastSeparatorIndex === -1 ? path : path.slice(lastSeparatorIndex + 1);
     if (ext && base.endsWith(ext)) {
       base = base.slice(0, base.length - ext.length);
     }
@@ -323,8 +368,8 @@
   }
   function getExtname(path) {
     const lastDotIndex = path.lastIndexOf(".");
-    const lastSepIndex = findLastSeparator(path);
-    if (lastDotIndex === -1 || lastDotIndex < lastSepIndex || lastDotIndex === path.length - 1) {
+    const lastSeparatorIndex = findLastSeparator(path);
+    if (lastDotIndex === -1 || lastDotIndex < lastSeparatorIndex || lastDotIndex === path.length - 1) {
       return "";
     }
     return path.slice(lastDotIndex);
@@ -340,10 +385,8 @@
       } else if (path[0] === "\\" || path[0] === "/") {
         root = "\\";
       }
-    } else {
-      if (path[0] === "/") {
-        root = "/";
-      }
+    } else if (path[0] === "/") {
+      root = "/";
     }
     const dir = getDirname(path, isWin);
     const base = getBasename(path, void 0, isWin);
@@ -359,6 +402,26 @@
     if (dir === pathObject.root) return dir + base;
     return dir + separator + base;
   }
+  function createPathOps(isWin) {
+    return {
+      sep: getSeparator(isWin),
+      delimiter: isWin ? ";" : ":",
+      normalize: (path) => normalizePath(path, isWin),
+      join: (...paths) => joinPaths(paths, isWin),
+      resolve: (...paths) => resolvePaths(paths, isWin),
+      isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
+      relative: (from, to) => relativePath(from, to, isWin),
+      dirname: (path) => getDirname(path, isWin),
+      basename: (path, ext) => getBasename(path, ext, isWin),
+      extname: (path) => getExtname(path),
+      parse: (path) => parsePath(path, isWin),
+      format: (pathObject) => formatPath(pathObject, isWin)
+    };
+  }
+
+  // src/server/path/index.ts
+  var posix = createPathOps(false);
+  var win32 = createPathOps(true);
   function join(...paths) {
     return joinPaths(paths, isWindows);
   }
@@ -369,119 +432,24 @@
     return getDirname(path, isWindows);
   }
 
-  // src/coverage.ts
-  var executedLinesMap = /* @__PURE__ */ new Map();
-  var totalLinesMap = /* @__PURE__ */ new Map();
-  function getExecutableLines(filePath) {
-    const executableLines = /* @__PURE__ */ new Set();
-    try {
-      const sourceCode = readFileSync(filePath, "utf-8").toString();
-      const lines = sourceCode.split("\n");
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("/*") || trimmed.startsWith("*/") || trimmed.startsWith("import ") || trimmed.startsWith("export ") && !trimmed.includes("function") && !trimmed.includes("class") && !trimmed.includes("const") && !trimmed.includes("let") && !trimmed.includes("var") || trimmed.startsWith("interface ") || trimmed.startsWith("type ") || trimmed.startsWith("enum ") || trimmed.match(/^class\s+\w+.*{?\s*$/) || trimmed === "{" || trimmed === "}" || trimmed === "();") {
-          continue;
-        }
-        executableLines.add(i + 1);
-      }
-    } catch (e) {
-    }
-    return executableLines;
-  }
-  function markFileAsCovered(_filePath) {
-  }
-  function markLineExecuted(filePath, lineNumber) {
-    if (!executedLinesMap.has(filePath)) {
-      executedLinesMap.set(filePath, /* @__PURE__ */ new Set());
-    }
-    executedLinesMap.get(filePath).add(lineNumber);
-  }
-  function getExecutedLines(filePath) {
-    return executedLinesMap.get(filePath) || /* @__PURE__ */ new Set();
-  }
-  function calculateUncoveredLines(filePath) {
-    const executableLines = getExecutableLines(filePath);
-    const executedLines = getExecutedLines(filePath);
-    const uncovered = [];
-    for (const line of executableLines) {
-      if (!executedLines.has(line)) {
-        uncovered.push(line);
-      }
-    }
-    return uncovered.sort((a, b) => a - b);
-  }
-  function resetCoverageTracking() {
-    executedLinesMap.clear();
-    totalLinesMap.clear();
-  }
-  function initializeCoverageTracking() {
-    resetCoverageTracking();
-  }
+  // src/test/coverage/matching.ts
   function globToRegex(pattern) {
-    let regexStr = "^";
-    for (let i = 0; i < pattern.length; i++) {
-      const char = pattern[i];
-      switch (char) {
-        case ".":
-          regexStr += "\\.";
-          break;
-        case "*":
-          if (i + 1 < pattern.length && pattern[i + 1] === "*") {
-            regexStr += "(?:[^/]*(?:/|$))*";
-            i++;
-          } else {
-            regexStr += "[^/]*";
-          }
-          break;
-        case "?":
-          regexStr += "[^/]";
-          break;
-        case "/":
-          regexStr += "/";
-          break;
-        // Escape special regex characters
-        case "^":
-        case "$":
-        case "+":
-        case "(":
-        case ")":
-        case "[":
-        case "]":
-        case "{":
-        case "}":
-        case "|":
-        case "\\":
-          regexStr += "\\" + char;
-          break;
-        default:
-          regexStr += char;
-          break;
-      }
-    }
-    regexStr += "$";
-    return new RegExp(regexStr);
+    const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "__DOUBLE_STAR__").replace(/\*/g, "[^/\\\\]*").replace(/__DOUBLE_STAR__/g, ".*");
+    return new RegExp(`^${regexPattern.replace(/\\/g, "[\\\\/]")}$`);
   }
   function matchesInclude(filePath, include) {
-    if (include.length === 0) return true;
     const normalizedPath = filePath.replace(/\\/g, "/");
-    for (const pattern of include) {
+    return include.some((pattern) => {
       const regex = globToRegex(pattern);
-      if (regex.test(normalizedPath)) {
-        return true;
-      }
-    }
-    return false;
+      return regex.test(normalizedPath);
+    });
   }
   function matchesExclude(filePath, exclude) {
     const normalizedPath = filePath.replace(/\\/g, "/");
-    for (const pattern of exclude) {
+    return exclude.some((pattern) => {
       const regex = globToRegex(pattern);
-      if (regex.test(normalizedPath)) {
-        return true;
-      }
-    }
-    return false;
+      return regex.test(normalizedPath);
+    });
   }
   function findAllTypeScriptFiles(dir, include, exclude) {
     const files = [];
@@ -491,21 +459,30 @@
     try {
       const entries = readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        if (typeof entry === "string") continue;
+        if (typeof entry === "string") {
+          const fullPath2 = join(dir, entry);
+          if (fullPath2.endsWith(".ts") && matchesInclude(fullPath2, include) && !matchesExclude(fullPath2, exclude)) {
+            files.push(fullPath2);
+          }
+          continue;
+        }
         const fullPath = join(dir, entry.name);
         if (entry.isDirectory()) {
-          if (matchesExclude(fullPath, exclude)) continue;
-          files.push(...findAllTypeScriptFiles(fullPath, include, exclude));
+          if (!matchesExclude(fullPath + "/", exclude)) {
+            files.push(...findAllTypeScriptFiles(fullPath, include, exclude));
+          }
         } else if (entry.isFile() && fullPath.endsWith(".ts")) {
           if (matchesInclude(fullPath, include) && !matchesExclude(fullPath, exclude)) {
             files.push(fullPath);
           }
         }
       }
-    } catch (e) {
+    } catch {
     }
     return files;
   }
+
+  // src/test/coverage/process.ts
   function analyzeSourceFile(filePath) {
     try {
       const sourceCode = readFileSync(filePath, "utf-8").toString();
@@ -540,10 +517,28 @@
         }
       }
       return { statements, branches, functions, lines: executableLines };
-    } catch (e) {
+    } catch {
       return { statements: 0, branches: 0, functions: 0, lines: 0 };
     }
   }
+  function createCoverageRecord(filePath, isCovered) {
+    const analysis = analyzeSourceFile(filePath);
+    const executableLines = getExecutableLines(filePath);
+    const executedLines = isCovered ? executableLines : /* @__PURE__ */ new Set();
+    const uncoveredLines = Array.from(executableLines).filter((line) => !executedLines.has(line)).sort((left, right) => left - right);
+    return {
+      path: filePath,
+      statements: analysis.statements,
+      coveredStatements: isCovered ? analysis.statements : 0,
+      branches: analysis.branches,
+      coveredBranches: isCovered ? analysis.branches : 0,
+      functions: analysis.functions,
+      coveredFunctions: isCovered ? analysis.functions : 0,
+      lines: executableLines.size,
+      coveredLines: executedLines.size,
+      uncoveredLines: uncoveredLines.length > 0 ? uncoveredLines : void 0
+    };
+  }
   async function processCoverage(options) {
     const {
       include = ["**/*.ts"],
@@ -554,108 +549,109 @@
     const allTsFiles = findAllTypeScriptFiles(process.cwd(), include, exclude);
     for (const tsFile of allTsFiles) {
       const isCovered = coveredFiles?.has(tsFile) || false;
-      const analysis = analyzeSourceFile(tsFile);
-      const executableLines = getExecutableLines(tsFile);
-      const executedLines = isCovered ? executableLines : /* @__PURE__ */ new Set();
-      const uncoveredLinesArray = [];
-      for (const line of executableLines) {
-        if (!executedLines.has(line)) {
-          uncoveredLinesArray.push(line);
-        }
-      }
-      const uncoveredLines = uncoveredLinesArray.length > 0 ? uncoveredLinesArray.sort((a, b) => a - b) : void 0;
-      const coveredLinesCount = executedLines.size;
-      coverageMap.set(tsFile, {
-        path: tsFile,
-        statements: analysis.statements,
-        coveredStatements: isCovered ? analysis.statements : 0,
-        branches: analysis.branches,
-        coveredBranches: isCovered ? analysis.branches : 0,
-        functions: analysis.functions,
-        coveredFunctions: isCovered ? analysis.functions : 0,
-        lines: executableLines.size,
-        coveredLines: coveredLinesCount,
-        uncoveredLines
-      });
+      coverageMap.set(tsFile, createCoverageRecord(tsFile, isCovered));
     }
     if (coveredFiles) {
       for (const coveredFile of coveredFiles) {
-        if (coverageMap.has(coveredFile)) continue;
+        if (coverageMap.has(coveredFile)) {
+          continue;
+        }
         const relativePath2 = relative(process.cwd(), coveredFile);
         const isOutsideProject = relativePath2.startsWith("..");
         if (!coveredFile.includes("node_modules") && !coveredFile.includes("dist") && !isOutsideProject) {
-          const analysis = analyzeSourceFile(coveredFile);
-          const executableLines = getExecutableLines(coveredFile);
-          const executedLines = executableLines;
-          const uncoveredLinesArray = [];
-          for (const line of executableLines) {
-            if (!executedLines.has(line)) {
-              uncoveredLinesArray.push(line);
-            }
-          }
-          const uncoveredLines = uncoveredLinesArray.length > 0 ? uncoveredLinesArray.sort((a, b) => a - b) : void 0;
-          const coveredLinesCount = executedLines.size;
-          coverageMap.set(coveredFile, {
-            path: coveredFile,
-            statements: analysis.statements,
-            coveredStatements: analysis.statements,
-            branches: analysis.branches,
-            coveredBranches: analysis.branches,
-            functions: analysis.functions,
-            coveredFunctions: analysis.functions,
-            lines: executableLines.size,
-            coveredLines: coveredLinesCount,
-            uncoveredLines
-          });
+          coverageMap.set(coveredFile, createCoverageRecord(coveredFile, true));
         }
       }
     }
     return coverageMap;
   }
-  var colors = {
-    reset: "\x1B[0m",
-    bold: "\x1B[1m",
-    dim: "\x1B[2m",
-    red: "\x1B[31m",
-    green: "\x1B[32m",
-    yellow: "\x1B[33m",
-    cyan: "\x1B[36m"
-  };
-  function getColorForPercentage(pct) {
-    if (pct >= 80) return colors.green;
-    if (pct >= 50) return colors.yellow;
-    return colors.red;
+
+  // src/test/coverage/shared.ts
+  function calculatePercentage(covered, total) {
+    return total > 0 ? covered / total * 100 : 0;
   }
   function calculateFileCoverage(file) {
-    const stmtPct = file.statements > 0 ? file.coveredStatements / file.statements * 100 : 0;
-    const branchPct = file.branches > 0 ? file.coveredBranches / file.branches * 100 : 0;
-    const funcPct = file.functions > 0 ? file.coveredFunctions / file.functions * 100 : 0;
-    const linePct = file.lines > 0 ? file.coveredLines / file.lines * 100 : 0;
     return {
-      statements: { total: file.statements, covered: file.coveredStatements, percentage: stmtPct },
-      branches: { total: file.branches, covered: file.coveredBranches, percentage: branchPct },
-      functions: { total: file.functions, covered: file.coveredFunctions, percentage: funcPct },
-      lines: { total: file.lines, covered: file.coveredLines, percentage: linePct }
+      statements: {
+        total: file.statements,
+        covered: file.coveredStatements,
+        percentage: calculatePercentage(file.coveredStatements, file.statements)
+      },
+      branches: {
+        total: file.branches,
+        covered: file.coveredBranches,
+        percentage: calculatePercentage(file.coveredBranches, file.branches)
+      },
+      functions: {
+        total: file.functions,
+        covered: file.coveredFunctions,
+        percentage: calculatePercentage(file.coveredFunctions, file.functions)
+      },
+      lines: {
+        total: file.lines,
+        covered: file.coveredLines,
+        percentage: calculatePercentage(file.coveredLines, file.lines)
+      }
     };
   }
-  function stripAnsi(str) {
-    return str.replace(/\x1b\[[0-9;]*m/g, "");
+  function calculateCoverageTotals(coverageMap) {
+    let totalStatements = 0;
+    let coveredStatements = 0;
+    let totalBranches = 0;
+    let coveredBranches = 0;
+    let totalFunctions = 0;
+    let coveredFunctions = 0;
+    let totalLines = 0;
+    let coveredLines = 0;
+    let coveredFiles = 0;
+    for (const coverage of coverageMap.values()) {
+      totalStatements += coverage.statements;
+      coveredStatements += coverage.coveredStatements;
+      totalBranches += coverage.branches;
+      coveredBranches += coverage.coveredBranches;
+      totalFunctions += coverage.functions;
+      coveredFunctions += coverage.coveredFunctions;
+      totalLines += coverage.lines;
+      coveredLines += coverage.coveredLines;
+      if (coverage.coveredStatements > 0) {
+        coveredFiles++;
+      }
+    }
+    const statements = {
+      total: totalStatements,
+      covered: coveredStatements,
+      percentage: calculatePercentage(coveredStatements, totalStatements)
+    };
+    const branches = {
+      total: totalBranches,
+      covered: coveredBranches,
+      percentage: calculatePercentage(coveredBranches, totalBranches)
+    };
+    const functions = {
+      total: totalFunctions,
+      covered: coveredFunctions,
+      percentage: calculatePercentage(coveredFunctions, totalFunctions)
+    };
+    const lines = {
+      total: totalLines,
+      covered: coveredLines,
+      percentage: calculatePercentage(coveredLines, totalLines)
+    };
+    return {
+      statements,
+      branches,
+      functions,
+      lines,
+      overallPercentage: (statements.percentage + branches.percentage + functions.percentage + lines.percentage) / 4,
+      totalFiles: coverageMap.size,
+      coveredFiles
+    };
   }
-  function getVisibleWidth(str) {
-    return stripAnsi(str).length;
+  function toRelativePath(cwd, filePath) {
+    return relative(cwd, filePath).replace(/\\/g, "/");
   }
-  function formatMetricFixedWidth(covered, total, percentage, includeSeparator = false) {
-    const color = getColorForPercentage(percentage);
-    const pctStr = percentage.toFixed(2);
-    const pct = color + pctStr + "%" + colors.reset;
-    const coveredPadded = covered.toString().padStart(4);
-    const totalPadded = total.toString().padStart(4);
-    const count = `${colors.dim}${coveredPadded}${colors.reset}/${totalPadded}`;
-    const metric = `${pct} (${count})`;
-    const visibleWidth = getVisibleWidth(metric);
-    const padding = " ".repeat(Math.max(0, 19 - visibleWidth));
-    const separator = includeSeparator ? `${colors.dim}\u2502${colors.reset}` : " ";
-    return metric + padding + separator;
+  function getSafeReportFileName(filePath) {
+    return filePath.replace(/[\/\\]/g, "_") + ".html";
   }
   function formatUncoveredLines(uncoveredLines) {
     if (!uncoveredLines || uncoveredLines.length === 0) {
@@ -664,18 +660,18 @@
     const ranges = [];
     let start = uncoveredLines[0];
     let end = uncoveredLines[0];
-    for (let i = 1; i < uncoveredLines.length; i++) {
-      if (uncoveredLines[i] === end + 1) {
-        end = uncoveredLines[i];
+    for (let index = 1; index < uncoveredLines.length; index++) {
+      if (uncoveredLines[index] === end + 1) {
+        end = uncoveredLines[index];
+        continue;
+      }
+      if (start === end) {
+        ranges.push(start.toString());
       } else {
-        if (start === end) {
-          ranges.push(start.toString());
-        } else {
-          ranges.push(`${start}-${end}`);
-        }
-        start = uncoveredLines[i];
-        end = uncoveredLines[i];
+        ranges.push(`${start}-${end}`);
       }
+      start = uncoveredLines[index];
+      end = uncoveredLines[index];
     }
     if (start === end) {
       ranges.push(start.toString());
@@ -684,41 +680,62 @@
     }
     return ranges.join(",");
   }
+  function escapeHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+  }
+  function escapeXml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  }
+
+  // src/test/coverage/text-report.ts
+  var colors = {
+    reset: "\x1B[0m",
+    bold: "\x1B[1m",
+    dim: "\x1B[2m",
+    red: "\x1B[31m",
+    green: "\x1B[32m",
+    yellow: "\x1B[33m",
+    cyan: "\x1B[36m"
+  };
+  function getColorForPercentage(percentage) {
+    if (percentage >= 80) return colors.green;
+    if (percentage >= 50) return colors.yellow;
+    return colors.red;
+  }
+  function stripAnsi(value) {
+    return value.replace(/\x1b\[[0-9;]*m/g, "");
+  }
+  function getVisibleWidth(value) {
+    return stripAnsi(value).length;
+  }
+  function formatMetricFixedWidth(covered, total, percentage, includeSeparator = false) {
+    const color = getColorForPercentage(percentage);
+    const pct = `${color}${percentage.toFixed(2)}%${colors.reset}`;
+    const count = `${colors.dim}${covered.toString().padStart(4)}${colors.reset}/${total.toString().padStart(4)}`;
+    const metric = `${pct} (${count})`;
+    const padding = " ".repeat(Math.max(0, 19 - getVisibleWidth(metric)));
+    const separator = includeSeparator ? `${colors.dim}\u2502${colors.reset}` : " ";
+    return metric + padding + separator;
+  }
   function generateTextReport(coverageMap, testResults) {
     let output = "\n";
     void testResults;
-    let totalStatements = 0, coveredStatements = 0;
-    let totalBranches = 0, coveredBranches = 0;
-    let totalFunctions = 0, coveredFunctions = 0;
-    let totalLines = 0, coveredLines = 0;
-    for (const coverage of coverageMap.values()) {
-      totalStatements += coverage.statements;
-      coveredStatements += coverage.coveredStatements;
-      totalBranches += coverage.branches;
-      coveredBranches += coverage.coveredBranches;
-      totalFunctions += coverage.functions;
-      coveredFunctions += coverage.coveredFunctions;
-      totalLines += coverage.lines;
-      coveredLines += coverage.coveredLines;
-    }
-    const pctStmts = totalStatements > 0 ? coveredStatements / totalStatements * 100 : 0;
-    const pctBranch = totalBranches > 0 ? coveredBranches / totalBranches * 100 : 0;
-    const pctFunc = totalFunctions > 0 ? coveredFunctions / totalFunctions * 100 : 0;
-    const pctLines = totalLines > 0 ? coveredLines / totalLines * 100 : 0;
-    output += `${colors.bold}% Coverage report from v8\x1B[0m
-`;
-    output += `
+    const totals = calculateCoverageTotals(coverageMap);
+    const cwd = process.cwd();
+    const namePadding = Math.max(
+      45,
+      ...Array.from(coverageMap.keys()).map((filePath) => toRelativePath(cwd, filePath).length + 2)
+    );
+    output += `${colors.bold}% Coverage report from v8${colors.reset}
+
 `;
-    output += `${colors.dim}${colors.bold}All files\x1B[0m`;
-    const maxFileNameLength = Math.max(...Array.from(coverageMap.keys()).map((f) => relative(process.cwd(), f).length));
-    const namePadding = Math.max(45, maxFileNameLength + 2);
+    output += `${colors.dim}${colors.bold}All files${colors.reset}`;
     output += " ".repeat(namePadding - 9);
-    const stmtsMetric = formatMetricFixedWidth(coveredStatements, totalStatements, pctStmts, true);
-    const branchMetric = formatMetricFixedWidth(coveredBranches, totalBranches, pctBranch, true);
-    const funcsMetric = formatMetricFixedWidth(coveredFunctions, totalFunctions, pctFunc, true);
-    const linesMetric = formatMetricFixedWidth(coveredLines, totalLines, pctLines, true);
-    output += `${stmtsMetric}${branchMetric}${funcsMetric}${linesMetric}
-`;
+    output += formatMetricFixedWidth(totals.statements.covered, totals.statements.total, totals.statements.percentage, true);
+    output += formatMetricFixedWidth(totals.branches.covered, totals.branches.total, totals.branches.percentage, true);
+    output += formatMetricFixedWidth(totals.functions.covered, totals.functions.total, totals.functions.percentage, true);
+    output += formatMetricFixedWidth(totals.lines.covered, totals.lines.total, totals.lines.percentage, true);
+    output += "\n";
     output += `${colors.dim}`;
     output += " ".repeat(namePadding);
     output += " ".repeat(5) + "Statements";
@@ -749,101 +766,58 @@
       }
       groupedFiles.get(dir).push({ path: filePath, coverage });
     }
-    const cwd = process.cwd();
-    const toRelative = (path) => relative(cwd, path).replace(/\\/g, "/");
     for (const [dir, files] of groupedFiles.entries()) {
-      const relDir = toRelative(dir);
-      if (relDir !== ".") {
+      const relativeDir = toRelativePath(cwd, dir);
+      if (relativeDir !== ".") {
         output += `
-${colors.cyan}${relDir}/${colors.reset}
+${colors.cyan}${relativeDir}/${colors.reset}
 `;
       }
       for (const { path, coverage } of files) {
         const stats = calculateFileCoverage(coverage);
-        const relPath = toRelative(path);
-        let displayName = relPath;
+        const relativePath2 = toRelativePath(cwd, path);
+        let displayName = relativePath2;
         if (displayName.length > namePadding - 2) {
           displayName = "..." + displayName.slice(-(namePadding - 5));
         }
         output += displayName.padEnd(namePadding);
-        output += formatMetricFixedWidth(
-          stats.statements.covered,
-          stats.statements.total,
-          stats.statements.percentage,
-          true
-          // Include separator
-        );
-        output += formatMetricFixedWidth(
-          stats.branches.covered,
-          stats.branches.total,
-          stats.branches.percentage,
-          true
-          // Include separator
-        );
-        output += formatMetricFixedWidth(
-          stats.functions.covered,
-          stats.functions.total,
-          stats.functions.percentage,
-          true
-          // Include separator
-        );
-        output += formatMetricFixedWidth(
-          stats.lines.covered,
-          stats.lines.total,
-          stats.lines.percentage,
-          true
-          // Include separator
-        );
-        const uncoveredStr = formatUncoveredLines(coverage.uncoveredLines);
-        output += `${colors.red}${uncoveredStr}${colors.reset}`;
+        output += formatMetricFixedWidth(stats.statements.covered, stats.statements.total, stats.statements.percentage, true);
+        output += formatMetricFixedWidth(stats.branches.covered, stats.branches.total, stats.branches.percentage, true);
+        output += formatMetricFixedWidth(stats.functions.covered, stats.functions.total, stats.functions.percentage, true);
+        output += formatMetricFixedWidth(stats.lines.covered, stats.lines.total, stats.lines.percentage, true);
+        output += `${colors.red}${formatUncoveredLines(coverage.uncoveredLines)}${colors.reset}`;
         output += "\n";
       }
     }
-    output += `
-`;
-    output += `${colors.dim}${colors.bold}Test Files\x1B[0m  ${coverageMap.size} passed (100%)
+    output += "\n";
+    output += `${colors.dim}${colors.bold}Test Files${colors.reset}  ${coverageMap.size} passed (100%)
 `;
-    output += `${colors.dim}${colors.bold}Tests\x1B[0m       ${coverageMap.size} passed (100%)
-`;
-    output += `
+    output += `${colors.dim}${colors.bold}Tests${colors.reset}       ${coverageMap.size} passed (100%)
+
 `;
-    output += `${colors.dim}${colors.bold}Statements\x1B[0m   ${colors.green}${coveredStatements}${colors.reset} ${colors.dim}/${colors.reset} ${totalStatements}
+    output += `${colors.dim}${colors.bold}Statements${colors.reset}   ${colors.green}${totals.statements.covered}${colors.reset} ${colors.dim}/${colors.reset} ${totals.statements.total}
 `;
-    output += `${colors.dim}${colors.bold}Branches\x1B[0m    ${colors.green}${coveredBranches}${colors.reset} ${colors.dim}/${colors.reset} ${totalBranches}
+    output += `${colors.dim}${colors.bold}Branches${colors.reset}    ${colors.green}${totals.branches.covered}${colors.reset} ${colors.dim}/${colors.reset} ${totals.branches.total}
 `;
-    output += `${colors.dim}${colors.bold}Functions\x1B[0m    ${colors.green}${coveredFunctions}${colors.reset} ${colors.dim}/${colors.reset} ${totalFunctions}
+    output += `${colors.dim}${colors.bold}Functions${colors.reset}    ${colors.green}${totals.functions.covered}${colors.reset} ${colors.dim}/${colors.reset} ${totals.functions.total}
 `;
-    output += `${colors.dim}${colors.bold}Lines\x1B[0m       ${colors.green}${coveredLines}${colors.reset} ${colors.dim}/${colors.reset} ${totalLines}
+    output += `${colors.dim}${colors.bold}Lines${colors.reset}       ${colors.green}${totals.lines.covered}${colors.reset} ${colors.dim}/${colors.reset} ${totals.lines.total}
 `;
     return output;
   }
+
+  // src/test/coverage/html-report.ts
+  function getCoverageClass(percentage) {
+    if (percentage >= 80) return "high";
+    if (percentage >= 50) return "medium";
+    return "low";
+  }
   function generateHtmlReport(coverageMap, reportsDir) {
     if (!existsSync(reportsDir)) {
       mkdirSync(reportsDir, { recursive: true });
     }
-    let totalStatements = 0, coveredStatements = 0;
-    let totalBranches = 0, coveredBranches = 0;
-    let totalFunctions = 0, coveredFunctions = 0;
-    let totalLines = 0, coveredLines = 0;
-    for (const coverage of coverageMap.values()) {
-      totalStatements += coverage.statements;
-      coveredStatements += coverage.coveredStatements;
-      totalBranches += coverage.branches;
-      coveredBranches += coverage.coveredBranches;
-      totalFunctions += coverage.functions;
-      coveredFunctions += coverage.coveredFunctions;
-      totalLines += coverage.lines;
-      coveredLines += coverage.coveredLines;
-    }
-    const pctStmts = totalStatements > 0 ? coveredStatements / totalStatements * 100 : 0;
-    const pctBranch = totalBranches > 0 ? coveredBranches / totalBranches * 100 : 0;
-    const pctFunc = totalFunctions > 0 ? coveredFunctions / totalFunctions * 100 : 0;
-    const pctLines = totalLines > 0 ? coveredLines / totalLines * 100 : 0;
-    const overallPct = (pctStmts + pctBranch + pctFunc + pctLines) / 4;
-    const totalFiles = coverageMap.size;
-    const coveredFiles = Array.from(coverageMap.values()).filter((c) => c.coveredStatements > 0).length;
+    const totals = calculateCoverageTotals(coverageMap);
     const cwd = process.cwd();
-    const toRelative = (path) => relative(cwd, path).replace(/\\/g, "/");
     const indexHtml = `<!DOCTYPE html>
 <html>
 <head>
@@ -893,7 +867,7 @@ ${colors.cyan}${relDir}/${colors.reset}
         }
         .overall-bar-fill {
             height: 100%;
-            background: ${overallPct >= 80 ? "#3fb950" : overallPct >= 50 ? "#d29922" : "#f85149"};
+            background: ${totals.overallPercentage >= 80 ? "#3fb950" : totals.overallPercentage >= 50 ? "#d29922" : "#f85149"};
             display: flex;
             align-items: center;
             justify-content: center;
@@ -980,11 +954,6 @@ ${colors.cyan}${relDir}/${colors.reset}
         .file-row:last-child { border-bottom: none; }
         .file-name { color: #58a6ff; text-decoration: none; cursor: pointer; }
         .file-name:hover { text-decoration: underline; }
-        .percentage { font-weight: 600; }
-        .percentage.high { color: #3fb950; }
-        .percentage.medium { color: #d29922; }
-        .percentage.low { color: #f85149; }
-        .metric-detail { font-size: 11px; color: #8b949e; margin-top: 2px; }
         .badge { display: inline-block; padding: 2px 8px; border-radius: 12px; font-size: 11px; font-weight: 600; margin-left: 8px; }
         .badge.covered { background: #238636; color: #fff; }
         .badge.uncovered { background: #da3633; color: #fff; }
@@ -1036,11 +1005,11 @@ ${colors.cyan}${relDir}/${colors.reset}
             <div class="overall-bar-inner">
                 <div class="overall-bar-label">Overall Coverage</div>
                 <div class="overall-bar-visual">
-                    <div class="overall-bar-fill" style="width: ${overallPct}%"></div>
-                    <div class="overall-bar-text">${overallPct.toFixed(2)}%</div>
+                    <div class="overall-bar-fill" style="width: ${totals.overallPercentage}%"></div>
+                    <div class="overall-bar-text">${totals.overallPercentage.toFixed(2)}%</div>
                 </div>
             </div>
-            <div class="files-info"><span>${coveredFiles}</span> of ${totalFiles} files covered</div>
+            <div class="files-info"><span>${totals.coveredFiles}</span> of ${totals.totalFiles} files covered</div>
         </div>
 
         <div class="summary">
@@ -1048,35 +1017,35 @@ ${colors.cyan}${relDir}/${colors.reset}
             <div class="metrics">
                 <div class="metric">
                     <div class="metric-label">Statements</div>
-                    <div class="metric-value ${pctStmts >= 80 ? "high" : pctStmts >= 50 ? "medium" : "low"}">${pctStmts.toFixed(2)}%</div>
+                    <div class="metric-value ${getCoverageClass(totals.statements.percentage)}">${totals.statements.percentage.toFixed(2)}%</div>
                     <div class="progress-bar">
-                        <div class="progress-fill ${pctStmts >= 80 ? "high" : pctStmts >= 50 ? "medium" : "low"}" style="width: ${pctStmts}%"></div>
+                        <div class="progress-fill ${getCoverageClass(totals.statements.percentage)}" style="width: ${totals.statements.percentage}%"></div>
                     </div>
-                    <div class="metric-count">${coveredStatements}/${totalStatements}</div>
+                    <div class="metric-count">${totals.statements.covered}/${totals.statements.total}</div>
                 </div>
                 <div class="metric">
                     <div class="metric-label">Branches</div>
-                    <div class="metric-value ${pctBranch >= 80 ? "high" : pctBranch >= 50 ? "medium" : "low"}">${pctBranch.toFixed(2)}%</div>
+                    <div class="metric-value ${getCoverageClass(totals.branches.percentage)}">${totals.branches.percentage.toFixed(2)}%</div>
                     <div class="progress-bar">
-                        <div class="progress-fill ${pctBranch >= 80 ? "high" : pctBranch >= 50 ? "medium" : "low"}" style="width: ${pctBranch}%"></div>
+                        <div class="progress-fill ${getCoverageClass(totals.branches.percentage)}" style="width: ${totals.branches.percentage}%"></div>
                     </div>
-                    <div class="metric-count">${coveredBranches}/${totalBranches}</div>
+                    <div class="metric-count">${totals.branches.covered}/${totals.branches.total}</div>
                 </div>
                 <div class="metric">
                     <div class="metric-label">Functions</div>
-                    <div class="metric-value ${pctFunc >= 80 ? "high" : pctFunc >= 50 ? "medium" : "low"}">${pctFunc.toFixed(2)}%</div>
+                    <div class="metric-value ${getCoverageClass(totals.functions.percentage)}">${totals.functions.percentage.toFixed(2)}%</div>
                     <div class="progress-bar">
-                        <div class="progress-fill ${pctFunc >= 80 ? "high" : pctFunc >= 50 ? "medium" : "low"}" style="width: ${pctFunc}%"></div>
+                        <div class="progress-fill ${getCoverageClass(totals.functions.percentage)}" style="width: ${totals.functions.percentage}%"></div>
                     </div>
-                    <div class="metric-count">${coveredFunctions}/${totalFunctions}</div>
+                    <div class="metric-count">${totals.functions.covered}/${totals.functions.total}</div>
                 </div>
                 <div class="metric">
                     <div class="metric-label">Lines</div>
-                    <div class="metric-value ${pctLines >= 80 ? "high" : pctLines >= 50 ? "medium" : "low"}">${pctLines.toFixed(2)}%</div>
+                    <div class="metric-value ${getCoverageClass(totals.lines.percentage)}">${totals.lines.percentage.toFixed(2)}%</div>
                     <div class="progress-bar">
-                        <div class="progress-fill ${pctLines >= 80 ? "high" : pctLines >= 50 ? "medium" : "low"}" style="width: ${pctLines}%"></div>
+                        <div class="progress-fill ${getCoverageClass(totals.lines.percentage)}" style="width: ${totals.lines.percentage}%"></div>
                     </div>
-                    <div class="metric-count">${coveredLines}/${totalLines}</div>
+                    <div class="metric-count">${totals.lines.covered}/${totals.lines.total}</div>
                 </div>
             </div>
         </div>
@@ -1096,8 +1065,8 @@ ${colors.cyan}${relDir}/${colors.reset}
             <div id="file-rows">
             ${Array.from(coverageMap.entries()).map(([filePath, coverage]) => {
       const stats = calculateFileCoverage(coverage);
-      const fileName = toRelative(filePath);
-      const safeFileName = fileName.replace(/[\/\\]/g, "_") + ".html";
+      const fileName = toRelativePath(cwd, filePath);
+      const safeFileName = getSafeReportFileName(fileName);
       const isCovered = coverage.coveredStatements > 0;
       return `
                     <div class="file-row" onclick="window.location.href='${safeFileName}'">
@@ -1106,19 +1075,19 @@ ${colors.cyan}${relDir}/${colors.reset}
                             ${isCovered ? '<span class="badge covered">Covered</span>' : '<span class="badge uncovered">Not Covered</span>'}
                         </div>
                         <div class="coverage-cell">
-                            <div class="coverage-percent ${stats.statements.percentage >= 80 ? "high" : stats.statements.percentage >= 50 ? "medium" : "low"}">${stats.statements.percentage.toFixed(2)}%</div>
+                            <div class="coverage-percent ${getCoverageClass(stats.statements.percentage)}">${stats.statements.percentage.toFixed(2)}%</div>
                             <div class="coverage-count">${coverage.coveredStatements}/${coverage.statements}</div>
                         </div>
                         <div class="coverage-cell">
-                            <div class="coverage-percent ${stats.branches.percentage >= 80 ? "high" : stats.branches.percentage >= 50 ? "medium" : "low"}">${stats.branches.percentage.toFixed(2)}%</div>
+                            <div class="coverage-percent ${getCoverageClass(stats.branches.percentage)}">${stats.branches.percentage.toFixed(2)}%</div>
                             <div class="coverage-count">${coverage.coveredBranches}/${coverage.branches}</div>
                         </div>
                         <div class="coverage-cell">
-                            <div class="coverage-percent ${stats.functions.percentage >= 80 ? "high" : stats.functions.percentage >= 50 ? "medium" : "low"}">${stats.functions.percentage.toFixed(2)}%</div>
+                            <div class="coverage-percent ${getCoverageClass(stats.functions.percentage)}">${stats.functions.percentage.toFixed(2)}%</div>
                             <div class="coverage-count">${coverage.coveredFunctions}/${coverage.functions}</div>
                         </div>
                         <div class="coverage-cell">
-                            <div class="coverage-percent ${stats.lines.percentage >= 80 ? "high" : stats.lines.percentage >= 50 ? "medium" : "low"}">${stats.lines.percentage.toFixed(2)}%</div>
+                            <div class="coverage-percent ${getCoverageClass(stats.lines.percentage)}">${stats.lines.percentage.toFixed(2)}%</div>
                             <div class="coverage-count">${coverage.coveredLines}/${coverage.lines}</div>
                         </div>
                     </div>
@@ -1160,18 +1129,18 @@ ${colors.cyan}${relDir}/${colors.reset}
 </html>`;
     writeFileSync(join(reportsDir, "index.html"), indexHtml, "utf-8");
     for (const [filePath, coverage] of coverageMap.entries()) {
-      generateFileDetailPage(filePath, coverage, reportsDir, toRelative);
+      generateFileDetailPage(filePath, coverage, reportsDir, cwd);
     }
   }
-  function generateFileDetailPage(filePath, coverage, reportsDir, toRelative) {
-    const fileName = toRelative(filePath);
-    const safeFileName = fileName.replace(/[\/\\]/g, "_") + ".html";
+  function generateFileDetailPage(filePath, coverage, reportsDir, cwd) {
+    const fileName = toRelativePath(cwd, filePath);
+    const safeFileName = getSafeReportFileName(fileName);
     const stats = calculateFileCoverage(coverage);
     let sourceLines = [];
     try {
       const sourceCode = readFileSync(filePath, "utf-8").toString();
       sourceLines = sourceCode.split("\n");
-    } catch (e) {
+    } catch {
       sourceLines = ["// Unable to read source file"];
     }
     const uncoveredSet = new Set(coverage.uncoveredLines || []);
@@ -1299,33 +1268,33 @@ ${colors.cyan}${relDir}/${colors.reset}
             <div class="metrics">
                 <div class="metric">
                     <div class="metric-label">Statements</div>
-                    <div class="metric-value ${stats.statements.percentage >= 80 ? "high" : stats.statements.percentage >= 50 ? "medium" : "low"}">${stats.statements.percentage.toFixed(2)}%</div>
+                    <div class="metric-value ${getCoverageClass(stats.statements.percentage)}">${stats.statements.percentage.toFixed(2)}%</div>
                     <div class="progress-bar">
-                        <div class="progress-fill ${stats.statements.percentage >= 80 ? "high" : stats.statements.percentage >= 50 ? "medium" : "low"}" style="width: ${stats.statements.percentage}%"></div>
+                        <div class="progress-fill ${getCoverageClass(stats.statements.percentage)}" style="width: ${stats.statements.percentage}%"></div>
                     </div>
                     <div class="metric-count">${coverage.coveredStatements}/${coverage.statements}</div>
                 </div>
                 <div class="metric">
                     <div class="metric-label">Branches</div>
-                    <div class="metric-value ${stats.branches.percentage >= 80 ? "high" : stats.branches.percentage >= 50 ? "medium" : "low"}">${stats.branches.percentage.toFixed(2)}%</div>
+                    <div class="metric-value ${getCoverageClass(stats.branches.percentage)}">${stats.branches.percentage.toFixed(2)}%</div>
                     <div class="progress-bar">
-                        <div class="progress-fill ${stats.branches.percentage >= 80 ? "high" : stats.branches.percentage >= 50 ? "medium" : "low"}" style="width: ${stats.branches.percentage}%"></div>
+                        <div class="progress-fill ${getCoverageClass(stats.branches.percentage)}" style="width: ${stats.branches.percentage}%"></div>
                     </div>
                     <div class="metric-count">${coverage.coveredBranches}/${coverage.branches}</div>
                 </div>
                 <div class="metric">
                     <div class="metric-label">Functions</div>
-                    <div class="metric-value ${stats.functions.percentage >= 80 ? "high" : stats.functions.percentage >= 50 ? "medium" : "low"}">${stats.functions.percentage.toFixed(2)}%</div>
+                    <div class="metric-value ${getCoverageClass(stats.functions.percentage)}">${stats.functions.percentage.toFixed(2)}%</div>
                     <div class="progress-bar">
-                        <div class="progress-fill ${stats.functions.percentage >= 80 ? "high" : stats.functions.percentage >= 50 ? "medium" : "low"}" style="width: ${stats.functions.percentage}%"></div>
+                        <div class="progress-fill ${getCoverageClass(stats.functions.percentage)}" style="width: ${stats.functions.percentage}%"></div>
                     </div>
                     <div class="metric-count">${coverage.coveredFunctions}/${coverage.functions}</div>
                 </div>
                 <div class="metric">
                     <div class="metric-label">Lines</div>
-                    <div class="metric-value ${stats.lines.percentage >= 80 ? "high" : stats.lines.percentage >= 50 ? "medium" : "low"}">${stats.lines.percentage.toFixed(2)}%</div>
+                    <div class="metric-value ${getCoverageClass(stats.lines.percentage)}">${stats.lines.percentage.toFixed(2)}%</div>
                     <div class="progress-bar">
-                        <div class="progress-fill ${stats.lines.percentage >= 80 ? "high" : stats.lines.percentage >= 50 ? "medium" : "low"}" style="width: ${stats.lines.percentage}%"></div>
+                        <div class="progress-fill ${getCoverageClass(stats.lines.percentage)}" style="width: ${stats.lines.percentage}%"></div>
                     </div>
                     <div class="metric-count">${coverage.coveredLines}/${coverage.lines}</div>
                 </div>
@@ -1349,13 +1318,13 @@ ${colors.cyan}${relDir}/${colors.reset}
             </div>
             <table class="code-table">
                 ${sourceLines.map((line, index) => {
-      const lineNum = index + 1;
-      const isUncovered = uncoveredSet.has(lineNum);
-      const isExecutable = coverage.lines > 0;
-      const rowClass = isExecutable ? isUncovered ? "uncovered" : "covered" : "";
+      const lineNumber = index + 1;
+      const isUncovered = uncoveredSet.has(lineNumber);
+      const hasCoverage = coverage.lines > 0;
+      const rowClass = hasCoverage ? isUncovered ? "uncovered" : "covered" : "";
       return `
                         <tr class="${rowClass}">
-                            <td class="line-number">${lineNum}</td>
+                            <td class="line-number">${lineNumber}</td>
                             <td class="line-content">${escapeHtml(line) || " "}</td>
                         </tr>
                     `;
@@ -1367,31 +1336,26 @@ ${colors.cyan}${relDir}/${colors.reset}
 </html>`;
     writeFileSync(join(reportsDir, safeFileName), fileHtml, "utf-8");
   }
-  function escapeHtml(text) {
-    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
-  }
-  function escapeXml(text) {
-    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-  }
+
+  // src/test/coverage/machine-reports.ts
   function generateCoverageFinalJson(coverageMap, reportsDir) {
+    const cwd = process.cwd();
     const coverageData = {};
     for (const [filePath, coverage] of coverageMap.entries()) {
-      const relativePath2 = relative(process.cwd(), filePath).replace(/\\/g, "/");
+      const relativePath2 = toRelativePath(cwd, filePath);
       const lineMap = {};
       const executableLines = getExecutableLines(filePath);
+      const isCovered = coverage.coveredStatements > 0;
       for (const line of executableLines) {
-        const isCovered = coverage.coveredStatements > 0;
         lineMap[line] = isCovered ? 1 : 0;
       }
-      coverageData[relativePath2] = {
-        lines: lineMap
-      };
+      coverageData[relativePath2] = { lines: lineMap };
     }
-    const jsonData = JSON.stringify(coverageData, null, 2);
-    writeFileSync(join(reportsDir, "coverage-final.json"), jsonData, "utf-8");
+    writeFileSync(join(reportsDir, "coverage-final.json"), JSON.stringify(coverageData, null, 2), "utf-8");
   }
   function generateCloverXml(coverageMap, reportsDir) {
     const timestamp = Date.now();
+    const cwd = process.cwd();
     let totalFiles = 0;
     let totalClasses = 0;
     let totalElements = 0;
@@ -1404,9 +1368,13 @@ ${colors.cyan}${relDir}/${colors.reset}
     let coveredFunctions = 0;
     let totalLines = 0;
     let coveredLines = 0;
+    const coveredClassCount = Array.from(coverageMap.values()).filter((coverage) => coverage.coveredStatements > 0).length;
     const fileEntries = [];
     for (const [filePath, coverage] of coverageMap.entries()) {
-      const relativePath2 = relative(process.cwd(), filePath).replace(/\\/g, "/");
+      const relativePath2 = toRelativePath(cwd, filePath);
+      const escapedPath = escapeXml(relativePath2);
+      const fileElements = coverage.statements + coverage.branches + coverage.functions;
+      const fileCoveredElements = coverage.coveredStatements + coverage.coveredBranches + coverage.coveredFunctions;
       totalFiles++;
       totalClasses++;
       totalStatements += coverage.statements;
@@ -1417,11 +1385,8 @@ ${colors.cyan}${relDir}/${colors.reset}
       coveredFunctions += coverage.coveredFunctions;
       totalLines += coverage.lines;
       coveredLines += coverage.coveredLines;
-      const fileElements = coverage.statements + coverage.branches + coverage.functions;
-      const fileCoveredElements = coverage.coveredStatements + coverage.coveredBranches + coverage.coveredFunctions;
       totalElements += fileElements;
       coveredElements += fileCoveredElements;
-      const escapedPath = escapeXml(relativePath2);
       fileEntries.push(`
     <file name="${escapedPath}">
       <class name="${escapedPath}">
@@ -1432,24 +1397,22 @@ ${colors.cyan}${relDir}/${colors.reset}
       <line num="1" type="stmt" count="${coverage.coveredStatements > 0 ? 1 : 0}" />
     </file>`);
     }
-    const complexity = 0;
-    const elements = totalElements;
     const xml = `<?xml version="1.0" encoding="UTF-8"?>
 <coverage generated="${timestamp}" clover="3.2.0">
   <project timestamp="${timestamp}" name="Coverage">
-    <metrics complexity="${complexity}" elements="${elements}" coveredelements="${coveredElements}"
+    <metrics complexity="0" elements="${totalElements}" coveredelements="${coveredElements}"
              conditionals="${totalBranches}" coveredconditionals="${coveredBranches}"
              statements="${totalStatements}" coveredstatements="${coveredStatements}"
              methods="${totalFunctions}" coveredmethods="${coveredFunctions}"
-             classes="${totalClasses}" coveredclasses="${coverageMap.size > 0 ? Array.from(coverageMap.values()).filter((c) => c.coveredStatements > 0).length : 0}"
+             classes="${totalClasses}" coveredclasses="${coveredClassCount}"
              files="${totalFiles}" loc="${totalLines}" ncloc="${totalLines - coveredLines}"
              packages="${totalFiles}" classes="${totalClasses}" />
     <package name="root">
-      <metrics complexity="${complexity}" elements="${elements}" coveredelements="${coveredElements}"
+      <metrics complexity="0" elements="${totalElements}" coveredelements="${coveredElements}"
                conditionals="${totalBranches}" coveredconditionals="${coveredBranches}"
                statements="${totalStatements}" coveredstatements="${coveredStatements}"
                methods="${totalFunctions}" coveredmethods="${coveredFunctions}"
-               classes="${totalClasses}" coveredclasses="${coverageMap.size > 0 ? Array.from(coverageMap.values()).filter((c) => c.coveredStatements > 0).length : 0}"
+               classes="${totalClasses}" coveredclasses="${coveredClassCount}"
                files="${totalFiles}" loc="${totalLines}" ncloc="${totalLines - coveredLines}" />
 ${fileEntries.join("")}
     </package>