@rpcbase/test 0.304.0 → 0.306.0

package/README.md

@@ -4,17 +4,10 @@
 
 ## 1. Declare your coverage config
 
-Create `spec/coverage.ts` (or `.js` / `.json`) in your package:
+Create `spec/coverage.config.ts` (or `.js` / `.json`) in your package:
 
 ```ts
-import path from "node:path"
-import { fileURLToPath } from "node:url"
-
-const workspaceRoot = path.resolve(fileURLToPath(new URL("../", import.meta.url)))
-
 export default {
-  workspaceRoot,
-  libDirs: ["lib"],
   testResultsDir: "test-results",
   thresholds: {
     statements: 75,
@@ -27,13 +20,23 @@ export default {
 
 Only `RB_DISABLE_COVERAGE=1` skips the hooks; every other option lives inside this config file.
 
+### Default file collection
+
+If you omit `collectCoverageFrom`, `rb-test` uses a reasonable default:
+
+- `src/**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}` when `src/` exists
+- if `src/` is missing, `rb-test` throws unless you set `collectCoverageFrom`
+
+Unit test files are excluded by default: `!**/*.test.{ts,tsx,js,jsx,mts,cts,mjs,cjs}`.
+
+`collectCoverageFrom` supports negated globs (prefix with `!`) to exclude files.
+
 ### Per-folder thresholds
 
 Need stricter coverage in a sub-tree? Extend the same `thresholds` object with glob keys (mirroring Jest's `coverageThreshold` syntax):
 
 ```ts
 export default {
-  workspaceRoot,
   thresholds: {
     global: {
       statements: 90,
@@ -41,11 +44,11 @@ export default {
       functions: 85,
       branches: 70,
     },
-    "lib/core/**": {
+    "src/core/**": {
       statements: 98,
       lines: 95,
     },
-    "lib/components/**": {
+    "src/components/**": {
       functions: 92,
     },
   },
@@ -54,7 +57,7 @@ export default {
 
 - When `thresholds` only has metric keys, it behaves exactly like before.
 - Adding `thresholds.global` lets you keep a default floor while overriding specific directories.
-- Globs run against POSIX-style paths relative to `workspaceRoot`, but absolute paths work too if you prefer.
+- Globs run against POSIX-style paths relative to the package root (parent folder of `spec/`). Absolute paths are not supported.
 - Metrics you omit inside an override inherit from the global thresholds (or the 75/75/75/60 defaults).
 - If a glob matches no files you'll get a warning and the override is skipped, so typos are easy to spot.
 
@@ -104,7 +107,7 @@ Each package uses its `npm test` script as `tsc --noEmit && rb-test`. The CLI ru
 
 Coverage is enforced separately:
 
-- Playwright uses `spec/coverage.*` via the shared reporter and will fail the run if thresholds aren’t met.
+- Playwright uses `spec/coverage.config.*` via the shared reporter and will fail the run if thresholds aren’t met.
 - Vitest only reads `src/coverage.json` (JSON object). If that file is missing, Vitest coverage is skipped.
 
 Need to debug without coverage? Set `RB_DISABLE_COVERAGE=1 npm test` and the Playwright hooks short-circuit.

package/index.d.ts

@@ -21,21 +21,22 @@ interface CoverageThresholdTarget {
 }
 
 interface CoverageHarnessOptions {
-  workspaceRoot: string
-  libDirs?: string[]
+  rootDir: string
+  collectCoverageFrom: string[]
   testResultsDir?: string
   coverageReportSubdir?: string
   coverageFileName?: string
+  includeAllFiles?: boolean
   envPrefix?: string
   thresholds?: CoverageThresholdOption
   disabledEnvVar?: string
 }
 
 interface CoverageConfig extends CoverageHarnessOptions {
-  libRoots: string[]
   testResultsRoot: string
   coverageReportDir: string
   coverageFileName: string
+  includeAllFiles: boolean
   thresholds: CoverageThresholds
   thresholdTargets: CoverageThresholdTarget[]
   coverageEnabled: boolean

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpcbase/test",
-  "version": "0.304.0",
+  "version": "0.306.0",
   "type": "module",
   "files": [
     "src",
@@ -56,7 +56,9 @@
   "dependencies": {
     "@playwright/test": "1.57.0",
     "esbuild": "0.27.2",
+    "fast-glob": "3.3.3",
     "istanbul-lib-coverage": "3.2.2",
+    "istanbul-lib-instrument": "6.0.3",
     "istanbul-lib-report": "3.0.1",
     "istanbul-reports": "3.2.0",
     "lodash": "4.17.21",

package/src/cli.js

@@ -8,6 +8,7 @@ import { createRequire } from "module"
 import { fileURLToPath } from "url"
 
 import { createCoverageConfig } from "./coverage/config.js"
+import { isInsideAnyRoot, resolveCollectCoverageRoots } from "./coverage/collect.js"
 import { loadCoverageOptions } from "./coverage/config-loader.js"
 import { removeCoverageFiles } from "./coverage/files.js"
 import { CoverageThresholdError, generateCoverageReport } from "./coverage/report.js"
@@ -19,6 +20,7 @@ const moduleDir = path.dirname(fileURLToPath(import.meta.url))
 
 const VITEST_COVERAGE_CANDIDATES = ["src/coverage.json"]
 
+const COMBINED_COVERAGE_ENV_VAR = "RB_TEST_COMBINED_COVERAGE"
 
 const isAider = process.env.IS_AIDER === "yes"
 
@@ -29,25 +31,27 @@ if (process.env.IS_AIDER !== undefined && process.env.IS_AIDER !== "yes") {
 async function runTests() {
   const userArgs = process.argv.slice(2)
 
+  const playwrightCoverage = await loadPlaywrightCoverageConfig()
   const vitestCoverage = await loadVitestCoverageConfig()
+  const combinedCoverage = resolveCombinedCoverage(playwrightCoverage, vitestCoverage)
 
-  if (vitestCoverage?.enabled) {
-    await cleanCoverageArtifacts(vitestCoverage.config)
+  if (combinedCoverage?.enabled) {
+    await cleanCoverageArtifacts(combinedCoverage.config)
   }
 
   let testError = null
 
   try {
-    await runVitest(vitestCoverage)
+    await runVitest(vitestCoverage, combinedCoverage?.config ?? null)
     console.log("\nRunning Playwright Tests...")
     await runPlaywright(userArgs)
   } catch (error) {
     testError = error
   }
 
-  if (vitestCoverage?.enabled) {
+  if (combinedCoverage?.enabled) {
     try {
-      await finalizeCoverage(vitestCoverage.config)
+      await finalizeCoverage(combinedCoverage.config)
     } catch (error) {
       if (!testError) {
         testError = error
@@ -62,9 +66,14 @@ async function runTests() {
 
 runTests()
   .then(() => process.exit(0))
-  .catch(() => process.exit(1))
+  .catch((error) => {
+    if (!(error instanceof CoverageThresholdError)) {
+      console.error(error?.stack ?? String(error))
+    }
+    process.exit(1)
+  })
 
-async function runVitest(coverage) {
+async function runVitest(coverage, combinedConfig) {
   const vitestArgs = ["run", "--passWithNoTests"]
   const vitestConfig = resolveVitestConfig()
 
@@ -75,7 +84,7 @@ async function runVitest(coverage) {
   const env = withRegisterShim(process.env)
 
   if (coverage?.enabled) {
-    env.NODE_V8_COVERAGE = coverage.nodeCoverageDir
+    env.NODE_V8_COVERAGE = resolveNodeCoverageDir(combinedConfig ?? coverage.config)
   }
 
   await spawnWithLogs({
@@ -88,7 +97,10 @@ async function runVitest(coverage) {
   })
 
   if (coverage?.enabled) {
-    await convertNodeCoverage(coverage)
+    await convertNodeCoverage({
+      config: combinedConfig ?? coverage.config,
+      nodeCoverageDir: resolveNodeCoverageDir(combinedConfig ?? coverage.config),
+    })
   }
 }
 
@@ -119,6 +131,7 @@ function runPlaywright(userArgs) {
   ensureJsxRuntimeShim(process.cwd())
   const launcher = resolvePlaywrightLauncher()
   const env = withRegisterShim(process.env)
+  env[COMBINED_COVERAGE_ENV_VAR] = "1"
 
   return spawnWithLogs({
     name: "Playwright",
@@ -246,22 +259,52 @@ async function loadVitestCoverageConfig() {
 
   return {
     config,
-    nodeCoverageDir: path.join(config.testResultsRoot, "node-coverage"),
     enabled: config.coverageEnabled,
   }
 }
 
+async function loadPlaywrightCoverageConfig() {
+  const options = await loadCoverageOptions({ optional: true })
+  if (!options) {
+    return null
+  }
+
+  const config = createCoverageConfig(options)
+
+  return {
+    config,
+    enabled: config.coverageEnabled,
+  }
+}
+
+function resolveCombinedCoverage(playwrightCoverage, vitestCoverage) {
+  if (playwrightCoverage?.enabled) {
+    return playwrightCoverage
+  }
+
+  if (vitestCoverage?.enabled) {
+    return vitestCoverage
+  }
+
+  return null
+}
+
 async function cleanCoverageArtifacts(config) {
   await removeCoverageFiles(config)
   await fsPromises.rm(config.coverageReportDir, { recursive: true, force: true })
   await fsPromises.rm(path.join(config.testResultsRoot, "node-coverage"), { recursive: true, force: true })
 }
 
+function resolveNodeCoverageDir(config) {
+  return path.join(config.testResultsRoot, "node-coverage", "vitest")
+}
+
 async function convertNodeCoverage(coverage) {
   const { config, nodeCoverageDir } = coverage
 
   const entries = await fsPromises.readdir(nodeCoverageDir).catch(() => [])
   const scripts = []
+  const scriptRoots = resolveCollectCoverageRoots(config.collectCoverageFrom, config.rootDir)
 
   for (const entry of entries) {
     if (!entry.endsWith(".json")) {
@@ -273,12 +316,16 @@ async function convertNodeCoverage(coverage) {
     const results = Array.isArray(payload?.result) ? payload.result : []
 
     for (const script of results) {
-      const normalized = normalizeNodeScriptUrl(script.url, config.workspaceRoot)
+      const normalized = normalizeNodeScriptUrl(script.url, config.rootDir)
       if (!normalized) {
         continue
       }
 
-      if (!isInsideLib(normalized.absolutePath, config.libRoots)) {
+      if (isNodeModulesPath(normalized.absolutePath)) {
+        continue
+      }
+
+      if (!isInsideAnyRoot(normalized.absolutePath, scriptRoots)) {
         continue
       }
 
@@ -324,7 +371,7 @@ async function readJson(filePath) {
   }
 }
 
-function normalizeNodeScriptUrl(rawUrl, workspaceRoot) {
+function normalizeNodeScriptUrl(rawUrl, rootDir) {
   if (!rawUrl || rawUrl.startsWith("node:")) {
     return null
   }
@@ -348,21 +395,18 @@ function normalizeNodeScriptUrl(rawUrl, workspaceRoot) {
   }
 
   const normalized = path.normalize(absolutePath)
-  if (!normalized.startsWith(workspaceRoot)) {
-    return null
-  }
 
   return {
     absolutePath: normalized,
-    relativePath: path.relative(workspaceRoot, normalized),
+    relativePath: path.relative(rootDir, normalized),
   }
 }
 
-function isInsideLib(absolutePath, libRoots) {
-  return libRoots.some((libRoot) => {
-    const relative = path.relative(libRoot, absolutePath)
-    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))
-  })
+function isNodeModulesPath(filePath) {
+  return path
+    .normalize(String(filePath ?? ""))
+    .split(path.sep)
+    .includes("node_modules")
 }
 
 function spawnWithLogs({ name, launcher, args, env, successMessage, failureMessage }) {

package/src/coverage/collect.js

@@ -0,0 +1,134 @@
+import path from "node:path"
+
+import picomatch from "picomatch"
+
+
+export function createCollectCoverageMatcher(patterns, rootDir) {
+  const normalizedRoot = path.resolve(String(rootDir ?? ""))
+
+  const includeMatchers = []
+  const excludeMatchers = []
+
+  if (Array.isArray(patterns)) {
+    for (const pattern of patterns) {
+      const raw = String(pattern ?? "").trim()
+      if (!raw) {
+        continue
+      }
+
+      const isExclude = raw.startsWith("!")
+      const body = toPosix(isExclude ? raw.slice(1) : raw)
+      if (!body) {
+        continue
+      }
+
+      const matcher = picomatch(body, { dot: true })
+      if (isExclude) {
+        excludeMatchers.push(matcher)
+      } else {
+        includeMatchers.push(matcher)
+      }
+    }
+  }
+
+  if (includeMatchers.length === 0) {
+    return () => false
+  }
+
+  return (absolutePath) => {
+    const normalizedAbsolute = path.resolve(String(absolutePath ?? ""))
+    if (!normalizedAbsolute) {
+      return false
+    }
+
+    const relativePosix = toPosix(path.relative(normalizedRoot, normalizedAbsolute))
+    const absolutePosix = toPosix(normalizedAbsolute)
+    const candidates = new Set([absolutePosix, relativePosix])
+
+    if (relativePosix) {
+      candidates.add(`./${relativePosix}`)
+    }
+
+    const candidateList = Array.from(candidates)
+    const included = includeMatchers.some((matcher) => candidateList.some((candidate) => matcher(candidate)))
+    if (!included) {
+      return false
+    }
+
+    return !excludeMatchers.some((matcher) => candidateList.some((candidate) => matcher(candidate)))
+  }
+}
+
+export function toPosix(input) {
+  return String(input ?? "").split(path.sep).join("/")
+}
+
+export function isInsideAnyRoot(absolutePath, roots) {
+  const normalizedAbsolute = path.resolve(String(absolutePath ?? ""))
+  return (Array.isArray(roots) ? roots : []).some((root) => {
+    const normalizedRoot = path.resolve(String(root ?? ""))
+    const relative = path.relative(normalizedRoot, normalizedAbsolute)
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))
+  })
+}
+
+export function resolveCollectCoverageRoots(patterns, rootDir) {
+  const resolvedRootDir = path.resolve(String(rootDir ?? ""))
+  const roots = new Set([resolvedRootDir])
+
+  if (!Array.isArray(patterns)) {
+    return Array.from(roots)
+  }
+
+  for (const pattern of patterns) {
+    const raw = String(pattern ?? "").trim()
+    if (!raw) {
+      continue
+    }
+
+    const cleaned = raw.startsWith("!") ? raw.slice(1) : raw
+    if (!cleaned) {
+      continue
+    }
+
+    const prefix = staticGlobPrefix(cleaned)
+    if (!prefix) {
+      continue
+    }
+
+    roots.add(path.resolve(resolvedRootDir, prefix))
+  }
+
+  return Array.from(roots)
+}
+
+function staticGlobPrefix(pattern) {
+  const normalized = String(pattern ?? "").trim()
+  if (!normalized) {
+    return null
+  }
+
+  const firstGlobIndex = findFirstGlobIndex(normalized)
+  const prefix = firstGlobIndex === -1 ? normalized : normalized.slice(0, firstGlobIndex)
+
+  if (!prefix) {
+    return null
+  }
+
+  if (prefix.endsWith("/") || prefix.endsWith(path.sep)) {
+    return prefix
+  }
+
+  const posix = prefix.split(path.sep).join("/")
+  return path.posix.dirname(posix)
+}
+
+function findFirstGlobIndex(value) {
+  for (let i = 0; i < value.length; i += 1) {
+    const char = value[i]
+    if (char === "*" || char === "?" || char === "[" || char === "{") {
+      return i
+    }
+  }
+  return -1
+}

package/src/coverage/config-loader.js

@@ -8,6 +8,16 @@ import { build } from "esbuild"
 
 
 const DEFAULT_COVERAGE_CANDIDATES = [
+  "spec/coverage.config.ts",
+  "spec/coverage.config.mts",
+  "spec/coverage.config.cts",
+  "spec/coverage.config.js",
+  "spec/coverage.config.mjs",
+  "spec/coverage.config.cjs",
+  "spec/coverage.config.json",
+]
+
+const LEGACY_COVERAGE_CANDIDATES = [
   "spec/coverage.ts",
   "spec/coverage.mts",
   "spec/coverage.cts",
@@ -19,6 +29,15 @@ const DEFAULT_COVERAGE_CANDIDATES = [
 
 export async function loadCoverageOptions({ optional = false, candidates = DEFAULT_COVERAGE_CANDIDATES, defaultTestResultsDir } = {}) {
   const projectRoot = process.cwd()
+  const legacy = await findCoverageFile(projectRoot, LEGACY_COVERAGE_CANDIDATES)
+  if (legacy) {
+    const ext = path.extname(legacy)
+    const suggested = path.join("spec", `coverage.config${ext}`)
+    throw new Error(
+      `Legacy coverage config detected (${path.relative(projectRoot, legacy)}). Rename it to ${suggested}.`,
+    )
+  }
+
   const resolved = await findCoverageFile(projectRoot, candidates)
 
   if (!resolved) {
@@ -26,7 +45,7 @@ export async function loadCoverageOptions({ optional = false, candidates = DEFAU
       return null
     }
     throw new Error(
-      "Coverage config not found. Create one of: spec/coverage.{ts,js,json} with your coverage settings.",
+      "Coverage config not found. Create `spec/coverage.config.{ts,js,json}` with your coverage settings.",
     )
   }
 
@@ -35,7 +54,7 @@ export async function loadCoverageOptions({ optional = false, candidates = DEFAU
     throw new Error(`Coverage config at ${resolved} must export an object.`)
   }
 
-  return normalizeOptions(raw, resolved, defaultTestResultsDir)
+  return await normalizeOptions(raw, resolved, defaultTestResultsDir)
 }
 
 async function findCoverageFile(root, candidates) {
@@ -101,24 +120,85 @@ async function loadModule(url) {
   return imported
 }
 
-function normalizeOptions(rawOptions, filePath, defaultTestResultsDir) {
+const DEFAULT_COLLECT_COVERAGE_EXTENSIONS = "ts,tsx,js,jsx,mts,cts,mjs,cjs"
+const DEFAULT_COLLECT_COVERAGE_TEST_EXCLUDE = `!**/*.test.{${DEFAULT_COLLECT_COVERAGE_EXTENSIONS}}`
+
+async function resolveCollectCoverageFrom(rawPatterns, rootDir) {
+  const resolvedRootDir = path.resolve(String(rootDir ?? ""))
+
+  const normalized = Array.isArray(rawPatterns)
+    ? rawPatterns
+        .map((pattern) => String(pattern ?? "").trim())
+        .filter((pattern) => pattern.length > 0)
+    : []
+
+  const excludes = normalized.filter((pattern) => pattern.startsWith("!"))
+  const hasIncludes = normalized.some((pattern) => !pattern.startsWith("!"))
+  if (hasIncludes) {
+    return withDefaultExcludes(normalized)
+  }
+
+  const defaults = await inferDefaultCollectCoverageFrom(resolvedRootDir)
+  if (defaults.length === 0) {
+    throw new Error(
+      "Coverage config: couldn't infer a default `collectCoverageFrom` (src/ directory missing). Provide `collectCoverageFrom` with at least one positive glob pattern.",
+    )
+  }
+
+  return withDefaultExcludes([...defaults, ...excludes])
+}
+
+async function inferDefaultCollectCoverageFrom(rootDir) {
+  const srcDir = path.join(rootDir, "src")
+  if (await isDirectory(srcDir)) {
+    return [`src/**/*.{${DEFAULT_COLLECT_COVERAGE_EXTENSIONS}}`]
+  }
+
+  return []
+}
+
+function withDefaultExcludes(patterns) {
+  if (!Array.isArray(patterns) || patterns.length === 0) {
+    return patterns
+  }
+
+  const hasTestExclude = patterns.some((pattern) => {
+    const raw = String(pattern ?? "")
+    if (!raw.startsWith("!")) {
+      return false
+    }
+    return /\.test(?:\.|\{|$)/.test(raw.slice(1))
+  })
+  if (hasTestExclude) {
+    return patterns
+  }
+
+  return [...patterns, DEFAULT_COLLECT_COVERAGE_TEST_EXCLUDE]
+}
+
+async function isDirectory(filePath) {
+  try {
+    const stat = await fs.stat(filePath)
+    return stat.isDirectory()
+  } catch {
+    return false
+  }
+}
+
+async function normalizeOptions(rawOptions, filePath, defaultTestResultsDir) {
   const options = { ...rawOptions }
   const configDir = path.dirname(filePath)
+  const rootDir = path.resolve(configDir, "..")
 
-  const workspaceRoot = path.resolve(
-    options.workspaceRoot ? path.resolve(configDir, options.workspaceRoot) : process.cwd(),
-  )
-
-  const libDirs = Array.isArray(options.libDirs) && options.libDirs.length > 0
-    ? options.libDirs.map((entry) => path.resolve(workspaceRoot, entry))
-    : [path.resolve(workspaceRoot, "lib")]
+  const collectCoverageFrom = await resolveCollectCoverageFrom(options.collectCoverageFrom, rootDir)
 
   return {
-    workspaceRoot,
-    libDirs,
+    rootDir,
+    collectCoverageFrom,
     testResultsDir: options.testResultsDir ?? defaultTestResultsDir ?? "test-results",
     coverageReportSubdir: options.coverageReportSubdir ?? "coverage",
     coverageFileName: options.coverageFileName ?? "v8-coverage.json",
+    includeAllFiles: options.includeAllFiles,
     thresholds: options.thresholds ?? {},
   }
 }

package/src/coverage/config.js

@@ -23,22 +23,25 @@ function resolveDir(root, target, fallback) {
 }
 
 export function createCoverageConfig(options = {}) {
-  const { workspaceRoot } = options
-  if (!workspaceRoot) {
-    throw new Error("createCoverageConfig requires a workspaceRoot")
+  const { rootDir } = options
+  if (!rootDir) {
+    throw new Error("createCoverageConfig requires a rootDir")
   }
 
-  const resolvedWorkspaceRoot = path.resolve(workspaceRoot)
+  const resolvedRootDir = path.resolve(rootDir)
+  const includeAllFiles = options.includeAllFiles !== false
 
-  const libDirs = Array.isArray(options.libDirs) && options.libDirs.length > 0
-    ? options.libDirs
-    : ["lib"]
+  const collectCoverageFrom = Array.isArray(options.collectCoverageFrom)
+    ? options.collectCoverageFrom
+        .map((pattern) => String(pattern ?? "").trim())
+        .filter((pattern) => pattern.length > 0)
+    : []
 
-  const libRoots = libDirs.map((dir) =>
-    path.isAbsolute(dir) ? path.normalize(dir) : path.resolve(resolvedWorkspaceRoot, dir),
-  )
+  if (collectCoverageFrom.length === 0) {
+    throw new Error("createCoverageConfig requires a collectCoverageFrom option")
+  }
 
-  const testResultsRoot = resolveDir(resolvedWorkspaceRoot, options.testResultsDir, "test-results")
+  const testResultsRoot = resolveDir(resolvedRootDir, options.testResultsDir, "test-results")
   const coverageReportDir = resolveDir(testResultsRoot, options.coverageReportSubdir, "coverage")
   const coverageFileName = options.coverageFileName ?? "v8-coverage.json"
   const disabledEnvVar = options.disabledEnvVar ?? "RB_DISABLE_COVERAGE"
@@ -47,8 +50,8 @@ export function createCoverageConfig(options = {}) {
   const { global: thresholds, targets: thresholdTargets } = normalizeThresholdOptions(options.thresholds)
 
   return {
-    workspaceRoot: resolvedWorkspaceRoot,
-    libRoots,
+    rootDir: resolvedRootDir,
+    collectCoverageFrom,
     testResultsRoot,
     coverageReportDir,
     coverageFileName,
@@ -56,6 +59,7 @@ export function createCoverageConfig(options = {}) {
     thresholdTargets,
     coverageEnabled,
     disabledEnvVar,
+    includeAllFiles,
   }
 }
 

package/src/coverage/fixtures.js

@@ -26,7 +26,11 @@ export function createCoverageFixtures(baseTest, config) {
         // eslint-disable-next-line react-hooks/rules-of-hooks
         await use(page)
       } finally {
-        await tracker.stop(testInfo)
+        try {
+          await tracker.stop(testInfo)
+        } catch (error) {
+          console.warn("[coverage] failed to record V8 coverage:", error)
+        }
       }
     },
   })

package/src/coverage/global-setup.js

@@ -5,6 +5,10 @@ import { removeCoverageFiles } from "./files.js"
 
 export function createCoverageGlobalSetup(config) {
   return async function globalSetup() {
+    if (process.env.RB_TEST_COMBINED_COVERAGE === "1") {
+      return
+    }
+
     if (!config.coverageEnabled) {
       return
     }

package/src/coverage/report.js

@@ -1,12 +1,16 @@
 import fs from "node:fs/promises"
 import path from "node:path"
+import { fileURLToPath } from "node:url"
 
 import * as libCoverage from "istanbul-lib-coverage"
+import * as libInstrument from "istanbul-lib-instrument"
 import { createContext } from "istanbul-lib-report"
 import reports from "istanbul-reports"
+import fg from "fast-glob"
 import picomatch from "picomatch"
 import v8ToIstanbul from "v8-to-istanbul"
 
+import { createCollectCoverageMatcher, toPosix } from "./collect.js"
 import { findCoverageFiles } from "./files.js"
 
 
@@ -29,6 +33,7 @@ export async function generateCoverageReport(config) {
 
   const coverageLib = resolveCoverageLib()
   const coverageMap = coverageLib.createCoverageMap({})
+  const matchesCollectCoverageFrom = createCollectCoverageMatcher(config.collectCoverageFrom, config.rootDir)
 
   for (const file of coverageFiles) {
     const payload = await readCoverageFile(file)
@@ -37,10 +42,14 @@ export async function generateCoverageReport(config) {
     }
 
     for (const script of payload.scripts) {
-      await mergeScriptCoverage(coverageMap, script)
+      await mergeScriptCoverage(coverageMap, script, config, matchesCollectCoverageFrom)
     }
   }
 
+  if (config.includeAllFiles) {
+    await includeUntestedFiles(coverageMap, config, matchesCollectCoverageFrom)
+  }
+
   if (coverageMap.files().length === 0) {
     console.warn("[coverage] no library files matched the coverage filters")
     return
@@ -65,7 +74,7 @@ export async function generateCoverageReport(config) {
 
   const targets = Array.isArray(config.thresholdTargets) ? config.thresholdTargets : []
   if (targets.length > 0) {
-    const fileSummaries = buildFileSummaries(coverageMap, config.workspaceRoot)
+    const fileSummaries = buildFileSummaries(coverageMap, config.rootDir)
     for (const target of targets) {
       const matcher = createGlobMatcher(target.pattern)
       const matchResult = collectTargetSummary(fileSummaries, matcher, coverageLib)
@@ -82,20 +91,49 @@ export async function generateCoverageReport(config) {
   }
 }
 
-async function mergeScriptCoverage(coverageMap, script) {
+async function mergeScriptCoverage(coverageMap, script, config, matchesCollectCoverageFrom) {
   const scriptPath = script.absolutePath
   if (!scriptPath) {
     return
   }
 
-  const source = script.source && script.source.length > 0
+  if (isNodeModulesPath(scriptPath)) {
+    return
+  }
+
+  if (isViteVirtualModulePath(scriptPath)) {
+    return
+  }
+
+  let source = script.source && script.source.length > 0
     ? script.source
-    : await fs.readFile(scriptPath, "utf8")
+    : ""
+
+  if (!source) {
+    try {
+      source = await fs.readFile(scriptPath, "utf8")
+    } catch (error) {
+      const base = path.basename(scriptPath)
+      if (error?.code === "ENOENT" && base && !base.includes(".")) {
+        return
+      }
+      throw error
+    }
+  }
 
-  const converter = v8ToIstanbul(scriptPath, 0, { source })
+  const sourceMap = await loadSourceMapForScript(scriptPath, source)
+  const converter = v8ToIstanbul(
+    scriptPath,
+    0,
+    sourceMap ? { source, sourceMap: { sourcemap: sourceMap } } : { source },
+  )
   await converter.load()
   converter.applyCoverage(script.functions)
-  coverageMap.merge(converter.toIstanbul())
+
+  const filtered = filterCoverageMap(converter.toIstanbul(), config, matchesCollectCoverageFrom)
+  if (Object.keys(filtered).length > 0) {
+    coverageMap.merge(filtered)
+  }
 }
 
 async function readCoverageFile(file) {
@@ -143,19 +181,156 @@ function resolveCoverageLib() {
   throw new Error("istanbul-lib-coverage exports are unavailable")
 }
 
-function buildFileSummaries(coverageMap, workspaceRoot) {
-  const normalizedRoot = path.resolve(workspaceRoot)
+function resolveInstrumentLib() {
+  const candidate = libInstrument
+  if (typeof candidate.createInstrumenter === "function") {
+    return candidate
+  }
+
+  if (candidate.default && typeof candidate.default.createInstrumenter === "function") {
+    return candidate.default
+  }
+
+  throw new Error("istanbul-lib-instrument exports are unavailable")
+}
+
+async function includeUntestedFiles(coverageMap, config, matchesCollectCoverageFrom) {
+  const existing = new Set(
+    coverageMap.files().map((filePath) => path.resolve(String(filePath ?? ""))),
+  )
+
+  const candidates = await findCollectCoverageFiles(config, matchesCollectCoverageFrom)
+  if (candidates.length === 0) {
+    return
+  }
+
+  const instrumentLib = resolveInstrumentLib()
+  const instrumenter = instrumentLib.createInstrumenter({
+    esModules: true,
+    parserPlugins: [
+      "typescript",
+      "jsx",
+      "classProperties",
+      "classPrivateProperties",
+      "classPrivateMethods",
+      "decorators-legacy",
+      "importMeta",
+      "topLevelAwait",
+    ],
+  })
+
+  for (const filePath of candidates) {
+    const normalized = path.resolve(filePath)
+    if (existing.has(normalized)) {
+      continue
+    }
+
+    const source = await fs.readFile(normalized, "utf8").catch(() => null)
+    if (source === null) {
+      continue
+    }
+
+    try {
+      instrumenter.instrumentSync(source, normalized)
+      const fileCoverage = instrumenter.lastFileCoverage()
+      if (!fileCoverage) {
+        continue
+      }
+      coverageMap.addFileCoverage(fileCoverage)
+      existing.add(normalized)
+    } catch (error) {
+      const relative = path.relative(config.rootDir, normalized)
+      console.warn(
+        `[coverage] failed to instrument ${relative && !relative.startsWith("..") ? relative : normalized}:`,
+        error,
+      )
+    }
+  }
+}
+
+const DEFAULT_COLLECT_COVERAGE_IGNORES = [
+  "**/.git/**",
+  "**/.next/**",
+  "**/.turbo/**",
+  "**/.vite/**",
+  "**/.vitest/**",
+  "**/build/**",
+  "**/coverage/**",
+  "**/dist/**",
+  "**/node_modules/**",
+  "**/playwright-report/**",
+  "**/spec/**",
+  "**/test/**",
+  "**/test-results/**",
+  "**/tests/**",
+  "**/__tests__/**",
+  "**/*.d.ts",
+  "**/*.map",
+]
+
+async function findCollectCoverageFiles(config, matchesCollectCoverageFrom) {
+  const patterns = Array.isArray(config.collectCoverageFrom)
+    ? config.collectCoverageFrom
+    : []
+
+  if (patterns.length === 0) {
+    return []
+  }
+
+  const rawFiles = await fg(patterns, {
+    cwd: config.rootDir,
+    absolute: true,
+    dot: true,
+    onlyFiles: true,
+    unique: true,
+    followSymbolicLinks: false,
+    ignore: DEFAULT_COLLECT_COVERAGE_IGNORES,
+  }).catch(() => [])
+
+  const collected = new Set()
+
+  for (const file of rawFiles) {
+    const normalized = path.resolve(String(file ?? ""))
+    if (!normalized) {
+      continue
+    }
+
+    if (normalized.endsWith(".d.ts") || normalized.endsWith(".map")) {
+      continue
+    }
+
+    if (isNodeModulesPath(normalized)) {
+      continue
+    }
+
+    if (isViteVirtualModulePath(normalized)) {
+      continue
+    }
+
+    if (!matchesCollectCoverageFrom(normalized)) {
+      continue
+    }
+
+    collected.add(normalized)
+  }
+
+  return Array.from(collected).sort()
+}
+
+function buildFileSummaries(coverageMap, rootDir) {
+  const normalizedRoot = path.resolve(rootDir)
   return coverageMap.files().map((filePath) => {
     const normalizedAbsolute = path.resolve(filePath)
     const summary = coverageMap.fileCoverageFor(filePath).toSummary()
     const relativePath = path.relative(normalizedRoot, normalizedAbsolute)
-    const candidates = new Set([toPosix(normalizedAbsolute)])
+    const candidates = new Set()
 
-    if (relativePath && !relativePath.startsWith("..")) {
+    if (relativePath) {
       const relativePosix = toPosix(relativePath)
       candidates.add(relativePosix)
       candidates.add(`./${relativePosix}`)
-      candidates.add(`/${relativePosix}`)
+    } else {
+      candidates.add(toPosix(path.basename(normalizedAbsolute)))
     }
 
     return {
@@ -184,9 +359,242 @@ function createGlobMatcher(pattern) {
   if (!normalized) {
     return () => false
   }
+  if (isAbsoluteGlobPattern(normalized)) {
+    throw new Error(`[coverage] threshold patterns must be relative (absolute paths are not supported): "${pattern}"`)
+  }
   return picomatch(normalized, { dot: true })
 }
 
-function toPosix(input) {
-  return input.split(path.sep).join("/")
+function isAbsoluteGlobPattern(pattern) {
+  const normalized = String(pattern ?? "").trim()
+  if (!normalized) {
+    return false
+  }
+
+  if (normalized.startsWith("/")) {
+    return true
+  }
+
+  if (normalized.startsWith("file://")) {
+    return true
+  }
+
+  return /^[A-Za-z]:\//.test(normalized)
+}
+
+function stripQuery(url) {
+  const queryIndex = url.indexOf("?")
+  const hashIndex = url.indexOf("#")
+
+  const endIndex = Math.min(
+    queryIndex === -1 ? Number.POSITIVE_INFINITY : queryIndex,
+    hashIndex === -1 ? Number.POSITIVE_INFINITY : hashIndex,
+  )
+
+  if (!Number.isFinite(endIndex)) {
+    return url
+  }
+
+  return url.slice(0, endIndex)
+}
+
+function extractSourceMappingUrl(source) {
+  const regex = /\/\/[#@]\s*sourceMappingURL=([^\s]+)/g
+
+  let last = null
+  let match = null
+
+  while ((match = regex.exec(source)) !== null) {
+    last = match[1]
+  }
+
+  return typeof last === "string" && last.length > 0 ? last : null
+}
+
+function resolveSourceMapPath(scriptPath, mappingUrl) {
+  const cleaned = stripQuery(mappingUrl)
+
+  if (cleaned.startsWith("file://")) {
+    return fileURLToPath(cleaned)
+  }
+
+  if (path.isAbsolute(cleaned)) {
+    return cleaned
+  }
+
+  return path.resolve(path.dirname(scriptPath), cleaned)
+}
+
+function filterCoverageMap(map, config, matchesCollectCoverageFrom) {
+  if (!map || typeof map !== "object") {
+    return {}
+  }
+
+  const filtered = {}
+
+  for (const [filePath, fileCoverage] of Object.entries(map)) {
+    const absolutePath = resolveCoveragePath(filePath, config.rootDir)
+    if (!absolutePath) {
+      continue
+    }
+
+    if (absolutePath.endsWith(".d.ts") || absolutePath.endsWith(".map")) {
+      continue
+    }
+
+    if (isNodeModulesPath(absolutePath)) {
+      continue
+    }
+
+    if (isViteVirtualModulePath(absolutePath)) {
+      continue
+    }
+
+    if (!matchesCollectCoverageFrom(absolutePath)) {
+      continue
+    }
+
+    if (fileCoverage && typeof fileCoverage === "object") {
+      filtered[absolutePath] = { ...fileCoverage, path: absolutePath }
+    } else {
+      filtered[absolutePath] = fileCoverage
+    }
+  }
+
+  return filtered
+}
+
+function resolveCoveragePath(filePath, rootDir) {
+  const raw = String(filePath ?? "").trim()
+  if (!raw) {
+    return null
+  }
+
+  const cleaned = stripQuery(raw)
+
+  if (cleaned.startsWith("file://")) {
+    try {
+      return path.normalize(fileURLToPath(cleaned))
+    } catch {
+      return null
+    }
+  }
+
+  if (path.isAbsolute(cleaned)) {
+    return path.normalize(cleaned)
+  }
+
+  if (cleaned.includes("://")) {
+    return null
+  }
+
+  return path.normalize(path.resolve(rootDir, cleaned))
+}
+
+function isNodeModulesPath(filePath) {
+  return path
+    .normalize(String(filePath ?? ""))
+    .split(path.sep)
+    .includes("node_modules")
+}
+
+function isViteVirtualModulePath(filePath) {
+  const normalized = path.normalize(String(filePath ?? ""))
+  const baseName = path.basename(normalized)
+  return baseName === "__vite-browser-external"
+    || baseName.startsWith("__vite-browser-external:")
+    || baseName.startsWith("__vite-")
+}
+
+function parseSourceMapPayload(raw) {
+  if (!raw || typeof raw !== "object") {
+    return null
+  }
+
+  const sources = raw.sources
+  if (!Array.isArray(sources) || sources.length === 0) {
+    return null
+  }
+
+  return raw
+}
+
+function normalizeSourceMap(sourceMap, scriptPath) {
+  const root = typeof sourceMap.sourceRoot === "string"
+    ? sourceMap.sourceRoot.replace("file://", "")
+    : ""
+
+  const dir = path.dirname(scriptPath)
+  const fixedSources = sourceMap.sources.map((source) => {
+    const raw = String(source ?? "")
+    const cleaned = stripQuery(raw)
+
+    if (cleaned.startsWith("file://")) {
+      try {
+        return path.normalize(fileURLToPath(cleaned))
+      } catch {
+        return cleaned
+      }
+    }
+
+    const withoutWebpack = cleaned.replace(/^webpack:\/\//, "")
+    const candidate = path.join(root, withoutWebpack)
+
+    if (path.isAbsolute(candidate)) {
+      return path.normalize(candidate)
+    }
+
+    const normalizedCandidate = candidate.split("/").join(path.sep)
+
+    if (dir.endsWith(`${path.sep}dist`) && !normalizedCandidate.startsWith(`..${path.sep}`)) {
+      if (normalizedCandidate.startsWith(`src${path.sep}`) || normalizedCandidate.startsWith(`lib${path.sep}`)) {
+        return path.normalize(path.resolve(dir, "..", normalizedCandidate))
+      }
+    }
+
+    return path.normalize(path.resolve(dir, normalizedCandidate))
+  })
+
+  return {
+    ...sourceMap,
+    sources: fixedSources,
+  }
+}
+
+async function loadSourceMapForScript(scriptPath, source) {
+  const mappingUrl = extractSourceMappingUrl(source)
+  if (!mappingUrl) {
+    return null
+  }
+
+  const cleaned = stripQuery(mappingUrl)
+
+  if (cleaned.startsWith("data:")) {
+    const commaIndex = cleaned.indexOf(",")
+    if (commaIndex === -1) {
+      return null
+    }
+
+    const meta = cleaned.slice(0, commaIndex)
+    const payload = cleaned.slice(commaIndex + 1)
+    const raw = meta.includes(";base64")
+      ? Buffer.from(payload, "base64").toString("utf8")
+      : decodeURIComponent(payload)
+
+    try {
+      const parsed = parseSourceMapPayload(JSON.parse(raw))
+      return parsed ? normalizeSourceMap(parsed, scriptPath) : null
+    } catch {
+      return null
+    }
+  }
+
+  try {
+    const mapPath = resolveSourceMapPath(scriptPath, cleaned)
+    const raw = await fs.readFile(mapPath, "utf8")
+    const parsed = parseSourceMapPayload(JSON.parse(raw))
+    return parsed ? normalizeSourceMap(parsed, scriptPath) : null
+  } catch {
+    return null
+  }
 }

package/src/coverage/reporter.js

@@ -13,6 +13,10 @@ class CoverageReporter {
   }
 
   async onBegin() {
+    if (process.env.RB_TEST_COMBINED_COVERAGE === "1") {
+      return
+    }
+
     if (!this.config.coverageEnabled) {
       return
     }
@@ -22,6 +26,10 @@ class CoverageReporter {
   }
 
   async onEnd(result) {
+    if (process.env.RB_TEST_COMBINED_COVERAGE === "1") {
+      return
+    }
+
     if (!this.config.coverageEnabled) {
       return
     }

package/src/coverage/v8-tracker.js

@@ -1,13 +1,26 @@
 import fs from "node:fs/promises"
 import path from "node:path"
 
+import { isInsideAnyRoot, resolveCollectCoverageRoots } from "./collect.js"
+
 
 const VITE_FS_PREFIX = "/@fs/"
 
+function sanitizePathSegment(input) {
+  const value = String(input ?? "").trim()
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "_") || "unknown"
+}
+
+function urlPathLooksLikeFile(pathname) {
+  const base = path.posix.basename(String(pathname ?? ""))
+  return base.length > 0 && base.includes(".")
+}
+
 export async function createCoverageTracker(page, config) {
   const session = await page.context().newCDPSession(page)
   const scriptMeta = new Map()
   const sourceCache = new Map()
+  const scriptRoots = resolveCollectCoverageRoots(config.collectCoverageFrom, config.rootDir)
 
   await session.send("Debugger.enable")
   session.on("Debugger.scriptParsed", (event) => {
@@ -16,16 +29,14 @@ export async function createCoverageTracker(page, config) {
     }
 
     const normalized = normalizeScriptUrl(event.url, config)
-    const trackable = normalized && isInsideLib(normalized.absolutePath, config.libRoots)
+    const trackable = normalized
+      && !isNodeModulesPath(normalized.absolutePath)
+      && isInsideAnyRoot(normalized.absolutePath, scriptRoots)
 
     scriptMeta.set(event.scriptId, {
       normalized: trackable ? normalized : null,
       url: event.url,
     })
-
-    if (trackable && !sourceCache.has(event.scriptId)) {
-      sourceCache.set(event.scriptId, fetchScriptSource(session, event.scriptId))
-    }
   })
 
   await session.send("Profiler.enable")
@@ -40,7 +51,7 @@ export async function createCoverageTracker(page, config) {
           return
         }
 
-        const outputFile = testInfo.outputPath(config.coverageFileName)
+        const outputFile = resolveCoverageOutputFile(config, testInfo)
         await fs.mkdir(path.dirname(outputFile), { recursive: true })
         await fs.writeFile(outputFile, JSON.stringify(payload, null, 2), "utf8")
       } finally {
@@ -50,6 +61,13 @@ export async function createCoverageTracker(page, config) {
   }
 }
 
+function resolveCoverageOutputFile(config, testInfo) {
+  const projectName = sanitizePathSegment(testInfo.project?.name)
+  const testId = sanitizePathSegment(testInfo.testId)
+  const outputDir = path.join(config.testResultsRoot, "playwright", projectName, testId)
+  return path.join(outputDir, config.coverageFileName)
+}
+
 async function collectCoveragePayload(session, scriptMeta, sourceCache, testInfo, config) {
   const { result } = await session.send("Profiler.takePreciseCoverage")
   await session.send("Profiler.stopPreciseCoverage")
@@ -90,8 +108,23 @@ async function resolveScriptSource(session, cache, scriptId) {
 }
 
 async function fetchScriptSource(session, scriptId) {
-  const sourceResponse = await session.send("Debugger.getScriptSource", { scriptId })
-  return sourceResponse?.scriptSource ?? ""
+  try {
+    const sourceResponse = await session.send("Debugger.getScriptSource", { scriptId })
+    return sourceResponse?.scriptSource ?? ""
+  } catch (error) {
+    const message = String(error?.message ?? error)
+    if (message.includes("Debugger agent is not enabled")) {
+      try {
+        await session.send("Debugger.enable")
+        const sourceResponse = await session.send("Debugger.getScriptSource", { scriptId })
+        return sourceResponse?.scriptSource ?? ""
+      } catch {
+        return ""
+      }
+    }
+
+    return ""
+  }
 }
 
 async function shutdownSession(session) {
@@ -128,22 +161,22 @@ function normalizeScriptUrl(rawUrl, config) {
   if (decoded.startsWith(VITE_FS_PREFIX)) {
     absolutePath = path.normalize(decoded.slice(VITE_FS_PREFIX.length))
   } else if (decoded.startsWith("/")) {
-    absolutePath = path.resolve(config.workspaceRoot, `.${decoded}`)
+    if (!urlPathLooksLikeFile(decoded)) {
+      return null
+    }
+    absolutePath = path.resolve(process.cwd(), `.${decoded}`)
   } else {
     return null
   }
 
-  return createNormalizedPath(absolutePath, config.workspaceRoot)
+  return createNormalizedPath(absolutePath, config.rootDir)
 }
 
-function createNormalizedPath(absolutePath, workspaceRoot) {
-  if (!absolutePath.startsWith(workspaceRoot)) {
-    return null
-  }
-
-  const relativePath = path.relative(workspaceRoot, absolutePath)
+function createNormalizedPath(absolutePath, rootDir) {
+  const normalizedAbsolute = path.normalize(absolutePath)
+  const relativePath = path.relative(rootDir, normalizedAbsolute)
   return {
-    absolutePath,
+    absolutePath: normalizedAbsolute,
     relativePath,
   }
 }
@@ -164,9 +197,9 @@ function stripQuery(url) {
   return url.slice(0, endIndex)
 }
 
-function isInsideLib(absolutePath, libRoots) {
-  return libRoots.some((libRoot) => {
-    const relative = path.relative(libRoot, absolutePath)
-    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))
-  })
+function isNodeModulesPath(filePath) {
+  return path
+    .normalize(String(filePath ?? ""))
+    .split(path.sep)
+    .includes("node_modules")
 }

package/src/index.js

@@ -17,7 +17,7 @@ export function defineConfig(userConfig = {}) {
   const normalized = { ...userConfig }
   const reporters = ensureReporterArray(normalized.reporter)
 
-  if (coverageHarness?.config.coverageEnabled) {
+  if (coverageHarness?.config.coverageEnabled && process.env.RB_TEST_COMBINED_COVERAGE !== "1") {
     const coverageReporter = coverageHarness.reporterEntry()
     if (!reporters.some(([name]) => name === coverageReporter[0])) {
       reporters.push(coverageReporter)