@rpcbase/test 0.308.0 → 0.310.0

package/src/cli.js

@@ -1,948 +0,0 @@
-#!/usr/bin/env node
-
-import { spawn, spawnSync } from "child_process"
-import fs from "fs"
-import fsPromises from "fs/promises"
-import path from "path"
-import { createRequire } from "module"
-import { fileURLToPath } from "url"
-
-import fg from "fast-glob"
-
-import { createCoverageConfig } from "./coverage/config.js"
-import { createCollectCoverageMatcher, isInsideAnyRoot, resolveCollectCoverageRoots } from "./coverage/collect.js"
-import { loadCoverageOptions } from "./coverage/config-loader.js"
-import { removeCoverageFiles } from "./coverage/files.js"
-import { collectCoveredFiles, CoverageThresholdError, generateCoverageReport } from "./coverage/report.js"
-
-
-const require = createRequire(import.meta.url)
-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"
-
-if (process.env.IS_AIDER !== undefined && process.env.IS_AIDER !== "yes") {
-  console.warn("Warning: IS_AIDER is set to a value other than 'yes'.")
-}
-
-async function runTests() {
-  const userArgs = process.argv.slice(2)
-  const buildSpecsMap = userArgs.includes("--build-specs-map")
-  const auto = userArgs.includes("--auto")
-  const showMapping = userArgs.includes("--show-mapping")
-  const filteredArgs = userArgs.filter((arg) => arg !== "--build-specs-map" && arg !== "--auto" && arg !== "--show-mapping")
-
-  if (buildSpecsMap && auto) {
-    throw new Error("[rb-test] --auto cannot be combined with --build-specs-map")
-  }
-
-  if (showMapping && !auto) {
-    throw new Error("[rb-test] --show-mapping requires --auto")
-  }
-
-  const playwrightCoverage = await loadPlaywrightCoverageConfig()
-  const vitestCoverage = await loadVitestCoverageConfig()
-  const combinedCoverage = resolveCombinedCoverage(playwrightCoverage, vitestCoverage)
-
-  if (buildSpecsMap) {
-    await buildSpecsMapFromCoverage({
-      userArgs: filteredArgs,
-      playwrightCoverage,
-      vitestCoverage,
-      combinedCoverage,
-    })
-    return
-  }
-
-  const shouldGenerateCoverageReport = combinedCoverage?.enabled && !auto
-
-  if (shouldGenerateCoverageReport) {
-    await cleanCoverageArtifacts(combinedCoverage.config)
-  }
-
-  let testError = null
-
-  try {
-    await runVitest(vitestCoverage, combinedCoverage?.config ?? null, { disableCoverage: auto })
-    console.log("\nRunning Playwright Tests...")
-    const playwrightArgs = auto
-      ? await resolveAutoPlaywrightArgs({
-        userArgs: filteredArgs,
-        playwrightCoverage,
-        vitestCoverage,
-        showMapping,
-      })
-      : userArgs
-    if (playwrightArgs) {
-      await runPlaywright(playwrightArgs, { disableCoverage: auto })
-    }
-  } catch (error) {
-    testError = error
-  }
-
-  if (shouldGenerateCoverageReport) {
-    try {
-      await finalizeCoverage(combinedCoverage.config)
-    } catch (error) {
-      if (!testError) {
-        testError = error
-      }
-    }
-  }
-
-  if (testError) {
-    throw testError
-  }
-}
-
-runTests()
-  .then(() => process.exit(0))
-  .catch((error) => {
-    if (!(error instanceof CoverageThresholdError)) {
-      console.error(error?.stack ?? String(error))
-    }
-    process.exit(1)
-  })
-
-async function runVitest(coverage, combinedConfig, { disableCoverage = false } = {}) {
-  const vitestArgs = ["run", "--passWithNoTests"]
-  const vitestConfig = resolveVitestConfig()
-
-  if (vitestConfig) {
-    vitestArgs.push("--config", vitestConfig)
-  }
-  const launcher = resolveVitestLauncher()
-  const env = withRegisterShim(process.env)
-
-  if (disableCoverage) {
-    env.RB_DISABLE_COVERAGE = "1"
-  }
-
-  if (coverage?.enabled && !disableCoverage) {
-    env.NODE_V8_COVERAGE = resolveNodeCoverageDir(combinedConfig ?? coverage.config)
-  }
-
-  await spawnWithLogs({
-    name: "Vitest",
-    launcher,
-    args: vitestArgs,
-    env,
-    successMessage: "Vitest suite passed!",
-    failureMessage: "Vitest failed",
-  })
-
-  if (coverage?.enabled && !disableCoverage) {
-    await convertNodeCoverage({
-      config: combinedConfig ?? coverage.config,
-      nodeCoverageDir: resolveNodeCoverageDir(combinedConfig ?? coverage.config),
-    })
-  }
-}
-
-async function buildSpecsMapFromCoverage({ userArgs, combinedCoverage }) {
-  if (!combinedCoverage?.enabled) {
-    throw new Error("[specs-map] Coverage must be enabled to build the specs map.")
-  }
-
-  const config = combinedCoverage.config
-  const workspaceRoot = findWorkspaceRoot(process.cwd())
-
-  const specSourceFiles = await findSpecSourceFiles(config.rootDir)
-  if (specSourceFiles.length === 0) {
-    throw new Error("[specs-map] No spec files found under spec/**/*.spec.ts")
-  }
-
-  const filesMapDir = path.join(config.testResultsRoot, "files-map")
-  await fsPromises.rm(filesMapDir, { recursive: true, force: true })
-  await fsPromises.mkdir(filesMapDir, { recursive: true })
-
-  for (const specSourceFile of specSourceFiles) {
-    const specProjectPath = path.relative(config.rootDir, specSourceFile)
-    const specWorkspacePath = toPosixPath(path.relative(workspaceRoot, specSourceFile))
-    const testFile = resolvePlaywrightSpecFile(specProjectPath)
-
-    console.log(`\n[specs-map] Running ${specWorkspacePath}`)
-
-    await removeCoverageFiles(config)
-
-    let error = null
-    let failed = false
-    try {
-      await runPlaywright([...userArgs, testFile])
-    } catch (runError) {
-      error = runError
-      failed = true
-      console.error(`[specs-map] Failed: ${specWorkspacePath}`)
-      console.error(runError?.stack ?? String(runError))
-    }
-
-    const coveredFiles = await collectCoveredFiles(config)
-    const impactedFiles = coveredFiles
-      .map((filePath) => toPosixPath(path.relative(workspaceRoot, filePath)))
-      .filter((relativePath) => relativePath && !relativePath.startsWith("../") && relativePath !== "..")
-      .sort()
-
-    const outputFile = path.join(filesMapDir, `${specProjectPath}.json`)
-    await fsPromises.mkdir(path.dirname(outputFile), { recursive: true })
-    await fsPromises.writeFile(
-      outputFile,
-      JSON.stringify(
-        {
-          spec: specWorkspacePath,
-          files: impactedFiles,
-          failed,
-        },
-        null,
-        2,
-      ),
-      "utf8",
-    )
-
-    if (failed) {
-      throw error
-    }
-  }
-}
-
-async function resolveAutoPlaywrightArgs({ userArgs, playwrightCoverage, vitestCoverage, showMapping = false }) {
-  const config = playwrightCoverage?.config ?? vitestCoverage?.config ?? null
-  if (!config) {
-    console.warn("[auto] Coverage config not found; running full Playwright suite.")
-    return userArgs
-  }
-
-  const filesMapDir = path.join(config.testResultsRoot, "files-map")
-  const mapFiles = await findFilesMapJson(filesMapDir)
-  if (mapFiles.length === 0) {
-    console.warn("[auto] Specs map not found; running full Playwright suite.")
-    return userArgs
-  }
-
-  const workspaceRoot = findWorkspaceRoot(process.cwd())
-  const gitChanges = getGitChanges(workspaceRoot)
-  const renameMap = new Map(gitChanges.filter((change) => change.kind === "rename").map((change) => [change.oldPath, change.newPath]))
-
-  const specRootAbs = path.join(config.rootDir, "spec")
-  const matchesCollectCoverageFrom = createCollectCoverageMatcher(config.collectCoverageFrom, config.rootDir)
-
-  const directSpecChanges = new Set()
-  const sourceChanges = []
-
-  for (const change of gitChanges) {
-    if (change.kind === "rename") {
-      const oldAbs = path.join(workspaceRoot, change.oldPath)
-      const newAbs = path.join(workspaceRoot, change.newPath)
-
-      if (isSpecSourceFile(newAbs, specRootAbs) && fs.existsSync(newAbs)) {
-        directSpecChanges.add(change.newPath)
-      }
-
-      const oldMatches = matchesCollectCoverageFrom(oldAbs)
-      const newMatches = matchesCollectCoverageFrom(newAbs)
-      if (oldMatches || newMatches) {
-        sourceChanges.push(change)
-      }
-      continue
-    }
-
-    const abs = path.join(workspaceRoot, change.path)
-
-    if (isSpecSourceFile(abs, specRootAbs) && fs.existsSync(abs)) {
-      directSpecChanges.add(change.path)
-    }
-
-    if (matchesCollectCoverageFrom(abs)) {
-      sourceChanges.push(change)
-    }
-  }
-
-  if (directSpecChanges.size === 0 && sourceChanges.length === 0) {
-    console.log("[auto] No relevant git changes.")
-    return null
-  }
-
-  const parsedMaps = []
-  for (const file of mapFiles) {
-    const json = await readJson(file)
-    if (!json) {
-      continue
-    }
-
-    if (json.failed === true) {
-      console.warn("[auto] Specs map contains failed entries; running full Playwright suite.")
-      return userArgs
-    }
-
-    const spec = typeof json?.spec === "string" ? json.spec : null
-    if (!spec) {
-      continue
-    }
-
-    const files = Array.isArray(json?.files) ? json.files.filter((entry) => typeof entry === "string") : []
-    parsedMaps.push({ spec, files })
-  }
-
-  if (parsedMaps.length === 0) {
-    console.warn("[auto] Specs map is empty; running full Playwright suite.")
-    return userArgs
-  }
-
-  const specsByImpactedFile = new Map()
-
-  for (const entry of parsedMaps) {
-    const resolvedSpec = resolveRenamedPath(entry.spec, renameMap)
-    for (const file of entry.files) {
-      const list = specsByImpactedFile.get(file) ?? []
-      list.push(resolvedSpec)
-      specsByImpactedFile.set(file, list)
-    }
-  }
-
-  const unmappedSourceChanges = sourceChanges.filter((change) => {
-    if (change.kind === "path") {
-      return !specsByImpactedFile.has(change.path)
-    }
-    return !specsByImpactedFile.has(change.oldPath) && !specsByImpactedFile.has(change.newPath)
-  })
-
-  if (unmappedSourceChanges.length > 0) {
-    console.warn("[auto] Unmapped source changes detected:")
-    for (const change of unmappedSourceChanges) {
-      if (change.kind === "path") {
-        console.warn(`  - ${change.path}`)
-      } else {
-        console.warn(`  - ${change.oldPath} -> ${change.newPath}`)
-      }
-    }
-  }
-
-  const selectedSpecs = new Set(directSpecChanges)
-  const triggersBySpec = new Map()
-
-  for (const spec of directSpecChanges) {
-    if (showMapping) {
-      triggersBySpec.set(spec, new Set([spec]))
-    }
-  }
-
-  for (const change of sourceChanges) {
-    if (change.kind === "path") {
-      const specs = specsByImpactedFile.get(change.path) ?? []
-      specs.forEach((spec) => selectedSpecs.add(spec))
-      if (showMapping) {
-        for (const spec of specs) {
-          const current = triggersBySpec.get(spec) ?? new Set()
-          current.add(change.path)
-          triggersBySpec.set(spec, current)
-        }
-      }
-      continue
-    }
-
-    const oldSpecs = specsByImpactedFile.get(change.oldPath) ?? []
-    oldSpecs.forEach((spec) => selectedSpecs.add(spec))
-    const newSpecs = specsByImpactedFile.get(change.newPath) ?? []
-    newSpecs.forEach((spec) => selectedSpecs.add(spec))
-    if (showMapping) {
-      const key = `${change.oldPath} -> ${change.newPath}`
-      const allSpecs = new Set([...oldSpecs, ...newSpecs])
-      for (const spec of allSpecs) {
-        const current = triggersBySpec.get(spec) ?? new Set()
-        current.add(key)
-        triggersBySpec.set(spec, current)
-      }
-    }
-  }
-
-  const missingSpecs = []
-  const specsToRun = Array.from(selectedSpecs)
-    .filter((spec) => {
-      const abs = path.join(workspaceRoot, spec)
-      if (fs.existsSync(abs)) {
-        return true
-      }
-      missingSpecs.push(spec)
-      return false
-    })
-    .sort()
-  if (missingSpecs.length > 0) {
-    console.warn(`[auto] Ignoring ${missingSpecs.length} missing spec file(s):`)
-    for (const spec of missingSpecs.sort()) {
-      console.warn(`  - ${spec}`)
-    }
-  }
-
-  if (specsToRun.length === 0) {
-    console.log("[auto] No impacted specs.")
-    return null
-  }
-
-  if (showMapping) {
-    console.log("[auto] Mapping:")
-    for (const spec of specsToRun) {
-      const triggers = Array.from(triggersBySpec.get(spec) ?? []).sort()
-      if (triggers.length === 0) {
-        continue
-      }
-      console.log(`  - ${spec}`)
-      for (const trigger of triggers) {
-        console.log(`    <- ${trigger}`)
-      }
-    }
-  }
-
-  const playwrightFiles = specsToRun
-    .map((specWorkspacePath) => path.join(workspaceRoot, specWorkspacePath))
-    .filter((specAbs) => isSubpath(specAbs, config.rootDir))
-    .map((specAbs) => {
-      const specProjectPath = path.relative(config.rootDir, specAbs)
-      return resolvePlaywrightSpecFile(specProjectPath)
-    })
-
-  const totalSpecFiles = (await findSpecSourceFiles(config.rootDir)).length
-  console.log(`[auto] Running ${playwrightFiles.length}/${totalSpecFiles} spec file(s).`)
-  return [...userArgs, ...playwrightFiles]
-}
-
-async function findFilesMapJson(filesMapDir) {
-  const patterns = ["spec/**/*.spec.ts.json", "spec/**/*.spec.tsx.json"]
-  const matches = await fg(patterns, { cwd: filesMapDir, absolute: true, onlyFiles: true }).catch(() => [])
-  return matches.sort()
-}
-
-function getGitChanges(workspaceRoot) {
-  const result = spawnSync("git", ["status", "--porcelain=1", "-z"], {
-    cwd: workspaceRoot,
-    encoding: "utf8",
-  })
-
-  if (result.status !== 0) {
-    throw new Error(`[auto] Failed to read git status: ${result.stderr || "unknown error"}`)
-  }
-
-  const tokens = String(result.stdout ?? "").split("\0").filter(Boolean)
-  const changes = []
-
-  for (let i = 0; i < tokens.length; i += 1) {
-    const record = tokens[i]
-    if (record.length < 4) {
-      continue
-    }
-
-    const status = record.slice(0, 2)
-    const pathPart = toPosixPath(record.slice(3))
-
-    if (isRenameOrCopyStatus(status)) {
-      const next = tokens[i + 1]
-      if (typeof next !== "string") {
-        continue
-      }
-      changes.push({
-        kind: "rename",
-        oldPath: pathPart,
-        newPath: toPosixPath(next),
-      })
-      i += 1
-      continue
-    }
-
-    changes.push({
-      kind: "path",
-      path: pathPart,
-    })
-  }
-
-  return changes
-}
-
-function isRenameOrCopyStatus(status) {
-  return status.includes("R") || status.includes("C")
-}
-
-function resolveRenamedPath(original, renameMap) {
-  let current = original
-  const visited = new Set()
-
-  while (renameMap.has(current) && !visited.has(current)) {
-    visited.add(current)
-    current = renameMap.get(current)
-  }
-
-  return current
-}
-
-function isSubpath(candidate, root) {
-  const relative = path.relative(root, candidate)
-  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))
-}
-
-function isSpecSourceFile(absolutePath, specRootAbsolute) {
-  if (!isSubpath(absolutePath, specRootAbsolute)) {
-    return false
-  }
-
-  return absolutePath.endsWith(".spec.ts")
-    || absolutePath.endsWith(".spec.tsx")
-}
-
-async function findSpecSourceFiles(projectRoot) {
-  const patterns = ["spec/**/*.spec.ts", "spec/**/*.spec.tsx"]
-  const matches = await fg(patterns, { cwd: projectRoot, absolute: true, onlyFiles: true })
-  return matches.sort()
-}
-
-function resolvePlaywrightSpecFile(specProjectPath) {
-  const buildSpecRoot = path.join(process.cwd(), "build", "spec")
-  const isBuildSpecProject = fs.existsSync(buildSpecRoot)
-
-  if (!isBuildSpecProject) {
-    return specProjectPath
-  }
-
-  const builtCandidate = normalizeBuiltSpecPath(path.join("build", specProjectPath))
-  const builtAbsolute = path.resolve(process.cwd(), builtCandidate)
-  if (!fs.existsSync(builtAbsolute)) {
-    throw new Error(`[specs-map] Missing built spec file: ${builtCandidate}`)
-  }
-
-  return builtCandidate
-}
-
-function normalizeBuiltSpecPath(filePath) {
-  if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) {
-    return `${filePath.replace(/\.tsx?$/, "")}.js`
-  }
-  return filePath
-}
-
-function toPosixPath(input) {
-  return String(input ?? "").split(path.sep).join("/")
-}
-
-function findWorkspaceRoot(projectRoot) {
-  let dir = path.resolve(projectRoot)
-
-  while (true) {
-    const pkgPath = path.join(dir, "package.json")
-    try {
-      if (fs.existsSync(pkgPath)) {
-        const parsed = JSON.parse(fs.readFileSync(pkgPath, "utf8"))
-        if (parsed && typeof parsed === "object" && parsed.workspaces) {
-          return dir
-        }
-      }
-    } catch {
-      //
-    }
-
-    const parent = path.dirname(dir)
-    if (parent === dir) {
-      return path.resolve(projectRoot)
-    }
-    dir = parent
-  }
-}
-
-function runPlaywright(userArgs, { disableCoverage = false } = {}) {
-  // Determine config file path
-  const configPath = fs.existsSync(
-    path.join(process.cwd(), "playwright.config.ts"),
-  )
-    ? path.join(process.cwd(), "playwright.config.ts")
-    : path.join(moduleDir, "playwright.config.ts")
-
-  const hasCustomConfig = userArgs.some((arg) => {
-    if (arg === "--config" || arg === "-c") {
-      return true
-    }
-
-    return arg.startsWith("--config=")
-  })
-
-  const playwrightArgs = ["test"]
-
-  if (!hasCustomConfig) {
-    playwrightArgs.push("--config", configPath)
-  }
-
-  playwrightArgs.push(...userArgs)
-
-  ensureJsxRuntimeShim(process.cwd())
-  const launcher = resolvePlaywrightLauncher()
-  const env = withRegisterShim(process.env)
-  env[COMBINED_COVERAGE_ENV_VAR] = "1"
-  if (disableCoverage) {
-    env.RB_DISABLE_COVERAGE = "1"
-  }
-
-  return spawnWithLogs({
-    name: "Playwright",
-    launcher,
-    args: playwrightArgs,
-    env,
-    successMessage: "Playwright suite passed!",
-    failureMessage: "Playwright failed",
-  })
-}
-
-function resolvePlaywrightLauncher() {
-  const cliPath = resolveCliPath()
-  if (cliPath) {
-    return {
-      command: process.execPath,
-      args: [cliPath],
-    }
-  }
-
-  const localBin = path.resolve(process.cwd(), "node_modules/.bin/playwright")
-  if (fs.existsSync(localBin)) {
-    return {
-      command: localBin,
-      args: [],
-    }
-  }
-
-  return {
-    command: "playwright",
-    args: [],
-  }
-}
-
-function resolveCliPath() {
-  const searchRoots = [process.cwd(), moduleDir]
-
-  for (const base of searchRoots) {
-    try {
-      const pkgPath = require.resolve("@playwright/test/package.json", { paths: [base] })
-      const cliPath = path.join(path.dirname(pkgPath), "cli.js")
-      if (fs.existsSync(cliPath)) {
-        return cliPath
-      }
-    } catch (_error) {
-      // continue searching
-    }
-  }
-
-  return null
-}
-
-function resolveVitestLauncher() {
-  const searchRoots = [process.cwd(), moduleDir]
-
-  for (const base of searchRoots) {
-    try {
-      const pkgPath = require.resolve("vitest/package.json", { paths: [base] })
-      const pkgDir = path.dirname(pkgPath)
-      const pkgJson = JSON.parse(fs.readFileSync(pkgPath, "utf8"))
-      const binPath = typeof pkgJson.bin === "string" ? pkgJson.bin : pkgJson.bin?.vitest
-      if (binPath) {
-        return {
-          command: process.execPath,
-          args: [path.join(pkgDir, binPath)],
-        }
-      }
-    } catch (_error) {
-      // continue searching
-    }
-  }
-
-  const localBin = path.resolve(process.cwd(), "node_modules/.bin/vitest")
-  if (fs.existsSync(localBin)) {
-    return {
-      command: localBin,
-      args: [],
-    }
-  }
-
-  return {
-    command: "vitest",
-    args: [],
-  }
-}
-
-function resolveVitestConfig() {
-  const userConfig = findVitestConfig(process.cwd())
-  if (userConfig) {
-    return userConfig
-  }
-
-  const bundledConfig = path.join(moduleDir, "vitest.config.mjs")
-  return fs.existsSync(bundledConfig) ? bundledConfig : null
-}
-
-function findVitestConfig(baseDir) {
-  const candidates = [
-    "vitest.config.ts",
-    "vitest.config.js",
-    "vitest.config.mjs",
-  ]
-
-  for (const file of candidates) {
-    const fullPath = path.join(baseDir, file)
-    if (fs.existsSync(fullPath)) {
-      return fullPath
-    }
-  }
-
-  return null
-}
-
-async function loadVitestCoverageConfig() {
-  const options = await loadCoverageOptions({
-    optional: true,
-    candidates: VITEST_COVERAGE_CANDIDATES,
-    defaultTestResultsDir: "test-results-vitest",
-  })
-  if (!options) {
-    return null
-  }
-
-  const config = createCoverageConfig(options)
-
-  return {
-    config,
-    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")) {
-      continue
-    }
-
-    const fullPath = path.join(nodeCoverageDir, entry)
-    const payload = await readJson(fullPath)
-    const results = Array.isArray(payload?.result) ? payload.result : []
-
-    for (const script of results) {
-      const normalized = normalizeNodeScriptUrl(script.url, config.rootDir)
-      if (!normalized) {
-        continue
-      }
-
-      if (isNodeModulesPath(normalized.absolutePath)) {
-        continue
-      }
-
-      if (!isInsideAnyRoot(normalized.absolutePath, scriptRoots)) {
-        continue
-      }
-
-      const source = await fsPromises.readFile(normalized.absolutePath, "utf8").catch(() => "")
-
-      scripts.push({
-        absolutePath: normalized.absolutePath,
-        relativePath: normalized.relativePath,
-        source,
-        functions: script.functions ?? [],
-        url: script.url,
-      })
-    }
-  }
-
-  if (scripts.length === 0) {
-    return
-  }
-
-  const outDir = path.join(config.testResultsRoot, "vitest")
-  await fsPromises.mkdir(outDir, { recursive: true })
-  const outputFile = path.join(outDir, config.coverageFileName)
-  await fsPromises.writeFile(outputFile, JSON.stringify({ testId: "vitest", scripts }, null, 2), "utf8")
-}
-
-async function finalizeCoverage(config) {
-  try {
-    await generateCoverageReport(config)
-  } catch (error) {
-    if (error instanceof CoverageThresholdError) {
-      console.error(error.message)
-    }
-    throw error
-  }
-}
-
-async function readJson(filePath) {
-  try {
-    const raw = await fsPromises.readFile(filePath, "utf8")
-    return JSON.parse(raw)
-  } catch {
-    return null
-  }
-}
-
-function normalizeNodeScriptUrl(rawUrl, rootDir) {
-  if (!rawUrl || rawUrl.startsWith("node:")) {
-    return null
-  }
-
-  let absolutePath = null
-
-  try {
-    if (rawUrl.startsWith("file://")) {
-      absolutePath = fileURLToPath(rawUrl)
-    }
-  } catch (_err) {
-    // ignore invalid URLs
-  }
-
-  if (!absolutePath && path.isAbsolute(rawUrl)) {
-    absolutePath = rawUrl
-  }
-
-  if (!absolutePath) {
-    return null
-  }
-
-  const normalized = path.normalize(absolutePath)
-
-  return {
-    absolutePath: normalized,
-    relativePath: path.relative(rootDir, normalized),
-  }
-}
-
-function isNodeModulesPath(filePath) {
-  return path
-    .normalize(String(filePath ?? ""))
-    .split(path.sep)
-    .includes("node_modules")
-}
-
-function spawnWithLogs({ name, launcher, args, env, successMessage, failureMessage }) {
-  return new Promise((resolve, reject) => {
-    const stdoutBuffer = []
-    const stderrBuffer = []
-
-    const child = spawn(
-      launcher.command,
-      [...(launcher.args || []), ...args],
-      {
-        shell: false,
-        env,
-      },
-    )
-
-    child.stdout.on("data", (data) => {
-      if (!isAider) {
-        process.stdout.write(data)
-      }
-      stdoutBuffer.push(data.toString())
-    })
-
-    child.stderr.on("data", (data) => {
-      if (!isAider) {
-        process.stderr.write(data)
-      }
-      stderrBuffer.push(data.toString())
-    })
-
-    child.on("close", (code) => {
-      if (code === 0) {
-        if (successMessage) {
-          console.log(successMessage)
-        }
-        resolve()
-      } else {
-        console.error(failureMessage || `${name} failed:`)
-
-        if (isAider) {
-          if (stdoutBuffer.length > 0) {
-            console.error(stdoutBuffer.join(""))
-          }
-
-          if (stderrBuffer.length > 0) {
-            console.error(stderrBuffer.join(""))
-          }
-        }
-
-        reject(new Error(`${name} failed with exit code: ${code}`))
-      }
-    })
-
-    child.on("error", (error) => {
-      console.error(`Error spawning ${name}:`, error)
-      reject(error)
-    })
-  })
-}
-
-function withRegisterShim(baseEnv) {
-  const nodeOptions = appendNodeRequire(baseEnv.NODE_OPTIONS, path.join(moduleDir, "register-tty.cjs"))
-  return {
-    ...baseEnv,
-    NODE_OPTIONS: nodeOptions,
-  }
-}
-
-function ensureJsxRuntimeShim(projectRoot) {
-  const shimDir = path.join(projectRoot, "node_modules", "playwright")
-  fs.mkdirSync(shimDir, { recursive: true })
-  const shims = [
-    { file: "jsx-runtime.js", target: "react/jsx-runtime" },
-    { file: "jsx-dev-runtime.js", target: "react/jsx-dev-runtime" },
-  ]
-
-  for (const { file, target } of shims) {
-    const filePath = path.join(shimDir, file)
-    if (!fs.existsSync(filePath)) {
-      const content = `export * from "${target}";\nexport { default } from "${target}";\n`
-      fs.writeFileSync(filePath, content, "utf8")
-    }
-  }
-}
-
-function appendNodeRequire(existing, modulePath) {
-  const flag = `--require=${modulePath}`
-  if (!existing || existing.length === 0) {
-    return flag
-  }
-  return `${existing} ${flag}`
-}