@swedevtools/livedoc-vitest 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,9 +1,10 @@
 import chalk3, { Chalk } from 'chalk';
 import { afterAll, it, describe, beforeAll, TestRunner } from 'vitest';
+import { AsyncLocalStorage } from 'async_hooks';
 import { fileURLToPath } from 'url';
-import * as path from 'path';
-import { dirname, resolve } from 'path';
-import { existsSync, unlinkSync, appendFileSync, mkdirSync, writeFileSync, promises } from 'fs';
+import * as path2 from 'path';
+import path2__default, { dirname, resolve } from 'path';
+import { existsSync, unlinkSync, appendFileSync, mkdirSync, writeFileSync, promises, statSync, readFileSync } from 'fs';
 import CliTable3 from 'cli-table3';
 import * as diff from 'diff';
 import wordwrap from 'wordwrap';
@@ -1565,10 +1566,12 @@ var FilterOptions = class {
 var PublishOptions = class {
   /** Server URL, e.g., 'http://localhost:3100' */
   server = "http://localhost:3100";
-  /** Project name (defaults to 'default') */
-  project = "default";
+  /** Project name (defaults to 'livedoc') */
+  project = "livedoc";
   /** Environment name (defaults to 'local') */
   environment = "local";
+  /** Whether the invocation reports the complete test inventory or a focused subset. */
+  runType = "full";
   /** Whether publishing is enabled */
   enabled = false;
 };
@@ -1682,6 +1685,7 @@ var currentStep = null;
 var scenarioCount = 0;
 var scenarioId = 0;
 var currentSpecification = null;
+var declarationContextStorage = new AsyncLocalStorage();
 var specificationRegistry = [];
 var afterBackgroundFnMap = /* @__PURE__ */ new Map();
 var backgroundStepsMap = /* @__PURE__ */ new Map();
@@ -1690,10 +1694,76 @@ var backgroundStepsComplete = false;
 var scenarioStartHooks = [];
 var scenarioEndHooks = [];
 var isPendingContext = false;
+var currentFilterOmissionReason;
+var isIncludedContext = false;
 var isFilteredContext = false;
 var isDynamicExecution = false;
 var capturedThrownException = null;
 var resultsFileWritten = false;
+function createDefaultOptions() {
+  const options = new LiveDocOptions();
+  options.rules.singleGivenWhenThen = "enabled" /* enabled */;
+  options.rules.backgroundMustOnlyIncludeGiven = "enabled" /* enabled */;
+  options.rules.enforceTitle = "enabled" /* enabled */;
+  options.rules.enforceUsingGivenOverBefore = "warning" /* warning */;
+  options.rules.mustIncludeGiven = "warning" /* warning */;
+  options.rules.mustIncludeWhen = "warning" /* warning */;
+  options.rules.mustIncludeThen = "warning" /* warning */;
+  return options;
+}
+function assertDeclarationParent(type, title, expectedParent, missingParentMessage, filename) {
+  const declarationTitle = title.trim().split(/\r?\n/, 1)[0].trim();
+  const currentDeclarationContext = declarationContextStorage.getStore();
+  if (currentDeclarationContext?.type === expectedParent) {
+    return;
+  }
+  if (currentDeclarationContext) {
+    throw new ParserException(
+      `Invalid nesting: ${type} "${declarationTitle}" cannot be declared within ${currentDeclarationContext.type} "${currentDeclarationContext.title}".`,
+      declarationTitle,
+      filename
+    );
+  }
+  if (expectedParent !== null) {
+    throw new ParserException(missingParentMessage, title, filename);
+  }
+}
+function captureParserException(error) {
+  if (!isDynamicExecution || !(error instanceof ParserException)) {
+    return;
+  }
+  capturedThrownException = {
+    type: "ParserException",
+    message: error.description,
+    data: {
+      description: error.description,
+      title: error.title,
+      filename: error.filename
+    }
+  };
+}
+function withDeclarationContext(context, fn) {
+  return declarationContextStorage.run(context, fn);
+}
+async function withDeclarationContextAsync(context, fn) {
+  return await declarationContextStorage.run(context, fn);
+}
+function getStepDeclarationType(stepType) {
+  switch (stepType) {
+    case "given":
+      return "Given";
+    case "when":
+      return "When";
+    case "then":
+      return "Then";
+    case "and":
+      return "And";
+    case "but":
+      return "But";
+    default:
+      throw new Error(`Unsupported LiveDoc step type: ${stepType}`);
+  }
+}
 var __filename_esm = fileURLToPath(import.meta.url);
 dirname(__filename_esm);
 var dynamicResultsFile = process.env.LIVEDOC_DYNAMIC_RESULTS_FILE;
@@ -1704,11 +1774,13 @@ if (dynamicResultsFile) {
       return;
     }
     try {
+      const outputFeatures = pruneFilteredFeatures(featureRegistry);
+      const outputSpecifications = pruneFilteredSpecifications(specificationRegistry);
       const fs2 = __require("fs");
       const results = {
-        features: featureRegistry.map((f) => f.toJSON()),
+        features: outputFeatures.map((f) => f.toJSON()),
         suites: suiteRegistry.map((s) => s.toJSON()),
-        specifications: specificationRegistry.map((s) => s.toJSON())
+        specifications: outputSpecifications.map((s) => s.toJSON())
       };
       if (capturedThrownException) {
         results.thrownException = capturedThrownException;
@@ -1725,15 +1797,8 @@ if (dynamicResultsFile) {
   });
 }
 var livedoc = {
-  options: new LiveDocOptions()
-};
-livedoc.options.rules.singleGivenWhenThen = "enabled" /* enabled */;
-livedoc.options.rules.backgroundMustOnlyIncludeGiven = "enabled" /* enabled */;
-livedoc.options.rules.enforceTitle = "enabled" /* enabled */;
-livedoc.options.rules.enforceUsingGivenOverBefore = "warning" /* warning */;
-livedoc.options.rules.mustIncludeGiven = "warning" /* warning */;
-livedoc.options.rules.mustIncludeWhen = "warning" /* warning */;
-livedoc.options.rules.mustIncludeThen = "warning" /* warning */;
+  options: createDefaultOptions()
+};
 var displayedViolations = {};
 function markedAsExcluded(tags) {
   if (tags.length === 0 || !livedoc.options.filters.exclude) {
@@ -1757,14 +1822,189 @@ function markedAsIncluded(tags) {
   }
   return false;
 }
-function shouldMarkAsPending(tags) {
-  return markedAsExcluded(tags) && (!markedAsIncluded(tags) || !!livedoc.options.filters.showFilterConflicts);
+function hasIncludeFilter() {
+  return (livedoc.options.filters.include?.length ?? 0) > 0;
 }
-function shouldInclude(tags) {
-  if (tags.length === 0) {
-    return false;
+function decideFilter(tags, inheritedIncluded, inheritedFilteredOut, allowIncludeMiss) {
+  const directlyIncluded = markedAsIncluded(tags);
+  const directlyExcluded = markedAsExcluded(tags);
+  const included = inheritedIncluded || directlyIncluded;
+  const isConflict = directlyIncluded && directlyExcluded;
+  if (inheritedFilteredOut) {
+    return {
+      filteredOut: true,
+      included,
+      pendingConflict: false,
+      reason: "parent-filtered"
+    };
+  }
+  if (isConflict && !!livedoc.options.filters.showFilterConflicts) {
+    return {
+      filteredOut: false,
+      included: true,
+      pendingConflict: true
+    };
+  }
+  if (directlyExcluded) {
+    return {
+      filteredOut: true,
+      included,
+      pendingConflict: false,
+      reason: "exclude"
+    };
+  }
+  if (allowIncludeMiss && hasIncludeFilter() && !included) {
+    return {
+      filteredOut: true,
+      included: false,
+      pendingConflict: false,
+      reason: "include-miss"
+    };
+  }
+  return {
+    filteredOut: false,
+    included,
+    pendingConflict: false
+  };
+}
+function markFilteredOut(target, decision) {
+  if (!decision.filteredOut) {
+    return;
+  }
+  const mutable = target;
+  mutable.filteredOut = true;
+  mutable.filterOmissionReason = decision.reason ?? "parent-filtered";
+}
+function shouldSkipForFilterDecision(decision, explicitPending, inheritedPending = false) {
+  return !!explicitPending || inheritedPending || decision.filteredOut || decision.pendingConflict;
+}
+function filterMeta(reason) {
+  if (!reason) {
+    return void 0;
+  }
+  return {
+    filteredOut: true,
+    reason
+  };
+}
+function isFilteredOutModel(value) {
+  return !!value?.filteredOut;
+}
+function pruneFilteredFeatures(features) {
+  return features.map((feature3) => pruneFeatureForOutput(feature3)).filter((feature3) => feature3 !== null);
+}
+function pruneFeatureForOutput(feature3) {
+  if (isFilteredOutModel(feature3)) {
+    return null;
+  }
+  feature3.scenarios = feature3.scenarios.map((scenario3) => pruneScenarioForOutput(scenario3)).filter((scenario3) => scenario3 !== null);
+  if (feature3.scenarios.length === 0) {
+    return null;
+  }
+  recalculateFeatureStatistics(feature3);
+  return feature3;
+}
+function pruneScenarioForOutput(scenario3) {
+  if (isFilteredOutModel(scenario3)) {
+    return null;
+  }
+  if (scenario3 instanceof ScenarioOutline) {
+    scenario3.examples = scenario3.examples.filter((example) => !isFilteredOutModel(example));
+    if (scenario3.examples.length === 0) {
+      return null;
+    }
+  }
+  return scenario3;
+}
+function pruneFilteredSpecifications(specifications) {
+  return specifications.map((specification3) => pruneSpecificationForOutput(specification3)).filter((specification3) => specification3 !== null);
+}
+function pruneSpecificationForOutput(specification3) {
+  if (isFilteredOutModel(specification3)) {
+    return null;
+  }
+  specification3.rules = specification3.rules.map((rule3) => pruneRuleForOutput(rule3)).filter((rule3) => rule3 !== null);
+  if (specification3.rules.length === 0) {
+    return null;
+  }
+  recalculateSpecificationStatistics(specification3);
+  return specification3;
+}
+function pruneRuleForOutput(rule3) {
+  if (isFilteredOutModel(rule3)) {
+    return null;
+  }
+  if (rule3 instanceof RuleOutline) {
+    rule3.examples = rule3.examples.filter((example) => !isFilteredOutModel(example));
+    if (rule3.examples.length === 0) {
+      return null;
+    }
+  }
+  return rule3;
+}
+function resetStatistics(suite) {
+  suite.statistics = new Statistics(suite);
+}
+function recalculateFeatureStatistics(feature3) {
+  resetStatistics(feature3);
+  if (feature3.background && !isFilteredOutModel(feature3.background)) {
+    resetStatistics(feature3.background);
+    for (const step of feature3.background.steps) {
+      if (!isFilteredOutModel(step)) {
+        feature3.background.statistics.updateStats(step.status, step.duration);
+      }
+    }
+  }
+  for (const scenario3 of feature3.scenarios) {
+    recalculateScenarioStatistics(scenario3);
+  }
+}
+function recalculateScenarioStatistics(scenario3) {
+  resetStatistics(scenario3);
+  if (scenario3 instanceof ScenarioOutline) {
+    for (const example of scenario3.examples) {
+      resetStatistics(example);
+      for (const step of example.steps) {
+        if (!isFilteredOutModel(step)) {
+          example.statistics.updateStats(step.status, step.duration);
+        }
+      }
+    }
+    return;
+  }
+  for (const step of scenario3.steps) {
+    if (!isFilteredOutModel(step)) {
+      scenario3.statistics.updateStats(step.status, step.duration);
+    }
+  }
+}
+function recalculateSpecificationStatistics(specification3) {
+  resetStatistics(specification3);
+  for (const rule3 of specification3.rules) {
+    if (rule3 instanceof RuleOutline) {
+      recalculateRuleOutlineStatus(rule3);
+      for (const example of rule3.examples) {
+        specification3.statistics.updateStats(example.status, example.executionTime);
+      }
+    } else {
+      specification3.statistics.updateStats(rule3.status, rule3.executionTime);
+    }
+  }
+}
+function recalculateRuleOutlineStatus(ruleOutline3) {
+  if (ruleOutline3.examples.length === 0) {
+    ruleOutline3.status = "unknown" /* unknown */;
+    return;
+  }
+  if (ruleOutline3.examples.some((example) => example.status === "fail" /* fail */)) {
+    ruleOutline3.status = "fail" /* fail */;
+  } else if (ruleOutline3.examples.every((example) => example.status === "pass" /* pass */)) {
+    ruleOutline3.status = "pass" /* pass */;
+  } else if (ruleOutline3.examples.every((example) => example.status === "pending" /* pending */)) {
+    ruleOutline3.status = "pending" /* pending */;
+  } else {
+    ruleOutline3.status = "pass" /* pass */;
   }
-  return markedAsIncluded(tags) && (!markedAsExcluded(tags) || !!livedoc.options.filters.showFilterConflicts);
 }
 function displayRuleViolation(violation, filename) {
   if (displayedViolations[violation.errorId]) {
@@ -1800,6 +2040,7 @@ function displayWarnings(filename) {
 }
 function featureImpl(title, fn, opts = {}) {
   const filename = getFilenameFromStack(3);
+  assertDeclarationParent("Feature", title, null, "", filename);
   if (fn.constructor.name === "AsyncFunction") {
     throw new ParserException(`The async keyword is not supported for Feature`, title, filename);
   }
@@ -1811,23 +2052,39 @@ function featureImpl(title, fn, opts = {}) {
   thisFeature.generateId(thisFeature);
   thisFeature.validateIdUniqueness(thisFeature.id, featureRegistry);
   featureRegistry.push(thisFeature);
-  const shouldSkip = opts.pending || shouldMarkAsPending(thisFeature.tags);
-  const shouldOnlyRun = opts.isOnly || shouldInclude(thisFeature.tags);
+  const filterDecision = decideFilter(thisFeature.tags, false, false, false);
+  markFilteredOut(thisFeature, filterDecision);
+  const shouldSkip = shouldSkipForFilterDecision(filterDecision, opts.pending);
+  const shouldOnlyRun = opts.isOnly;
   const describeFunc = shouldSkip ? describe.skip : shouldOnlyRun ? describe.only : describe;
   describeFunc(thisFeature.displayTitle, () => {
     currentFeature = thisFeature;
     const previousPendingContext = isPendingContext;
     const previousFilteredContext = isFilteredContext;
+    const previousFilterOmissionReason = currentFilterOmissionReason;
+    const previousIncludedContext = isIncludedContext;
+    if (filterDecision.included) {
+      isIncludedContext = true;
+    }
     if (shouldSkip) {
       isPendingContext = true;
+      if (filterDecision.filteredOut) {
+        isFilteredContext = true;
+        currentFilterOmissionReason = filterDecision.reason ?? "parent-filtered";
+      }
     }
     const ctx = {
       get feature() {
         return thisFeature?.getFeatureContext();
       }
     };
-    fn(ctx);
+    withDeclarationContext(
+      { type: "Feature", title: thisFeature.title },
+      () => fn(ctx)
+    );
     isPendingContext = previousPendingContext;
+    currentFilterOmissionReason = previousFilterOmissionReason;
+    isIncludedContext = previousIncludedContext;
     isFilteredContext = previousFilteredContext;
   });
 }
@@ -1845,29 +2102,38 @@ var feature = Object.assign(
   }
 );
 function scenarioImpl(title, fn, opts = {}) {
+  const filename = getFilenameFromStack(3);
+  assertDeclarationParent("Scenario", title, "Feature", "Scenario must be within a feature.", filename);
   if (!currentFeature) {
-    throw new ParserException("Scenario must be within a feature.", title, "");
+    throw new ParserException("Scenario must be within a feature.", title, filename);
   }
-  const filename = getFilenameFromStack(3);
   if (fn.constructor.name === "AsyncFunction") {
     throw new ParserException(`The async keyword is not supported for Scenario`, title, filename);
   }
   const scenarioModel = parser.addScenario(currentFeature, title);
   scenarioCount++;
   const thisScenarioId = scenarioCount;
-  const shouldSkip = opts.pending || isPendingContext || shouldMarkAsPending(scenarioModel.tags);
-  const shouldOnlyRun = opts.isOnly || shouldInclude(scenarioModel.tags);
-  const isInheritedFilter = isFilteredContext;
+  const filterDecision = decideFilter(scenarioModel.tags, isIncludedContext, isFilteredContext, true);
+  markFilteredOut(scenarioModel, filterDecision);
+  const shouldSkip = shouldSkipForFilterDecision(filterDecision, opts.pending, isPendingContext);
+  const shouldOnlyRun = opts.isOnly;
+  const inheritedFilterOmissionReason = currentFilterOmissionReason;
   const describeFunc = shouldSkip ? describe.skip : shouldOnlyRun ? describe.only : describe;
   describeFunc(scenarioModel.displayTitle, () => {
     const previousScenario = currentScenario;
     currentScenario = scenarioModel;
     const previousPendingContext = isPendingContext;
+    const previousFilterOmissionReason = currentFilterOmissionReason;
+    const previousIncludedContext = isIncludedContext;
+    if (filterDecision.included) {
+      isIncludedContext = true;
+    }
     const previousFilteredContext = isFilteredContext;
     if (shouldSkip) {
       isPendingContext = true;
-      if (isInheritedFilter) {
+      if (filterDecision.filteredOut) {
         isFilteredContext = true;
+        currentFilterOmissionReason = filterDecision.reason ?? inheritedFilterOmissionReason ?? "parent-filtered";
       }
     }
     beforeAll(async () => {
@@ -1913,8 +2179,13 @@ function scenarioImpl(title, fn, opts = {}) {
         return scenarioModel.getScenarioContext();
       }
     };
-    fn(ctx);
+    withDeclarationContext(
+      { type: "Scenario", title: scenarioModel.title },
+      () => fn(ctx)
+    );
     isPendingContext = previousPendingContext;
+    currentFilterOmissionReason = previousFilterOmissionReason;
+    isIncludedContext = previousIncludedContext;
     isFilteredContext = previousFilteredContext;
     currentScenario = previousScenario;
   });
@@ -1933,10 +2204,11 @@ var scenario = Object.assign(
   }
 );
 function backgroundImpl(title, fn, opts = {}) {
+  const filename = getFilenameFromStack(3);
+  assertDeclarationParent("Background", title, "Feature", "Background must be within a feature.", filename);
   if (!currentFeature) {
-    throw new ParserException("Background must be within a feature.", title, "");
+    throw new ParserException("Background must be within a feature.", title, filename);
   }
-  const filename = getFilenameFromStack(3);
   if (fn.constructor.name === "AsyncFunction") {
     throw new ParserException(`The async keyword is not supported for Background`, title, filename);
   }
@@ -1963,7 +2235,10 @@ function backgroundImpl(title, fn, opts = {}) {
         }
       }
     };
-    fn(ctx);
+    withDeclarationContext(
+      { type: "Background", title: backgroundModel.title },
+      () => fn(ctx)
+    );
     currentBackground = previousBackground;
   });
 }
@@ -1987,33 +2262,49 @@ function onScenarioEnd(fn) {
   scenarioEndHooks.push(fn);
 }
 function scenarioOutlineImpl(title, fn, opts = {}) {
+  const filename = getFilenameFromStack(3);
+  assertDeclarationParent(
+    "Scenario Outline",
+    title,
+    "Feature",
+    "Scenario Outline must be within a feature.",
+    filename
+  );
   if (!currentFeature) {
-    throw new ParserException("Scenario Outline must be within a feature.", title, "");
+    throw new ParserException("Scenario Outline must be within a feature.", title, filename);
   }
-  const filename = getFilenameFromStack(3);
   if (fn.constructor.name === "AsyncFunction") {
     throw new ParserException(`The async keyword is not supported for Scenario Outline`, title, filename);
   }
   const scenarioOutlineModel = parser.addScenarioOutline(currentFeature, title);
-  const shouldSkip = opts.pending || isPendingContext || shouldMarkAsPending(scenarioOutlineModel.tags);
-  const shouldOnlyRun = opts.isOnly || shouldInclude(scenarioOutlineModel.tags);
-  const isInheritedFilter = isFilteredContext;
+  const filterDecision = decideFilter(scenarioOutlineModel.tags, isIncludedContext, isFilteredContext, true);
+  markFilteredOut(scenarioOutlineModel, filterDecision);
+  const shouldSkip = shouldSkipForFilterDecision(filterDecision, opts.pending, isPendingContext);
+  const shouldOnlyRun = opts.isOnly;
+  const inheritedFilterOmissionReason = currentFilterOmissionReason;
   const outlineDescribeFunc = shouldSkip ? describe.skip : shouldOnlyRun ? describe.only : describe;
   outlineDescribeFunc(`Scenario: ${scenarioOutlineModel.title}`, () => {
     for (const example of scenarioOutlineModel.examples) {
       scenarioCount++;
       const thisScenarioId = scenarioCount;
+      markFilteredOut(example, filterDecision);
       const materializedScenarioTitle = materializePlaceholders(scenarioOutlineModel.title, example.exampleRaw ?? example.example ?? {});
       const exampleName = `Example ${example.sequence}: ${materializedScenarioTitle}`;
       describe(exampleName, () => {
         const previousScenario = currentScenario;
         currentScenario = example;
         const previousPendingContext = isPendingContext;
+        const previousFilterOmissionReason = currentFilterOmissionReason;
+        const previousIncludedContext = isIncludedContext;
+        if (filterDecision.included) {
+          isIncludedContext = true;
+        }
         const previousFilteredContext = isFilteredContext;
         if (shouldSkip) {
           isPendingContext = true;
-          if (isInheritedFilter) {
+          if (filterDecision.filteredOut) {
             isFilteredContext = true;
+            currentFilterOmissionReason = filterDecision.reason ?? inheritedFilterOmissionReason ?? "parent-filtered";
           }
         }
         beforeAll(async () => {
@@ -2062,8 +2353,13 @@ function scenarioOutlineImpl(title, fn, opts = {}) {
             return example.getScenarioContext();
           }
         };
-        fn(ctx);
+        withDeclarationContext(
+          { type: "Scenario Outline", title: scenarioOutlineModel.title },
+          () => fn(ctx)
+        );
         isPendingContext = previousPendingContext;
+        currentFilterOmissionReason = previousFilterOmissionReason;
+        isIncludedContext = previousIncludedContext;
         isFilteredContext = previousFilteredContext;
         currentScenario = previousScenario;
       });
@@ -2085,19 +2381,31 @@ var scenarioOutline = Object.assign(
 );
 function specificationImpl(title, fn, opts = {}) {
   const filename = getFilenameFromStack(3);
+  assertDeclarationParent("Specification", title, null, "", filename);
   const thisSpecification = parser.createSpecification(title, filename);
   currentSpecification = thisSpecification;
   thisSpecification.generateId(thisSpecification);
   thisSpecification.validateIdUniqueness(thisSpecification.id, specificationRegistry);
   specificationRegistry.push(thisSpecification);
-  const shouldSkip = opts.pending || shouldMarkAsPending(thisSpecification.tags);
-  const shouldOnlyRun = opts.isOnly || shouldInclude(thisSpecification.tags);
+  const filterDecision = decideFilter(thisSpecification.tags, false, false, false);
+  markFilteredOut(thisSpecification, filterDecision);
+  const shouldSkip = shouldSkipForFilterDecision(filterDecision, opts.pending);
+  const shouldOnlyRun = opts.isOnly;
   const describeFunc = shouldSkip ? describe.skip : shouldOnlyRun ? describe.only : describe;
   describeFunc(thisSpecification.displayTitle, () => {
     currentSpecification = thisSpecification;
     const previousPendingContext = isPendingContext;
     const previousFilteredContext = isFilteredContext;
+    const previousFilterOmissionReason = currentFilterOmissionReason;
+    const previousIncludedContext = isIncludedContext;
+    if (filterDecision.included) {
+      isIncludedContext = true;
+    }
     if (shouldSkip) {
+      if (filterDecision.filteredOut) {
+        isFilteredContext = true;
+        currentFilterOmissionReason = filterDecision.reason ?? "parent-filtered";
+      }
       isPendingContext = true;
     }
     const ctx = {
@@ -2105,8 +2413,13 @@ function specificationImpl(title, fn, opts = {}) {
         return thisSpecification?.getSpecificationContext();
       }
     };
-    fn(ctx);
+    withDeclarationContext(
+      { type: "Specification", title: thisSpecification.title },
+      () => fn(ctx)
+    );
     isPendingContext = previousPendingContext;
+    currentFilterOmissionReason = previousFilterOmissionReason;
+    isIncludedContext = previousIncludedContext;
     isFilteredContext = previousFilteredContext;
   });
 }
@@ -2124,13 +2437,20 @@ var specification = Object.assign(
   }
 );
 function ruleImpl(title, fn, opts = {}) {
+  const filename = getFilenameFromStack(3);
+  assertDeclarationParent("Rule", title, "Specification", "Rule must be within a specification.", filename);
   if (!currentSpecification) {
-    throw new ParserException("Rule must be within a specification.", title, "");
+    throw new ParserException("Rule must be within a specification.", title, filename);
   }
   const ruleModel = parser.addRule(currentSpecification, title);
   const specificationModel = currentSpecification;
-  const shouldSkip = opts.pending || isPendingContext || shouldMarkAsPending(ruleModel.tags);
-  const shouldOnlyRun = opts.isOnly || shouldInclude(ruleModel.tags);
+  const filterDecision = decideFilter(ruleModel.tags, isIncludedContext, isFilteredContext, true);
+  markFilteredOut(ruleModel, filterDecision);
+  const shouldSkip = shouldSkipForFilterDecision(filterDecision, opts.pending, isPendingContext);
+  const shouldOnlyRun = opts.isOnly;
+  if (shouldSkip && !filterDecision.filteredOut) {
+    ruleModel.status = "pending" /* pending */;
+  }
   const ruleMeta = {
     livedoc: {
       kind: "rule",
@@ -2138,7 +2458,8 @@ function ruleImpl(title, fn, opts = {}) {
         title: ruleModel.title,
         description: ruleModel.description ?? "",
         tags: ruleModel.tags ?? []
-      }
+      },
+      ...filterDecision.filteredOut ? { filter: filterMeta(filterDecision.reason ?? currentFilterOmissionReason ?? "parent-filtered") } : {}
     }
   };
   const ruleHandler = async () => {
@@ -2152,10 +2473,14 @@ function ruleImpl(title, fn, opts = {}) {
     };
     const startTime = Date.now();
     try {
-      await fn(ctx);
+      await withDeclarationContextAsync(
+        { type: "Rule", title: ruleModel.title },
+        () => fn(ctx)
+      );
       ruleModel.status = "pass" /* pass */;
       ruleModel.executionTime = Date.now() - startTime;
     } catch (error) {
+      captureParserException(error);
       ruleModel.status = "fail" /* fail */;
       ruleModel.executionTime = Date.now() - startTime;
       ruleModel.error = error;
@@ -2190,12 +2515,25 @@ var rule = Object.assign(
   }
 );
 function ruleOutlineImpl(title, fn, opts = {}) {
+  const filename = getFilenameFromStack(3);
+  assertDeclarationParent(
+    "Rule Outline",
+    title,
+    "Specification",
+    "Rule Outline must be within a specification.",
+    filename
+  );
   if (!currentSpecification) {
-    throw new ParserException("Rule Outline must be within a specification.", title, "");
+    throw new ParserException("Rule Outline must be within a specification.", title, filename);
   }
   const ruleOutlineModel = parser.addRuleOutline(currentSpecification, title);
-  const shouldSkip = opts.pending || isPendingContext || shouldMarkAsPending(ruleOutlineModel.tags);
-  const shouldOnlyRun = opts.isOnly || shouldInclude(ruleOutlineModel.tags);
+  const filterDecision = decideFilter(ruleOutlineModel.tags, isIncludedContext, isFilteredContext, true);
+  markFilteredOut(ruleOutlineModel, filterDecision);
+  const shouldSkip = shouldSkipForFilterDecision(filterDecision, opts.pending, isPendingContext);
+  const shouldOnlyRun = opts.isOnly;
+  if (shouldSkip && !filterDecision.filteredOut) {
+    ruleOutlineModel.status = "pending" /* pending */;
+  }
   const outlineDescribeFunc = shouldSkip ? describe.skip : shouldOnlyRun ? describe.only : describe;
   const specificationModel = currentSpecification;
   outlineDescribeFunc(`Rule Outline: ${ruleOutlineModel.title}`, () => {
@@ -2205,6 +2543,10 @@ function ruleOutlineImpl(title, fn, opts = {}) {
       example.title = materializedRuleTitle;
       example.displayTitle = materializedRuleTitle;
       const exampleName = `Example ${example.sequence}: ${materializedRuleTitle}`;
+      markFilteredOut(example, filterDecision);
+      if (shouldSkip && !filterDecision.filteredOut) {
+        example.status = "pending" /* pending */;
+      }
       const exampleMeta = {
         livedoc: {
           kind: "ruleExample",
@@ -2218,7 +2560,8 @@ function ruleOutlineImpl(title, fn, opts = {}) {
               values: example.example ?? {},
               valuesRaw: example.exampleRaw ?? {}
             }
-          }
+          },
+          ...filterDecision.filteredOut ? { filter: filterMeta(filterDecision.reason ?? currentFilterOmissionReason ?? "parent-filtered") } : {}
         }
       };
       const exampleHandler = async () => {
@@ -2235,10 +2578,14 @@ function ruleOutlineImpl(title, fn, opts = {}) {
         };
         const startTime = Date.now();
         try {
-          await fn(ctx);
+          await withDeclarationContextAsync(
+            { type: "Rule Outline", title: ruleOutlineModel.title },
+            () => fn(ctx)
+          );
           example.status = "pass" /* pass */;
           example.executionTime = Date.now() - startTime;
         } catch (error) {
+          captureParserException(error);
           example.status = "fail" /* fail */;
           example.executionTime = Date.now() - startTime;
           example.error = error;
@@ -2254,6 +2601,7 @@ function ruleOutlineImpl(title, fn, opts = {}) {
       }
       currentSuite.task(exampleName, {
         meta: exampleMeta,
+        skip: shouldSkip,
         handler: exampleHandler
       });
     }
@@ -2283,6 +2631,10 @@ function createStepFunction(stepType) {
       );
     }
     const stepDefinition = parser.createStep(stepType, title, passedParam);
+    if (isFilteredContext) {
+      stepDefinition.filteredOut = true;
+      stepDefinition.filterOmissionReason = currentFilterOmissionReason ?? "parent-filtered";
+    }
     if (currentScenario instanceof ScenarioExample || currentScenario instanceof ScenarioOutline) {
       parser.applyPassedParams(stepDefinition);
     }
@@ -2370,7 +2722,8 @@ function createStepFunction(stepType) {
               }
             } : {}
           }
-        } : {}
+        } : {},
+        ...isFilteredContext ? { filter: filterMeta(currentFilterOmissionReason ?? "parent-filtered") } : {}
       }
     };
     const stepHandler = async () => {
@@ -2396,10 +2749,10 @@ function createStepFunction(stepType) {
                 return stepDefinition.getStepContext();
               }
             };
-            const result = fn(ctx);
-            if (result && typeof result.then === "function") {
-              await result;
-            }
+            await withDeclarationContextAsync(
+              { type: getStepDeclarationType(stepDefinition.type), title: stepDefinition.title },
+              () => fn(ctx)
+            );
           }
         } else if (capturedScenario) {
           const backgroundItExecuted = capturedFeature ? backgroundItExecutedMap.get(capturedFeature) ?? false : false;
@@ -2412,20 +2765,23 @@ function createStepFunction(stepType) {
               parser.applyPassedParams(stepDetail.stepDefinition);
               const bgStartTime = Date.now();
               try {
-                const result = stepDetail.func({
-                  get feature() {
-                    return capturedFeature?.getFeatureContext();
+                await withDeclarationContextAsync(
+                  {
+                    type: getStepDeclarationType(stepDetail.stepDefinition.type),
+                    title: stepDetail.stepDefinition.title
                   },
-                  get background() {
-                    return capturedFeature?.getBackgroundContext();
-                  },
-                  get step() {
-                    return stepDetail.stepDefinition.getStepContext();
-                  }
-                });
-                if (result && typeof result.then === "function") {
-                  await result;
-                }
+                  () => stepDetail.func({
+                    get feature() {
+                      return capturedFeature?.getFeatureContext();
+                    },
+                    get background() {
+                      return capturedFeature?.getBackgroundContext();
+                    },
+                    get step() {
+                      return stepDetail.stepDefinition.getStepContext();
+                    }
+                  })
+                );
                 stepDetail.stepDefinition.setStatus("pass" /* pass */, Date.now() - bgStartTime);
               } catch (error) {
                 stepDetail.stepDefinition.setStatus("fail" /* fail */, Date.now() - bgStartTime);
@@ -2459,10 +2815,10 @@ function createStepFunction(stepType) {
                 return capturedFeature?.getBackgroundContext();
               }
             };
-            const result = fn(ctx);
-            if (result && typeof result.then === "function") {
-              await result;
-            }
+            await withDeclarationContextAsync(
+              { type: getStepDeclarationType(stepDefinition.type), title: stepDefinition.title },
+              () => fn(ctx)
+            );
           }
         }
         const duration = Date.now() - startTime;
@@ -2471,6 +2827,7 @@ function createStepFunction(stepType) {
           taskMeta.livedoc.step.attachments = stepDefinition.attachments;
         }
       } catch (error) {
+        captureParserException(error);
         const duration = Date.now() - startTime;
         stepDefinition.setStatus("fail" /* fail */, duration);
         const exception = new Exception();
@@ -2499,7 +2856,8 @@ function createStepFunction(stepType) {
     }
     currentSuite.task(testName, {
       meta: taskMeta,
-      handler: stepHandler
+      handler: stepHandler,
+      skip: isFilteredContext || void 0
     });
   };
 }
@@ -2850,9 +3208,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;
@@ -2890,8 +3248,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;
@@ -3111,6 +3469,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));
     }
