elit 3.6.6 → 3.6.7

package/dist/coverage.cjs

@@ -17,7 +17,7 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/coverage.ts
+// src/test/coverage/index.ts
 var coverage_exports = {};
 __export(coverage_exports, {
   calculateUncoveredLines: () => calculateUncoveredLines,
@@ -34,7 +34,7 @@ __export(coverage_exports, {
 });
 module.exports = __toCommonJS(coverage_exports);
 
-// src/runtime.ts
+// src/shares/runtime.ts
 var runtime = (() => {
   if (typeof Deno !== "undefined") return "deno";
   if (typeof Bun !== "undefined") return "bun";
@@ -44,7 +44,15 @@ var isNode = runtime === "node";
 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;
 }
@@ -63,6 +71,18 @@ function dataToUint8Array(data) {
   }
   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) {
@@ -74,12 +94,37 @@ function processDenoEntries(iterator, withFileTypes) {
   }
   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) {
@@ -115,6 +160,8 @@ function statSync(path) {
   }
   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) {
@@ -132,79 +179,87 @@ function readdirSync(path, options) {
   }
   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] === "/";
 }
@@ -225,28 +280,18 @@ function isAbsoluteWin(path) {
   }
   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 === "..") {
@@ -261,21 +306,21 @@ function normalizePath(path, isWin) {
       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;
@@ -290,43 +335,43 @@ function joinPaths(paths, isWin) {
 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) || ".";
 }
@@ -334,15 +379,15 @@ function getDirname(path, isWin) {
   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);
   }
@@ -350,8 +395,8 @@ function getBasename(path, ext, isWin) {
 }
 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);
@@ -367,10 +412,8 @@ function parsePath(path, isWin) {
     } 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);
@@ -386,6 +429,26 @@ function formatPath(pathObject, isWin) {
   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);
 }
@@ -396,119 +459,24 @@ function dirname(path) {
   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 = [];
@@ -518,21 +486,30 @@ function findAllTypeScriptFiles(dir, include, exclude) {
   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();
@@ -567,10 +544,28 @@ function analyzeSourceFile(filePath) {
       }
     }
     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"],
@@ -581,108 +576,109 @@ async function processCoverage(options) {
   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) {
@@ -691,18 +687,18 @@ function formatUncoveredLines(uncoveredLines) {
   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());
@@ -711,41 +707,62 @@ function formatUncoveredLines(uncoveredLines) {
   }
   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";
@@ -776,101 +793,58 @@ function generateTextReport(coverageMap, testResults) {
     }
     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>
@@ -920,7 +894,7 @@ function generateHtmlReport(coverageMap, reportsDir) {
         }
         .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;
@@ -1007,11 +981,6 @@ function generateHtmlReport(coverageMap, reportsDir) {
         .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; }
@@ -1063,11 +1032,11 @@ function generateHtmlReport(coverageMap, reportsDir) {
             <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">
@@ -1075,35 +1044,35 @@ function generateHtmlReport(coverageMap, reportsDir) {
             <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>
@@ -1123,8 +1092,8 @@ function generateHtmlReport(coverageMap, reportsDir) {
             <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}'">
@@ -1133,19 +1102,19 @@ function generateHtmlReport(coverageMap, reportsDir) {
                             ${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>
@@ -1187,18 +1156,18 @@ function generateHtmlReport(coverageMap, reportsDir) {
 </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 || []);
@@ -1326,33 +1295,33 @@ function generateFileDetailPage(filePath, coverage, reportsDir, toRelative) {
             <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>
@@ -1376,13 +1345,13 @@ function generateFileDetailPage(filePath, coverage, reportsDir, toRelative) {
             </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>
                     `;
@@ -1394,31 +1363,26 @@ function generateFileDetailPage(filePath, coverage, reportsDir, toRelative) {
 </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;
@@ -1431,9 +1395,13 @@ function generateCloverXml(coverageMap, reportsDir) {
   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;
@@ -1444,11 +1412,8 @@ function generateCloverXml(coverageMap, reportsDir) {
     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}">
@@ -1459,24 +1424,22 @@ function generateCloverXml(coverageMap, reportsDir) {
       <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>