@swedevtools/livedoc-vitest 0.2.0 → 0.3.0

package/dist/reporter/index.js

@@ -1,7 +1,7 @@
 import chalk, { Chalk } from 'chalk';
-import { existsSync, unlinkSync, appendFileSync, mkdirSync, writeFileSync, promises } from 'fs';
-import * as path from 'path';
-import { resolve, dirname } from 'path';
+import { existsSync, unlinkSync, appendFileSync, mkdirSync, writeFileSync, promises, statSync, readFileSync } from 'fs';
+import * as path2 from 'path';
+import path2__default, { resolve, dirname } from 'path';
 import CliTable3 from 'cli-table3';
 import * as diff from 'diff';
 import wordwrap from 'wordwrap';
@@ -1287,9 +1287,9 @@ var LiveDocReporter = class {
     if (!strs || strs.length === 0)
       return "";
     if (strs.length === 1)
-      return path.dirname(strs[0]);
+      return path2.dirname(strs[0]);
     for (let i = 0; i < strs.length; i++) {
-      strs[i] = path.dirname(strs[i]);
+      strs[i] = path2.dirname(strs[i]);
     }
     let shortestString = "";
     let shortestLength = Number.MAX_SAFE_INTEGER;
@@ -1327,8 +1327,8 @@ var LiveDocReporter = class {
     if (rootPath.length === 0 || stripPath === "") {
       return "";
     } else {
-      let dirPath = path.parse(stripPath).dir;
-      if (dirPath.startsWith(path.sep)) {
+      let dirPath = path2.parse(stripPath).dir;
+      if (dirPath.startsWith(path2.sep)) {
         return dirPath.substr(1);
       } else {
         return dirPath;
@@ -1548,6 +1548,9 @@ var LiveDocSpec = class _LiveDocSpec extends LiveDocReporter {
   }
   outputSpecificationDetails(spec) {
     this.writeLine(this.formatKeywordTitle("Specification", spec.title, this.colorTheme.keyword, this.colorTheme.featureTitle, 2));
+    if (spec.tags.length > 0) {
+      this.writeLine(this.applyBlockIndent(this.formatTags(spec.tags), 4));
+    }
     if (spec.description) {
       this.writeLine(this.formatDescription(spec.description, 4, this.colorTheme.featureDescription));
     }
@@ -1557,6 +1560,9 @@ var LiveDocSpec = class _LiveDocSpec extends LiveDocReporter {
         const status = this.getStatusIndicator(rule.status);
         const title = this.highlight(rule.title, /<[^>]+>/g, this.colorTheme.valuePlaceholders);
         this.writeLine(`    ${status} ${this.colorTheme.keyword("Rule Outline:")} ${this.colorTheme.scenarioTitle(title)}`);
+        if (rule.tags.length > 0) {
+          this.writeLine(this.applyBlockIndent(this.formatTags(rule.tags), 6));
+        }
         if (rule.description) {
           this.writeLine(this.formatDescription(rule.description, 6, this.colorTheme.scenarioDescription));
         }
@@ -1585,6 +1591,9 @@ var LiveDocSpec = class _LiveDocSpec extends LiveDocReporter {
       } else {
         const status = this.getStatusIndicator(rule.status);
         this.writeLine(`    ${status} ${this.colorTheme.keyword("Rule:")} ${this.colorTheme.stepTitle(rule.title)}`);
+        if (rule.tags.length > 0) {
+          this.writeLine(this.applyBlockIndent(this.formatTags(rule.tags), 6));
+        }
       }
     }
     this.writeLine(" ");
@@ -2897,8 +2906,8 @@ function getErrorMap() {
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path3, errorMaps, issueData } = params;
-  const fullPath = [...path3, ...issueData.path || []];
+  const { data, path: path4, errorMaps, issueData } = params;
+  const fullPath = [...path4, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -3014,11 +3023,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path3, key) {
+  constructor(parent, value, path4, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path3;
+    this._path = path4;
     this._key = key;
   }
   get path() {
@@ -6470,9 +6479,9 @@ function simpleHash(str) {
   return Math.abs(hash).toString(36);
 }
 function generateStabilityId(params) {
-  const { project, path: path3, title, kind, parentId, keyword, index } = params;
+  const { project, path: path4, title, kind, parentId, keyword, index } = params;
   if (!parentId) {
-    return simpleHash(`${project}:${path3 || ""}:${title}`);
+    return simpleHash(`${project}:${path4 || ""}:${title}`);
   }
   if (kind === "Step") {
     return `${parentId}:${simpleHash(`${keyword || ""}:${title}:${index ?? 0}`)}`;
@@ -6538,6 +6547,53 @@ var V1StatisticsSchema = external_exports.object({
   pending: external_exports.number().int().nonnegative(),
   skipped: external_exports.number().int().nonnegative()
 });
+var V1CoverageMetricNameSchema = external_exports.enum(["lines", "branches", "functions", "statements"]);
+var V1CoverageMetricSchema = external_exports.object({
+  covered: external_exports.number().nonnegative(),
+  total: external_exports.number().nonnegative(),
+  skipped: external_exports.number().nonnegative().optional(),
+  pct: external_exports.number().min(0).max(100).nullable()
+});
+var V1CoverageSummarySchema = external_exports.object({
+  lines: V1CoverageMetricSchema.optional(),
+  branches: V1CoverageMetricSchema.optional(),
+  functions: V1CoverageMetricSchema.optional(),
+  statements: V1CoverageMetricSchema.optional()
+});
+var V1CoverageProvenanceSchema = external_exports.object({
+  tool: external_exports.string().optional(),
+  format: external_exports.string(),
+  path: external_exports.string().optional(),
+  detected: external_exports.enum(["auto", "configured"]),
+  generatedAt: external_exports.string().optional()
+});
+var V1CoverageFileSchema = external_exports.object({
+  path: external_exports.string(),
+  module: external_exports.string().optional(),
+  summary: V1CoverageSummarySchema,
+  detailRef: external_exports.string().optional()
+});
+var V1CoverageDiagnosticSchema = external_exports.object({
+  severity: external_exports.enum(["info", "warning", "error"]),
+  code: external_exports.string(),
+  message: external_exports.string(),
+  path: external_exports.string().optional(),
+  details: external_exports.array(external_exports.string()).optional()
+});
+var V1CoverageThresholdSchema = external_exports.object({
+  metric: V1CoverageMetricNameSchema,
+  minimum: external_exports.number().min(0).max(100),
+  actual: external_exports.number().min(0).max(100).nullable(),
+  status: external_exports.enum(["passed", "warning"])
+});
+var V1CoverageReportSchema = external_exports.object({
+  status: external_exports.enum(["available", "not-collected", "partial", "invalid"]),
+  summary: V1CoverageSummarySchema.optional(),
+  files: external_exports.array(V1CoverageFileSchema).optional(),
+  diagnostics: external_exports.array(V1CoverageDiagnosticSchema).optional(),
+  provenance: V1CoverageProvenanceSchema.optional(),
+  thresholds: external_exports.array(V1CoverageThresholdSchema).optional()
+});
 var V1BaseTestSchema = external_exports.object({
   id: external_exports.string(),
   kind: external_exports.string(),
@@ -6601,10 +6657,12 @@ var V1TestCaseSchema = external_exports.object({
   ruleViolations: external_exports.array(V1RuleViolationSchema).optional()
 });
 var V1FrameworkSchema = external_exports.string();
+var V1RunTypeSchema = external_exports.enum(["full", "partial"]);
 external_exports.object({
   protocolVersion: external_exports.literal("1.0"),
   runId: external_exports.string(),
-  sessionId: external_exports.string().optional(),
+  runType: V1RunTypeSchema.optional(),
+  baselineRunId: external_exports.string().optional(),
   project: external_exports.string(),
   environment: external_exports.string(),
   framework: V1FrameworkSchema,
@@ -6612,18 +6670,19 @@ external_exports.object({
   duration: external_exports.number().nonnegative(),
   status: V1StatusSchema,
   summary: V1StatisticsSchema,
-  documents: external_exports.array(V1TestCaseSchema)
+  documents: external_exports.array(V1TestCaseSchema),
+  coverage: V1CoverageReportSchema.optional()
 });
 external_exports.object({
   project: external_exports.string(),
   environment: external_exports.string(),
   framework: external_exports.string(),
-  timestamp: external_exports.string().optional()
+  timestamp: external_exports.string().optional(),
+  runType: V1RunTypeSchema.optional()
 });
 external_exports.object({
   protocolVersion: external_exports.literal("1.0"),
   runId: external_exports.string(),
-  sessionId: external_exports.string().optional(),
   websocketUrl: external_exports.string()
 });
 external_exports.object({
@@ -6634,7 +6693,8 @@ external_exports.object({
   complete: external_exports.object({
     status: V1StatusSchema,
     duration: external_exports.number().nonnegative(),
-    summary: V1StatisticsSchema.optional()
+    summary: V1StatisticsSchema.optional(),
+    coverage: V1CoverageReportSchema.optional()
   }).optional()
 });
 external_exports.object({
@@ -6663,31 +6723,17 @@ var V1UpsertOutlineExampleResultsRequestSchema = external_exports.object({
 external_exports.object({
   status: V1StatusSchema,
   duration: external_exports.number().nonnegative(),
-  summary: V1StatisticsSchema.optional()
-});
-var V1SessionRunInfoSchema = external_exports.object({
-  runId: external_exports.string(),
-  framework: external_exports.string(),
-  status: V1StatusSchema,
-  timestamp: external_exports.string(),
-  duration: external_exports.number().nonnegative(),
-  summary: V1StatisticsSchema,
-  documentCount: external_exports.number().int().nonnegative()
+  summary: V1StatisticsSchema.optional(),
+  coverage: V1CoverageReportSchema.optional()
 });
 external_exports.object({
-  sessionId: external_exports.string(),
-  project: external_exports.string(),
-  environment: external_exports.string(),
-  status: V1StatusSchema,
-  timestamp: external_exports.string(),
-  duration: external_exports.number().nonnegative(),
-  summary: V1StatisticsSchema,
-  runs: external_exports.array(V1SessionRunInfoSchema),
-  documents: external_exports.array(V1TestCaseSchema)
+  coverage: V1CoverageReportSchema
 });
 var V1WsRunStartedSchema = external_exports.object({
   type: external_exports.literal("run:v1:started"),
   runId: external_exports.string(),
+  runType: V1RunTypeSchema.optional(),
+  baselineRunId: external_exports.string().optional(),
   project: external_exports.string(),
   environment: external_exports.string(),
   framework: external_exports.string(),
@@ -6721,15 +6767,13 @@ var V1WsRunCompletedSchema = external_exports.object({
   runId: external_exports.string(),
   status: V1StatusSchema,
   duration: external_exports.number().nonnegative(),
-  summary: V1StatisticsSchema
+  summary: V1StatisticsSchema,
+  coverage: V1CoverageReportSchema.optional()
 });
-var V1WsSessionUpdatedSchema = external_exports.object({
-  type: external_exports.literal("session:v1:updated"),
-  sessionId: external_exports.string(),
-  project: external_exports.string(),
-  environment: external_exports.string(),
-  status: V1StatusSchema,
-  summary: V1StatisticsSchema
+var V1WsRunCoverageSchema = external_exports.object({
+  type: external_exports.literal("run:v1:coverage"),
+  runId: external_exports.string(),
+  coverage: V1CoverageReportSchema
 });
 external_exports.union([
   V1WsRunStartedSchema,
@@ -6738,19 +6782,360 @@ external_exports.union([
   V1WsTestExecutionSchema,
   V1WsOutlineExampleResultsSchema,
   V1WsRunCompletedSchema,
-  V1WsSessionUpdatedSchema
+  V1WsRunCoverageSchema
 ]);
+var metricNames = ["lines", "branches", "functions", "statements"];
+function collectCoverageReport(options = {}) {
+  const envEnabled = parseBoolean(process.env.LIVEDOC_COVERAGE);
+  const configuredPath = firstNonEmpty(options.artifactPath, process.env.LIVEDOC_COVERAGE_PATH);
+  const thresholds = resolveThresholds(options.thresholds);
+  const rootDir = path2__default.resolve(options.rootDir || process.cwd());
+  const reportsDirectory = options.reportsDirectory ? resolvePath(rootDir, options.reportsDirectory) : void 0;
+  const explicit = envEnabled === true || options.enabled === true || !!configuredPath;
+  if (options.coverageMap !== void 0) {
+    try {
+      const report = parseIstanbulCoverageMap(options.coverageMap, rootDir);
+      const applied = applyThresholds(report, thresholds);
+      return {
+        ...applied,
+        provenance: {
+          tool: "vitest",
+          format: "istanbul-coverage-map",
+          detected: "auto",
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+    } catch (error) {
+      return diagnosticReport(
+        "parse-failed",
+        "warning",
+        `LiveDoc could not parse Vitest's in-memory coverage map: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  const candidates = findCandidates(rootDir, reportsDirectory, configuredPath);
+  if (candidates.length === 0) {
+    return explicit ? diagnosticReport("artifact-missing", "warning", "Coverage was enabled, but LiveDoc could not find a supported coverage artifact.") : void 0;
+  }
+  const stale = [];
+  for (const candidate of candidates) {
+    if (!existsSync(candidate.path)) continue;
+    let fileStats;
+    try {
+      fileStats = statSync(candidate.path);
+    } catch (error) {
+      return diagnosticReport(
+        "parse-failed",
+        "warning",
+        `LiveDoc could not read the coverage artifact metadata: ${error instanceof Error ? error.message : String(error)}`,
+        candidate.path
+      );
+    }
+    const generatedAt = fileStats.mtime.toISOString();
+    if (isStale(fileStats, options.runStartedAt)) {
+      stale.push({
+        severity: "warning",
+        code: "stale",
+        message: "LiveDoc found a coverage artifact, but it appears older than the current test run.",
+        path: candidate.path
+      });
+      if (candidate.detected === "configured") {
+        return { status: "invalid", diagnostics: stale };
+      }
+      continue;
+    }
+    if (candidate.format === "unsupported") {
+      return diagnosticReport(
+        "unsupported-format",
+        "warning",
+        `LiveDoc does not support this coverage artifact format yet: ${path2__default.basename(candidate.path)}.`,
+        candidate.path
+      );
+    }
+    try {
+      const report = candidate.format === "istanbul-json-summary" ? parseIstanbulSummary(candidate.path, rootDir) : parseLcov(candidate.path, rootDir);
+      const applied = applyThresholds(report, thresholds);
+      return {
+        ...applied,
+        provenance: {
+          tool: candidate.format === "lcov" ? "lcov" : "istanbul",
+          format: candidate.format,
+          path: candidate.path,
+          detected: candidate.detected,
+          generatedAt
+        }
+      };
+    } catch (error) {
+      return diagnosticReport(
+        "parse-failed",
+        "warning",
+        `LiveDoc could not parse the coverage artifact: ${error instanceof Error ? error.message : String(error)}`,
+        candidate.path
+      );
+    }
+  }
+  if (stale.length > 0 && explicit) {
+    return { status: "invalid", diagnostics: stale };
+  }
+  return void 0;
+}
+function parseIstanbulSummary(filePath, rootDir) {
+  const data = JSON.parse(readFileSync(filePath, "utf8"));
+  if (!isRecord(data)) {
+    throw new Error("Istanbul summary root must be an object.");
+  }
+  const total = data.total;
+  if (!isRecord(total)) {
+    throw new Error("Istanbul summary is missing the total coverage block.");
+  }
+  const files = Object.entries(data).filter(([key]) => key !== "total").map(([file, value]) => ({
+    path: normalizeCoveragePath(file, rootDir),
+    summary: normalizeSummary(value)
+  })).filter((file) => Object.keys(file.summary).length > 0);
+  return {
+    status: "available",
+    summary: normalizeSummary(total),
+    files
+  };
+}
+function parseIstanbulCoverageMap(value, rootDir) {
+  if (!isIstanbulCoverageMap(value)) {
+    throw new Error("Coverage value does not expose the Istanbul CoverageMap API.");
+  }
+  const files = value.files().map((file) => {
+    const fileCoverage = value.fileCoverageFor(file);
+    const summary = fileCoverage.toSummary().toJSON();
+    return {
+      path: normalizeCoveragePath(file, rootDir),
+      summary: normalizeSummary(summary)
+    };
+  }).filter((file) => Object.keys(file.summary).length > 0);
+  return {
+    status: "available",
+    summary: normalizeSummary(value.getCoverageSummary().toJSON()),
+    files
+  };
+}
+function parseLcov(filePath, rootDir) {
+  const text = readFileSync(filePath, "utf8");
+  const files = [];
+  let current;
+  const flush = () => {
+    if (!current?.path) return;
+    const lineValues = Array.from(current.lines.values());
+    const branchValues = current.branches;
+    const functionValues = Array.from(current.functions.values());
+    const summary = {
+      lines: metricFromHits(lineValues)
+    };
+    if (branchValues.length > 0) summary.branches = metricFromHits(branchValues);
+    if (functionValues.length > 0) summary.functions = metricFromHits(functionValues);
+    files.push({ path: normalizeCoveragePath(current.path, rootDir), summary });
+  };
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (line === "end_of_record") {
+      flush();
+      current = void 0;
+      continue;
+    }
+    if (line.startsWith("SF:")) {
+      flush();
+      current = { path: line.slice(3), lines: /* @__PURE__ */ new Map(), branches: [], functions: /* @__PURE__ */ new Map() };
+      continue;
+    }
+    if (!current) continue;
+    if (line.startsWith("DA:")) {
+      const [lineNumber, hits] = line.slice(3).split(",");
+      const parsedLine = Number(lineNumber);
+      const parsedHits = Number(hits);
+      if (Number.isFinite(parsedLine) && Number.isFinite(parsedHits)) current.lines.set(parsedLine, parsedHits);
+      continue;
+    }
+    if (line.startsWith("BRDA:")) {
+      const parts = line.slice(5).split(",");
+      const taken = parts[3] === "-" ? null : Number(parts[3]);
+      current.branches.push(Number.isFinite(taken) ? taken : null);
+      continue;
+    }
+    if (line.startsWith("FNDA:")) {
+      const [hits, name] = line.slice(5).split(",");
+      const parsedHits = Number(hits);
+      if (name && Number.isFinite(parsedHits)) current.functions.set(name, parsedHits);
+    }
+  }
+  flush();
+  return {
+    status: "available",
+    summary: aggregateSummaries(files.map((file) => file.summary)),
+    files
+  };
+}
+function metricFromHits(values) {
+  const total = values.length;
+  const covered = values.filter((value) => typeof value === "number" && value > 0).length;
+  return makeMetric(covered, total);
+}
+function normalizeSummary(value) {
+  const summary = {};
+  if (!isRecord(value)) return summary;
+  for (const metric of metricNames) {
+    const raw = value[metric];
+    if (!isRecord(raw)) continue;
+    const total = Number(raw.total);
+    const covered = Number(raw.covered);
+    const skipped = Number(raw.skipped);
+    const pct = raw.pct === "Unknown" || raw.pct === void 0 || raw.pct === null ? calculatePct(covered, total) : Number(raw.pct);
+    if (!Number.isFinite(total) || !Number.isFinite(covered)) continue;
+    summary[metric] = {
+      covered,
+      total,
+      skipped: Number.isFinite(skipped) ? skipped : void 0,
+      pct: Number.isFinite(pct) ? clampPct(pct) : calculatePct(covered, total)
+    };
+  }
+  return summary;
+}
+function aggregateSummaries(summaries) {
+  const aggregate = {};
+  for (const metric of metricNames) {
+    let covered = 0;
+    let total = 0;
+    let skipped = 0;
+    let hasMetric = false;
+    for (const summary of summaries) {
+      const value = summary[metric];
+      if (!value) continue;
+      covered += value.covered;
+      total += value.total;
+      skipped += value.skipped ?? 0;
+      hasMetric = true;
+    }
+    if (hasMetric) aggregate[metric] = { ...makeMetric(covered, total), skipped };
+  }
+  return aggregate;
+}
+function applyThresholds(report, thresholds) {
+  const entries = Object.entries(thresholds);
+  if (entries.length === 0) return report;
+  const diagnostics = [...report.diagnostics ?? []];
+  const applied = entries.map(([metric, minimum]) => {
+    const actual = report.summary?.[metric]?.pct ?? null;
+    const status = actual !== null && actual < minimum ? "warning" : "passed";
+    if (status === "warning") {
+      diagnostics.push({
+        severity: "warning",
+        code: "threshold-warning",
+        message: `${metric} coverage is ${actual?.toFixed(1)}%, below the configured ${minimum}% threshold.`
+      });
+    }
+    return { metric, minimum, actual, status };
+  });
+  return {
+    ...report,
+    thresholds: applied,
+    diagnostics: diagnostics.length > 0 ? diagnostics : void 0
+  };
+}
+function findCandidates(rootDir, reportsDirectory, configuredPath) {
+  const candidates = [];
+  const add = (candidatePath, detected) => {
+    if (!candidatePath) return;
+    const resolved = resolvePath(rootDir, candidatePath);
+    if (candidates.some((candidate) => candidate.path.toLowerCase() === resolved.toLowerCase())) return;
+    candidates.push({ path: resolved, format: detectFormat(resolved), detected });
+  };
+  add(configuredPath, "configured");
+  add(reportsDirectory ? path2__default.join(reportsDirectory, "coverage-summary.json") : void 0, "auto");
+  add(reportsDirectory ? path2__default.join(reportsDirectory, "lcov.info") : void 0, "auto");
+  add(path2__default.join(rootDir, "coverage", "coverage-summary.json"), "auto");
+  add(path2__default.join(rootDir, "coverage", "lcov.info"), "auto");
+  add(path2__default.join(process.cwd(), "coverage", "coverage-summary.json"), "auto");
+  add(path2__default.join(process.cwd(), "coverage", "lcov.info"), "auto");
+  return candidates.filter((candidate) => existsSync(candidate.path) || candidate.detected === "configured");
+}
+function detectFormat(filePath) {
+  const normalized = filePath.replace(/\\/g, "/").toLowerCase();
+  if (normalized.endsWith("/coverage-summary.json") || normalized.endsWith("\\coverage-summary.json")) return "istanbul-json-summary";
+  if (normalized.endsWith(".info") || normalized.endsWith(".lcov")) return "lcov";
+  return "unsupported";
+}
+function diagnosticReport(code, severity, message, filePath) {
+  return {
+    status: severity === "info" ? "not-collected" : "invalid",
+    diagnostics: [{ severity, code, message, path: filePath }]
+  };
+}
+function normalizeCoveragePath(filePath, rootDir) {
+  const absolute = path2__default.isAbsolute(filePath) ? path2__default.normalize(filePath) : path2__default.resolve(rootDir, filePath);
+  let relative = path2__default.relative(rootDir, absolute);
+  if (!relative || relative.startsWith("..")) relative = filePath;
+  return relative.replace(/\\/g, "/").replace(/^\.\/+/, "");
+}
+function makeMetric(covered, total) {
+  return { covered, total, pct: calculatePct(covered, total) };
+}
+function calculatePct(covered, total) {
+  if (!Number.isFinite(total) || total <= 0) return null;
+  return clampPct(covered / total * 100);
+}
+function clampPct(value) {
+  return Math.max(0, Math.min(100, Math.round(value * 10) / 10));
+}
+function isStale(fileStats, runStartedAt) {
+  if (!runStartedAt || !Number.isFinite(runStartedAt)) return false;
+  return fileStats.mtimeMs + 2e3 < runStartedAt;
+}
+function resolveThresholds(configured) {
+  const thresholds = {};
+  for (const metric of metricNames) {
+    const fromOptions = configured?.[metric];
+    const fromEnv = process.env[`LIVEDOC_COVERAGE_THRESHOLD_${metric.toUpperCase()}`];
+    const parsed = Number(fromOptions ?? fromEnv);
+    if (Number.isFinite(parsed) && parsed >= 0 && parsed <= 100) thresholds[metric] = parsed;
+  }
+  return thresholds;
+}
+function parseBoolean(value) {
+  if (value === void 0) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  return void 0;
+}
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    const trimmed = value?.trim();
+    if (trimmed) return trimmed;
+  }
+  return void 0;
+}
+function resolvePath(rootDir, value) {
+  return path2__default.isAbsolute(value) ? path2__default.normalize(value) : path2__default.resolve(rootDir, value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isIstanbulCoverageMap(value) {
+  if (!isRecord(value)) return false;
+  return typeof value.getCoverageSummary === "function" && typeof value.files === "function" && typeof value.fileCoverageFor === "function";
+}
 
 // _src/app/reporter/LiveDocViewerReporterV1.ts
 var LiveDocViewerReporter = class {
   options;
+  hasExplicitRunType;
   constructor(options) {
+    this.hasExplicitRunType = options?.runType !== void 0;
     this.options = {
       server: options?.server || "http://localhost:3100",
-      project: options?.project || "default",
+      project: options?.project || "livedoc",
       environment: options?.environment || "local",
+      runType: this.parseRunType(options?.runType ?? process.env.LIVEDOC_RUN_TYPE),
       timeout: options?.timeout || 1e4,
-      silent: options?.silent ?? true
+      silent: options?.silent ?? true,
+      coverage: options?.coverage || {}
     };
   }
   async execute(results, rawOptions) {
@@ -6776,7 +7161,7 @@ var LiveDocViewerReporter = class {
         const testCase = this.buildSuiteTestCase(suite, pathContext);
         await this.upsertTestCase(runId, testCase);
       }
-      await this.completeRun(runId, results);
+      await this.completeRun(runId, results, rawOptions);
     } catch (error) {
       if (!this.options.silent) {
         console.error("LiveDocViewerReporter error:", error);
@@ -6789,6 +7174,11 @@ var LiveDocViewerReporter = class {
    */
   buildTestRun(results, rawOptions) {
     this.applyRawOptions(rawOptions);
+    if (this.options.runType === "partial") {
+      throw new Error(
+        "partial-export-unsupported: Partial runs require server history and cannot be exported directly."
+      );
+    }
     const pathContext = this.buildPathContext(results);
     const documents = [];
     for (const feature of results.features) {
@@ -6802,6 +7192,7 @@ var LiveDocViewerReporter = class {
     }
     const { summary, duration } = this.calculateSummary(results);
     const status = this.calculateOverallStatus(results);
+    const coverage = this.collectCoverage(rawOptions);
     return {
       protocolVersion: "1.0",
       runId: randomUUID(),
@@ -6812,7 +7203,8 @@ var LiveDocViewerReporter = class {
       duration,
       status,
       summary,
-      documents
+      documents,
+      ...coverage ? { coverage } : {}
     };
   }
   async startRunSession(rawOptions) {
@@ -6851,22 +7243,44 @@ var LiveDocViewerReporter = class {
     if (rawOptions?.["viewer-environment"]) {
       this.options.environment = rawOptions["viewer-environment"];
     }
+    if (!this.hasExplicitRunType && rawOptions?.["viewer-run-type"]) {
+      this.options.runType = this.parseRunType(rawOptions["viewer-run-type"]);
+    }
     if (rawOptions?.["viewer-timeout"] !== void 0) {
       const parsed = Number(rawOptions["viewer-timeout"]);
       if (Number.isFinite(parsed) && parsed > 0) {
         this.options.timeout = parsed;
       }
     }
+    const coverage = rawOptions?.coverage;
+    if (coverage && typeof coverage === "object") {
+      this.options.coverage = {
+        ...this.options.coverage,
+        enabled: coverage.enabled ?? this.options.coverage.enabled,
+        path: coverage.path ?? coverage.artifactPath ?? this.options.coverage.path,
+        thresholds: coverage.thresholds ?? this.options.coverage.thresholds
+      };
+    }
+    if (rawOptions?.["coverage-path"]) {
+      this.options.coverage.path = String(rawOptions["coverage-path"]);
+    }
   }
   async startRun() {
     const request = {
       project: this.options.project,
       environment: this.options.environment,
-      framework: "vitest"
+      framework: "vitest",
+      runType: this.options.runType
     };
     const response = await this.post("/api/v1/runs/start", request);
     return response?.runId || null;
   }
+  parseRunType(value) {
+    if (value === void 0 || value === null || value === "") return "full";
+    const normalized = typeof value === "string" ? value.trim().toLowerCase() : value;
+    if (normalized === "full" || normalized === "partial") return normalized;
+    throw new Error(`Invalid LiveDoc run type '${String(value)}'. Expected 'full' or 'partial'.`);
+  }
   async upsertTestCase(runId, testCase) {
     await this.post(`/api/v1/runs/${runId}/testcases`, { testCase });
   }
@@ -6881,7 +7295,7 @@ var LiveDocViewerReporter = class {
     for (const s of results.suites || []) {
       if (s?.filename) filenames.push(s.filename);
     }
-    const abs = filenames.filter(Boolean).map((p) => path.isAbsolute(p) ? p : path.resolve(process.cwd(), p)).map((p) => p.replace(/\\/g, "/"));
+    const abs = filenames.filter(Boolean).map((p) => path2.isAbsolute(p) ? p : path2.resolve(process.cwd(), p)).map((p) => p.replace(/\\/g, "/"));
     const rootPath = this.findCommonRootPath(abs);
     return { rootPath };
   }
@@ -6903,7 +7317,7 @@ var LiveDocViewerReporter = class {
   }
   buildFileInfo(filename, rootPath) {
     const raw = filename || "";
-    const abs = raw ? path.isAbsolute(raw) ? raw : path.resolve(process.cwd(), raw) : "";
+    const abs = raw ? path2.isAbsolute(raw) ? raw : path2.resolve(process.cwd(), raw) : "";
     const normalized = abs.replace(/\\/g, "/");
     const root = (rootPath || "").replace(/\\/g, "/").replace(/\/+$/g, "");
     if (!normalized) {
@@ -7457,16 +7871,31 @@ Actual: ${step.exception.actual}` : void 0)
     if (value instanceof Date) return { value: value.toISOString(), type: "date" };
     return { value, type: "object" };
   }
-  async completeRun(runId, results) {
+  async completeRun(runId, results, rawOptions) {
     const { summary, duration } = this.calculateSummary(results);
     const overallStatus = this.calculateOverallStatus(results);
+    const coverage = this.collectCoverage(rawOptions);
     const request = {
       status: overallStatus,
       duration,
-      summary
+      summary,
+      ...coverage ? { coverage } : {}
     };
     await this.post(`/api/v1/runs/${runId}/complete`, request);
   }
+  collectCoverage(rawOptions) {
+    const context = rawOptions?.coverageContext ?? {};
+    const options = {
+      enabled: this.options.coverage.enabled ?? context.enabled,
+      coverageMap: context.coverageMap,
+      artifactPath: this.options.coverage.path ?? context.artifactPath,
+      rootDir: context.rootDir,
+      reportsDirectory: context.reportsDirectory,
+      runStartedAt: context.runStartedAt,
+      thresholds: this.options.coverage.thresholds ?? context.thresholds
+    };
+    return collectCoverageReport(options);
+  }
   mapStatus(status) {
     switch (status) {
       case "pass" /* pass */:
@@ -7838,6 +8267,7 @@ var LiveDocSpecReporter = class {
   liveDocSpec;
   options;
   exportConfig = null;
+  coverageContext = { runStartedAt: Date.now() };
   streamEnabled = true;
   taskById = /* @__PURE__ */ new Map();
   streamedStates = /* @__PURE__ */ new Map();
@@ -7864,6 +8294,7 @@ var LiveDocSpecReporter = class {
       livedoc.options.publish.server = options.publish.server ?? livedoc.options.publish.server;
       livedoc.options.publish.project = options.publish.project ?? livedoc.options.publish.project;
       livedoc.options.publish.environment = options.publish.environment ?? livedoc.options.publish.environment;
+      livedoc.options.publish.runType = options.publish.runType ?? livedoc.options.publish.runType;
     }
     if (options.export) {
       this.exportConfig = {
@@ -7880,22 +8311,14 @@ var LiveDocSpecReporter = class {
     this.setLiveDocOptions(this.options);
   }
   async onInit(ctx) {
+    this.captureCoverageContext(ctx);
     this.liveDocSpec.executionStart();
-    if (!livedoc.options.publish.enabled) {
-      const envServerUrl = process.env.LIVEDOC_SERVER_URL || process.env.LIVEDOC_PUBLISH_SERVER;
-      if (envServerUrl) {
+    const envServerUrl = this.applyPublishEnvironmentOverrides();
+    if (!envServerUrl && !livedoc.options.publish.enabled) {
+      const serverInfo = await this.discoverLiveDocServer();
+      if (serverInfo) {
         livedoc.options.publish.enabled = true;
-        livedoc.options.publish.server = envServerUrl;
-      } else {
-        try {
-          const { discoverServer } = await import('@swedevtools/livedoc-server');
-          const serverInfo = await discoverServer();
-          if (serverInfo) {
-            livedoc.options.publish.enabled = true;
-            livedoc.options.publish.server = serverInfo.url;
-          }
-        } catch {
-        }
+        livedoc.options.publish.server = serverInfo.url;
       }
     }
     if (livedoc.options.publish.enabled) {
@@ -7907,6 +8330,102 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
 `);
     }
   }
+  onCoverage(coverageMap) {
+    this.coverageContext.coverageMap = coverageMap;
+  }
+  captureCoverageContext(ctx) {
+    const config = ctx?.config ?? {};
+    const coverage = config.coverage ?? {};
+    const rawOptions = this.options.rawOptions ?? {};
+    const reporterCoverage = rawOptions.coverage ?? {};
+    const rootDir = config.root || process.cwd();
+    const reportsDirectory = coverage.reportsDirectory ? resolve(rootDir, coverage.reportsDirectory) : void 0;
+    this.coverageContext = {
+      enabled: Boolean(coverage.enabled) || Boolean(reporterCoverage.enabled),
+      artifactPath: reporterCoverage.path ?? reporterCoverage.artifactPath,
+      rootDir,
+      reportsDirectory,
+      runStartedAt: Date.now(),
+      thresholds: reporterCoverage.thresholds
+    };
+  }
+  applyPublishEnvironmentOverrides() {
+    const envServerUrl = this.firstEnvironmentValue(
+      "LIVEDOC_SERVER_URL",
+      "LIVEDOC_PUBLISH_SERVER",
+      "LIVEDOC_VIEWER_SERVER"
+    );
+    const envProject = this.firstEnvironmentValue(
+      "LIVEDOC_PROJECT",
+      "LIVEDOC_PUBLISH_PROJECT",
+      "LIVEDOC_VIEWER_PROJECT"
+    );
+    const envEnvironment = this.firstEnvironmentValue(
+      "LIVEDOC_ENVIRONMENT",
+      "LIVEDOC_PUBLISH_ENV",
+      "LIVEDOC_VIEWER_ENV"
+    );
+    const envRunType = this.firstEnvironmentValue("LIVEDOC_RUN_TYPE");
+    if (envProject) {
+      livedoc.options.publish.project = envProject;
+    }
+    if (envEnvironment) {
+      livedoc.options.publish.environment = envEnvironment;
+    }
+    if (envRunType) {
+      const normalizedRunType = envRunType.toLowerCase();
+      if (normalizedRunType !== "full" && normalizedRunType !== "partial") {
+        throw new Error(
+          `Invalid LIVEDOC_RUN_TYPE value '${envRunType}'. Expected 'full' or 'partial'.`
+        );
+      }
+      livedoc.options.publish.runType = normalizedRunType;
+    }
+    if (envServerUrl) {
+      livedoc.options.publish.enabled = true;
+      livedoc.options.publish.server = envServerUrl;
+    }
+    return envServerUrl;
+  }
+  firstEnvironmentValue(...names) {
+    for (const name of names) {
+      const value = process.env[name]?.trim();
+      if (value) return value;
+    }
+    return void 0;
+  }
+  async discoverLiveDocServer() {
+    try {
+      const { discoverServer } = await import('@swedevtools/livedoc-server');
+      const serverInfo = await discoverServer();
+      if (serverInfo) return serverInfo;
+    } catch {
+    }
+    return await this.discoverDefaultLocalServer();
+  }
+  async discoverDefaultLocalServer() {
+    const defaultPort = 3100;
+    const defaultUrl = `http://localhost:${defaultPort}`;
+    if (await this.isLiveDocServerHealthy(defaultUrl)) {
+      return { url: defaultUrl, port: defaultPort };
+    }
+    return null;
+  }
+  async isLiveDocServerHealthy(serverUrl) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 500);
+    try {
+      const response = await fetch(`${serverUrl}/api/health`, {
+        headers: { "Connection": "close" },
+        signal: controller.signal
+      });
+      return response.ok;
+    } catch {
+      return false;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
   onCollected(files) {
     if (!this.streamEnabled) return;
     this.taskById.clear();
@@ -7970,30 +8489,34 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
         server: publishOptions.server,
         project: publishOptions.project,
         environment: publishOptions.environment,
+        runType: publishOptions.runType,
         silent: false
       });
-      const rawOptions = this.options.rawOptions || {};
-      if (!rawOptions.postReporters) {
-        rawOptions.postReporters = [];
+      const rawOptions2 = this.options.rawOptions || {};
+      if (!rawOptions2.postReporters) {
+        rawOptions2.postReporters = [];
       }
-      rawOptions.postReporters.push(viewerReporter);
+      rawOptions2.postReporters.push(viewerReporter);
     }
-    await this.liveDocSpec.executionEnd(results, this.options.rawOptions);
+    const rawOptions = this.options.rawOptions || {};
+    rawOptions.coverageContext = this.coverageContext;
+    await this.liveDocSpec.executionEnd(results, rawOptions);
     if (this.exportConfig) {
-      this.exportTestRunJson(results);
+      this.exportTestRunJson(results, rawOptions);
     }
   }
-  exportTestRunJson(results) {
+  exportTestRunJson(results, rawOptions) {
     const exportConfig = this.exportConfig;
     const outputPath = resolve(exportConfig.output);
-    const project = exportConfig.project || livedoc.options.publish.project || "default";
+    const project = exportConfig.project || livedoc.options.publish.project || "livedoc";
     const environment = exportConfig.environment || livedoc.options.publish.environment || (process.env.CI ? "ci" : "local");
     const converter = new LiveDocViewerReporter({
       project,
       environment,
+      runType: livedoc.options.publish.runType,
       silent: true
     });
-    const testRun = converter.buildTestRun(results);
+    const testRun = converter.buildTestRun(results, rawOptions);
     try {
       mkdirSync(dirname(outputPath), { recursive: true });
       const json = JSON.stringify(testRun, null, 2);
@@ -8016,9 +8539,15 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
       for (const suite of file.tasks || []) {
         if (suite.type === "suite") {
           if (suite.name.startsWith("Specification:")) {
-            specifications.push(this.buildSpecificationFromSuite(suite, file.filepath));
+            const specification = this.buildSpecificationFromSuite(suite, file.filepath);
+            if (specification.rules.length > 0) {
+              specifications.push(specification);
+            }
           } else if (suite.name.startsWith("Feature:")) {
-            features.push(this.buildFeatureFromSuite(suite, file.filepath));
+            const feature = this.buildFeatureFromSuite(suite, file.filepath);
+            if (feature.scenarios.length > 0) {
+              features.push(feature);
+            }
           } else {
             suites.push(this.buildVitestSuiteFromTask(suite, file.filepath));
           }
@@ -8063,6 +8592,7 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
     }
     for (const task of tasks) {
       if (task === backgroundSuite) continue;
+      if (!this.hasUnfilteredLiveDocLeaf(task)) continue;
       if (typeof task.name === "string" && task.name.startsWith("Scenario:")) {
         const exampleSuites = (task.tasks || []).filter(
           (t) => t.type === "suite" && t.name.startsWith("Example ")
@@ -8086,7 +8616,7 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
     scenarioOutline.description = parsed.description;
     scenarioOutline.tags = parsed.tags;
     const exampleSuites = (suite.tasks || []).filter(
-      (t) => t.type === "suite" && t.name.startsWith("Example ")
+      (t) => t.type === "suite" && t.name.startsWith("Example ") && this.hasUnfilteredLiveDocLeaf(t)
     );
     const firstExampleSuite = exampleSuites[0];
     const firstExampleLiveDoc = this.findFirstLiveDocStepMetaInSuite(firstExampleSuite);
@@ -8138,7 +8668,7 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
     background.tags = parsed.tags;
     const forcePending = suite?.mode === "skip" || suite?.mode === "todo";
     for (const task of suite.tasks || []) {
-      if (task.type === "test") {
+      if (task.type === "test" && !this.isFilteredOutTask(task)) {
         const step = this.buildStepFromTest(task, background, forcePending);
         background.addStep(step);
       }
@@ -8153,7 +8683,7 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
     scenario.tags = parsed.tags;
     const forcePending = suite?.mode === "skip" || suite?.mode === "todo";
     for (const task of suite.tasks || []) {
-      if (task.type === "test") {
+      if (task.type === "test" && !this.isFilteredOutTask(task)) {
         const step = this.buildStepFromTest(task, scenario, forcePending);
         scenario.addStep(step);
       }
@@ -8177,7 +8707,7 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
     example.example = this.sanitizeExampleKeys(metaExampleValues);
     example.exampleRaw = example.example;
     for (const task of suite.tasks || []) {
-      if (task.type === "test") {
+      if (task.type === "test" && !this.isFilteredOutTask(task)) {
         const step = this.buildStepFromTest(task, example, forcePending);
         example.addStep(step);
       }
@@ -8191,9 +8721,20 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
     if (!livedoc2 || typeof livedoc2 !== "object") return void 0;
     return livedoc2;
   }
+  isFilteredOutTask(task) {
+    return this.getLiveDocMetaFromTask(task)?.filter?.filteredOut === true;
+  }
+  hasUnfilteredLiveDocLeaf(task) {
+    if (task?.type === "test") {
+      const kind = this.getLiveDocMetaFromTask(task)?.kind;
+      return (kind === "step" || kind === "rule" || kind === "ruleExample") && !this.isFilteredOutTask(task);
+    }
+    return Array.isArray(task?.tasks) && task.tasks.some((child) => this.hasUnfilteredLiveDocLeaf(child));
+  }
   findFirstLiveDocStepMetaInSuite(suite) {
     const tasks = suite?.tasks || [];
     for (const task of tasks) {
+      if (this.isFilteredOutTask(task)) continue;
       if (task?.type !== "test") continue;
       const livedoc2 = this.getLiveDocMetaFromTask(task);
       if (livedoc2?.kind === "step") return livedoc2;
@@ -8381,8 +8922,10 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
     specification.tags = parsed.tags;
     specification.filename = filepath;
     for (const task of suite.tasks || []) {
+      if (!this.hasUnfilteredLiveDocLeaf(task)) continue;
       if (task.type === "suite") {
         const exampleTests = (task.tasks || []).filter((t) => {
+          if (this.isFilteredOutTask(t)) return false;
           if (t.type !== "test") return false;
           const meta = this.getLiveDocMetaFromTask(t);
           return meta?.kind === "ruleExample";
@@ -8391,6 +8934,7 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
           const ruleOutline = this.buildRuleOutlineFromSuite(task, specification);
           specification.rules.push(ruleOutline);
         }
+        if (this.isFilteredOutTask(task)) continue;
       } else if (task.type === "test") {
         if (task.name.startsWith("Rule:")) {
           const rule = this.buildRuleFromTest(task, specification);
@@ -8439,6 +8983,7 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
   buildRuleOutlineFromSuite(suite, specification) {
     const ruleOutline = new RuleOutline(specification);
     const exampleTests = (suite.tasks || []).filter((t) => {
+      if (this.isFilteredOutTask(t)) return false;
       if (t.type !== "test") return false;
       const meta = this.getLiveDocMetaFromTask(t);
       return meta?.kind === "ruleExample";