@@ -3120,6 +3481,9 @@ var LiveDocSpec = class _LiveDocSpec extends LiveDocReporter {
         const status = this.getStatusIndicator(rule3.status);
         const title = this.highlight(rule3.title, /<[^>]+>/g, this.colorTheme.valuePlaceholders);
         this.writeLine(`    ${status} ${this.colorTheme.keyword("Rule Outline:")} ${this.colorTheme.scenarioTitle(title)}`);
+        if (rule3.tags.length > 0) {
+          this.writeLine(this.applyBlockIndent(this.formatTags(rule3.tags), 6));
+        }
         if (rule3.description) {
           this.writeLine(this.formatDescription(rule3.description, 6, this.colorTheme.scenarioDescription));
         }
@@ -3148,6 +3512,9 @@ var LiveDocSpec = class _LiveDocSpec extends LiveDocReporter {
       } else {
         const status = this.getStatusIndicator(rule3.status);
         this.writeLine(`    ${status} ${this.colorTheme.keyword("Rule:")} ${this.colorTheme.stepTitle(rule3.title)}`);
+        if (rule3.tags.length > 0) {
+          this.writeLine(this.applyBlockIndent(this.formatTags(rule3.tags), 6));
+        }
       }
     }
     this.writeLine(" ");
@@ -4460,8 +4827,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
@@ -4577,11 +4944,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() {
@@ -8033,9 +8400,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}`)}`;
@@ -8101,6 +8468,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(),
@@ -8164,10 +8578,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,
@@ -8175,18 +8591,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({
@@ -8197,7 +8614,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({
@@ -8226,31 +8644,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(),
@@ -8284,15 +8688,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,
@@ -8301,19 +8703,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) {
@@ -8339,7 +9082,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);
@@ -8352,6 +9095,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 feature3 of results.features) {
@@ -8365,6 +9113,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(),
@@ -8375,7 +9124,8 @@ var LiveDocViewerReporter = class {
       duration,
       status,
       summary,
-      documents
+      documents,
+      ...coverage ? { coverage } : {}
     };
   }
   async startRunSession(rawOptions) {
@@ -8414,22 +9164,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 });
   }
@@ -8444,7 +9216,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 };
   }
@@ -8466,7 +9238,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) {
@@ -9020,16 +9792,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 */:
@@ -9178,6 +9965,7 @@ var LiveDocSpecReporter = class {
   liveDocSpec;
   options;
   exportConfig = null;
+  coverageContext = { runStartedAt: Date.now() };
   streamEnabled = true;
   taskById = /* @__PURE__ */ new Map();
   streamedStates = /* @__PURE__ */ new Map();
@@ -9204,6 +9992,7 @@ var LiveDocSpecReporter = class {
       livedoc$1.options.publish.server = options.publish.server ?? livedoc$1.options.publish.server;
       livedoc$1.options.publish.project = options.publish.project ?? livedoc$1.options.publish.project;
       livedoc$1.options.publish.environment = options.publish.environment ?? livedoc$1.options.publish.environment;
+      livedoc$1.options.publish.runType = options.publish.runType ?? livedoc$1.options.publish.runType;
     }
     if (options.export) {
       this.exportConfig = {
@@ -9220,22 +10009,14 @@ var LiveDocSpecReporter = class {
     this.setLiveDocOptions(this.options);
   }
   async onInit(ctx) {
+    this.captureCoverageContext(ctx);
     this.liveDocSpec.executionStart();
-    if (!livedoc$1.options.publish.enabled) {
-      const envServerUrl = process.env.LIVEDOC_SERVER_URL || process.env.LIVEDOC_PUBLISH_SERVER;
-      if (envServerUrl) {
+    const envServerUrl = this.applyPublishEnvironmentOverrides();
+    if (!envServerUrl && !livedoc$1.options.publish.enabled) {
+      const serverInfo = await this.discoverLiveDocServer();
+      if (serverInfo) {
         livedoc$1.options.publish.enabled = true;
-        livedoc$1.options.publish.server = envServerUrl;
-      } else {
-        try {
-          const { discoverServer } = await import('@swedevtools/livedoc-server');
-          const serverInfo = await discoverServer();
-          if (serverInfo) {
-            livedoc$1.options.publish.enabled = true;
-            livedoc$1.options.publish.server = serverInfo.url;
-          }
-        } catch {
-        }
+        livedoc$1.options.publish.server = serverInfo.url;
       }
     }
     if (livedoc$1.options.publish.enabled) {
@@ -9247,6 +10028,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$1.options.publish.project = envProject;
+    }
+    if (envEnvironment) {
+      livedoc$1.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$1.options.publish.runType = normalizedRunType;
+    }
+    if (envServerUrl) {
+      livedoc$1.options.publish.enabled = true;
+      livedoc$1.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();
@@ -9310,30 +10187,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$1.options.publish.project || "default";
+    const project = exportConfig.project || livedoc$1.options.publish.project || "livedoc";
     const environment = exportConfig.environment || livedoc$1.options.publish.environment || (process.env.CI ? "ci" : "local");
     const converter = new LiveDocViewerReporter({
       project,
       environment,
+      runType: livedoc$1.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);
@@ -9356,9 +10237,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 specification3 = this.buildSpecificationFromSuite(suite, file.filepath);
+            if (specification3.rules.length > 0) {
+              specifications.push(specification3);
+            }
           } else if (suite.name.startsWith("Feature:")) {
-            features.push(this.buildFeatureFromSuite(suite, file.filepath));
+            const feature3 = this.buildFeatureFromSuite(suite, file.filepath);
+            if (feature3.scenarios.length > 0) {
+              features.push(feature3);
+            }
           } else {
             suites.push(this.buildVitestSuiteFromTask(suite, file.filepath));
           }
@@ -9403,6 +10290,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 ")
@@ -9426,7 +10314,7 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
     scenarioOutline3.description = parsed.description;
     scenarioOutline3.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);
@@ -9478,7 +10366,7 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
     background3.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, background3, forcePending);
         background3.addStep(step);
       }
@@ -9493,7 +10381,7 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
     scenario3.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, scenario3, forcePending);
         scenario3.addStep(step);
       }
@@ -9517,7 +10405,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);
       }
@@ -9531,9 +10419,20 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
     if (!livedoc3 || typeof livedoc3 !== "object") return void 0;
     return livedoc3;
   }
+  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 livedoc3 = this.getLiveDocMetaFromTask(task);
       if (livedoc3?.kind === "step") return livedoc3;
@@ -9721,8 +10620,10 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
     specification3.tags = parsed.tags;
     specification3.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";
@@ -9731,6 +10632,7 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
           const ruleOutline3 = this.buildRuleOutlineFromSuite(task, specification3);
           specification3.rules.push(ruleOutline3);
         }
+        if (this.isFilteredOutTask(task)) continue;
       } else if (task.type === "test") {
         if (task.name.startsWith("Rule:")) {
           const rule3 = this.buildRuleFromTest(task, specification3);
@@ -9779,6 +10681,7 @@ LiveDoc Viewer: Connecting to ${publishOptions.server}...`);
   buildRuleOutlineFromSuite(suite, specification3) {
     const ruleOutline3 = new RuleOutline(specification3);
     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";