executable-stories-formatters 0.7.14 → 0.7.15

package/dist/cli.js

@@ -3,7 +3,7 @@
 // src/cli.ts
 import { parseArgs } from "util";
 import * as fs8 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 
 // src/validation/schema-validator.ts
 import Ajv from "ajv/dist/2020.js";
@@ -492,17 +492,17 @@ function validateRawRun(data) {
     return { valid: true, errors: [] };
   }
   const errors = (validate.errors ?? []).map((err) => {
-    const path9 = err.instancePath || "/";
+    const path10 = err.instancePath || "/";
     const message = err.message ?? "unknown error";
     if (err.keyword === "additionalProperties") {
       const extra = err.params.additionalProperty;
-      return `${path9}: ${message} \u2014 '${extra}'`;
+      return `${path10}: ${message} \u2014 '${extra}'`;
     }
     if (err.keyword === "enum") {
       const allowed = err.params.allowedValues;
-      return `${path9}: ${message} \u2014 allowed: ${JSON.stringify(allowed)}`;
+      return `${path10}: ${message} \u2014 allowed: ${JSON.stringify(allowed)}`;
     }
-    return `${path9}: ${message}`;
+    return `${path10}: ${message}`;
   });
   return { valid: false, errors };
 }
@@ -976,7 +976,7 @@ ${result.errors.join("\n")}`);
 
 // src/index.ts
 import "fs";
-import * as path6 from "path";
+import * as path7 from "path";
 import * as fsPromises from "fs/promises";
 
 // src/converters/acl/lines.ts
@@ -1355,9 +1355,298 @@ ${doc.markdown}`,
   }
 };
 
+// src/converters/story-report.ts
+import { posix as path2 } from "path";
+
+// src/types/story-report.ts
+var STORY_REPORT_SCHEMA_VERSION = "1.0";
+
+// src/converters/story-report.ts
+function reportSlug(text2) {
+  return text2.toLowerCase().replace(/[/\\.]+/g, "-").replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+function toRelativeSourceFile(sourceFile, projectRoot) {
+  if (!sourceFile) return sourceFile;
+  const normalized = sourceFile.split(path2.sep).join("/");
+  const root = projectRoot.split(path2.sep).join("/").replace(/\/$/, "");
+  if (root && normalized.startsWith(root + "/")) return normalized.slice(root.length + 1);
+  return normalized;
+}
+function fileBasenameTitle(sourceFile) {
+  const base = sourceFile.split("/").pop() ?? sourceFile;
+  return base.replace(/\.(story\.)?(test|spec)\.[tj]sx?$/, "").replace(/\.[tj]sx?$/, "");
+}
+function emptySummary() {
+  return { total: 0, passed: 0, failed: 0, skipped: 0, pending: 0, durationMs: 0 };
+}
+function addToSummary(summary, status, durationMs) {
+  summary.total += 1;
+  summary[status] += 1;
+  summary.durationMs += durationMs;
+}
+function isKeyword(value) {
+  return value === "Given" || value === "When" || value === "Then" || value === "And" || value === "But";
+}
+function copyDocEntries(entries) {
+  if (!entries || entries.length === 0) return [];
+  return entries.map(copyDocEntry);
+}
+function copyDocEntry(entry) {
+  const children = entry.children ? { children: copyDocEntries(entry.children) } : {};
+  switch (entry.kind) {
+    case "note":
+      return { kind: "note", text: entry.text, phase: entry.phase, ...children };
+    case "tag":
+      return { kind: "tag", names: [...entry.names], phase: entry.phase, ...children };
+    case "kv":
+      return { kind: "kv", label: entry.label, value: entry.value, phase: entry.phase, ...children };
+    case "code":
+      return {
+        kind: "code",
+        label: entry.label,
+        content: entry.content,
+        ...entry.lang ? { lang: entry.lang } : {},
+        phase: entry.phase,
+        ...children
+      };
+    case "table":
+      return {
+        kind: "table",
+        label: entry.label,
+        columns: [...entry.columns],
+        rows: entry.rows.map((r) => [...r]),
+        phase: entry.phase,
+        ...children
+      };
+    case "link":
+      return { kind: "link", label: entry.label, url: entry.url, phase: entry.phase, ...children };
+    case "section":
+      return { kind: "section", title: entry.title, markdown: entry.markdown, phase: entry.phase, ...children };
+    case "mermaid":
+      return {
+        kind: "mermaid",
+        code: entry.code,
+        ...entry.title ? { title: entry.title } : {},
+        phase: entry.phase,
+        ...children
+      };
+    case "screenshot":
+      return {
+        kind: "screenshot",
+        path: entry.path,
+        ...entry.alt ? { alt: entry.alt } : {},
+        phase: entry.phase,
+        ...children
+      };
+    case "custom":
+      return {
+        kind: "custom",
+        type: entry.type,
+        data: entry.data,
+        phase: entry.phase,
+        ...children
+      };
+  }
+}
+function buildStep(args) {
+  const step = {
+    id: `${args.scenarioId}--step-${args.index}`,
+    index: args.index,
+    keyword: args.keyword,
+    text: args.text,
+    status: args.status,
+    durationMs: args.durationMs,
+    docEntries: args.docEntries
+  };
+  if (args.errorMessage !== void 0) step.errorMessage = args.errorMessage;
+  if (args.mode !== void 0) step.mode = args.mode;
+  return step;
+}
+function buildSteps(scenarioId, tc) {
+  const declared = tc.story.steps ?? [];
+  const results = tc.stepResults;
+  const max = Math.max(declared.length, results.length);
+  const steps = [];
+  for (let i = 0; i < max; i++) {
+    const decl = declared[i];
+    const res = results[i];
+    const keywordSource = decl?.keyword;
+    const keyword = keywordSource && isKeyword(keywordSource) ? keywordSource : "Given";
+    const text2 = decl?.text ?? "";
+    const status = res?.status ?? "pending";
+    const durationMs = res?.durationMs ?? decl?.durationMs ?? 0;
+    const docEntries = copyDocEntries(decl?.docs);
+    steps.push(buildStep({
+      scenarioId,
+      index: i,
+      keyword,
+      text: text2,
+      status,
+      durationMs,
+      ...res?.errorMessage !== void 0 ? { errorMessage: res.errorMessage } : {},
+      ...decl?.mode !== void 0 ? { mode: decl.mode } : {},
+      docEntries
+    }));
+  }
+  return steps;
+}
+function buildAttachments(tc) {
+  return tc.attachments.map((a) => ({
+    name: a.name,
+    mediaType: a.mediaType,
+    body: a.body,
+    contentEncoding: a.contentEncoding
+  }));
+}
+function buildScenario(tc, featureId) {
+  const titleRaw = tc.story.scenario?.trim() || "(untitled scenario)";
+  const id = `${featureId}--${reportSlug(titleRaw) || `case-${tc.id}`}`;
+  const steps = buildSteps(id, tc);
+  const scenario = {
+    id,
+    title: titleRaw,
+    status: tc.status,
+    durationMs: tc.durationMs,
+    tags: [...tc.tags],
+    retry: tc.retry,
+    retries: tc.retries,
+    docEntries: copyDocEntries(tc.story.docs),
+    steps,
+    attachments: buildAttachments(tc)
+  };
+  if (tc.sourceLine && tc.sourceLine > 0) scenario.sourceLine = tc.sourceLine;
+  if (tc.errorMessage !== void 0) scenario.errorMessage = tc.errorMessage;
+  if (tc.errorStack !== void 0) scenario.errorStack = tc.errorStack;
+  const tickets = tc.story.tickets;
+  if (tickets && tickets.length > 0) {
+    scenario.tickets = tickets.map((t) => t.url ? { id: t.id, url: t.url } : { id: t.id });
+  }
+  return scenario;
+}
+function deriveFeatureTitle(group, relSourceFile) {
+  for (const tc of group) {
+    const head = tc.titlePath?.[0];
+    if (head && head.trim()) return head.trim();
+  }
+  return fileBasenameTitle(relSourceFile);
+}
+function compareScenarios(a, b) {
+  const aLine = a.sourceLine ?? Number.POSITIVE_INFINITY;
+  const bLine = b.sourceLine ?? Number.POSITIVE_INFINITY;
+  if (aLine !== bLine) return aLine - bLine;
+  return a.title.localeCompare(b.title);
+}
+function buildFeature(relSourceFile, group) {
+  const id = `feature-${reportSlug(relSourceFile.replace(/\.[^.]+$/, "")) || "untitled"}`;
+  const title = deriveFeatureTitle(group, relSourceFile);
+  const summary = emptySummary();
+  const scenarios = [];
+  for (const tc of group) {
+    const scenario = buildScenario(tc, id);
+    scenarios.push(scenario);
+    addToSummary(summary, scenario.status, scenario.durationMs);
+  }
+  scenarios.sort(compareScenarios);
+  return { id, title, sourceFile: relSourceFile, summary, scenarios };
+}
+function ensureUniqueFeatureIds(features) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const f of features) {
+    const count = seen.get(f.id) ?? 0;
+    if (count > 0) f.id = `${f.id}-${count + 1}`;
+    seen.set(f.id, count + 1);
+  }
+}
+function ensureUniqueScenarioIds(feature) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const s of feature.scenarios) {
+    const count = seen.get(s.id) ?? 0;
+    if (count > 0) {
+      const newId = `${s.id}-${count + 1}`;
+      for (const step of s.steps) {
+        step.id = step.id.replace(s.id, newId);
+      }
+      s.id = newId;
+    }
+    seen.set(s.id, count + 1);
+  }
+}
+function toStoryReport(run) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const tc of run.testCases) {
+    const rel = toRelativeSourceFile(tc.sourceFile, run.projectRoot);
+    const existing = groups.get(rel);
+    if (existing) existing.push(tc);
+    else groups.set(rel, [tc]);
+  }
+  const features = [];
+  for (const [rel, group] of groups) {
+    features.push(buildFeature(rel, group));
+  }
+  features.sort((a, b) => a.title.localeCompare(b.title));
+  ensureUniqueFeatureIds(features);
+  for (const f of features) ensureUniqueScenarioIds(f);
+  const summary = emptySummary();
+  for (const f of features) {
+    summary.total += f.summary.total;
+    summary.passed += f.summary.passed;
+    summary.failed += f.summary.failed;
+    summary.skipped += f.summary.skipped;
+    summary.pending += f.summary.pending;
+    summary.durationMs += f.summary.durationMs;
+  }
+  const report = {
+    schemaVersion: STORY_REPORT_SCHEMA_VERSION,
+    runId: run.runId,
+    startedAtMs: run.startedAtMs,
+    finishedAtMs: run.finishedAtMs,
+    durationMs: run.durationMs,
+    projectRoot: run.projectRoot,
+    summary,
+    features
+  };
+  if (run.packageVersion) report.packageVersion = run.packageVersion;
+  if (run.gitSha) report.gitSha = run.gitSha;
+  if (run.ci) {
+    const ci = { name: run.ci.name };
+    if (run.ci.url) ci.url = run.ci.url;
+    if (run.ci.buildNumber) ci.buildNumber = run.ci.buildNumber;
+    if (run.ci.branch) ci.branch = run.ci.branch;
+    if (run.ci.commitSha) ci.commitSha = run.ci.commitSha;
+    if (run.ci.prNumber) ci.prNumber = run.ci.prNumber;
+    report.ci = ci;
+  }
+  if (run.coverage) {
+    const cov = {};
+    if (run.coverage.linesPct !== void 0) cov.linesPct = run.coverage.linesPct;
+    if (run.coverage.branchesPct !== void 0) cov.branchesPct = run.coverage.branchesPct;
+    if (run.coverage.functionsPct !== void 0) cov.functionsPct = run.coverage.functionsPct;
+    if (run.coverage.statementsPct !== void 0) cov.statementsPct = run.coverage.statementsPct;
+    report.coverage = cov;
+  }
+  return report;
+}
+
+// src/formatters/story-report-json.ts
+var StoryReportJsonFormatter = class {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      pretty: options.pretty ?? true
+    };
+  }
+  toReport(run) {
+    return toStoryReport(run);
+  }
+  format(run) {
+    const report = toStoryReport(run);
+    return this.options.pretty ? JSON.stringify(report, null, 2) : JSON.stringify(report);
+  }
+};
+
 // src/formatters/html/renderers/index.ts
 import * as fs2 from "fs";
-import * as path2 from "path";
+import * as path3 from "path";
 
 // src/formatters/html/template.ts
 var JS_THEME = `
@@ -2166,6 +2455,80 @@ function escapeHtml(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
 }
 
+// src/theme/tokens.ts
+var ES_THEME_TOKENS_CSS = `
+:root,
+[data-theme="light"] {
+  --es-color-bg: #ffffff;
+  --es-color-fg: #111827;
+  --es-color-muted: #6b7280;
+  --es-color-border: #e5e7eb;
+  --es-color-surface: #f9fafb;
+  --es-color-link: #2563eb;
+  --es-color-passed: #16a34a;
+  --es-color-failed: #dc2626;
+  --es-color-skipped: #9ca3af;
+  --es-color-pending: #d97706;
+  --es-color-passed-bg: #f0fdf4;
+  --es-color-failed-bg: #fef2f2;
+  --es-color-skipped-bg: #f3f4f6;
+  --es-color-pending-bg: #fffbeb;
+  --es-font-body: -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif;
+  --es-font-mono: ui-monospace, SFMono-Regular, "SF Mono", Menlo, monospace;
+  --es-size-base: 1rem;
+  --es-size-sm: 0.875rem;
+  --es-size-xs: 0.75rem;
+  --es-size-h1: 1.875rem;
+  --es-size-h2: 1.5rem;
+  --es-size-h3: 1.25rem;
+  --es-space-1: 0.25rem;
+  --es-space-2: 0.5rem;
+  --es-space-3: 0.75rem;
+  --es-space-4: 1rem;
+  --es-space-6: 1.5rem;
+  --es-space-8: 2rem;
+  --es-radius: 0.5rem;
+  --es-line: 1.6;
+  --es-measure: 72ch;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --es-color-bg: #0b0f17;
+    --es-color-fg: #e5e7eb;
+    --es-color-muted: #9ca3af;
+    --es-color-border: #1f2937;
+    --es-color-surface: #111827;
+    --es-color-link: #60a5fa;
+    --es-color-passed: #4ade80;
+    --es-color-failed: #f87171;
+    --es-color-skipped: #6b7280;
+    --es-color-pending: #fbbf24;
+    --es-color-passed-bg: rgba(74, 222, 128, 0.08);
+    --es-color-failed-bg: rgba(248, 113, 113, 0.08);
+    --es-color-skipped-bg: rgba(107, 114, 128, 0.08);
+    --es-color-pending-bg: rgba(251, 191, 36, 0.08);
+  }
+}
+
+[data-theme="dark"] {
+  --es-color-bg: #0b0f17;
+  --es-color-fg: #e5e7eb;
+  --es-color-muted: #9ca3af;
+  --es-color-border: #1f2937;
+  --es-color-surface: #111827;
+  --es-color-link: #60a5fa;
+  --es-color-passed: #4ade80;
+  --es-color-failed: #f87171;
+  --es-color-skipped: #6b7280;
+  --es-color-pending: #fbbf24;
+  --es-color-passed-bg: rgba(74, 222, 128, 0.08);
+  --es-color-failed-bg: rgba(248, 113, 113, 0.08);
+  --es-color-skipped-bg: rgba(107, 114, 128, 0.08);
+  --es-color-pending-bg: rgba(251, 191, 36, 0.08);
+}
+`.trim();
+
 // src/formatters/html/styles.ts
 var CSS_STYLES = `
 /* ============================================================================
@@ -2173,6 +2536,14 @@ var CSS_STYLES = `
    ============================================================================ */
 @import url('https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:wght@400;500;600;700&family=IBM+Plex+Mono:wght@400;500&display=swap');
 
+/* ============================================================================
+   executable-stories canonical tokens (--es-*).
+   Shared with executable-stories-react. Override on :root or any ancestor of
+   the report to re-color both the standalone HTML and the React component.
+   ============================================================================ */
+${ES_THEME_TOKENS_CSS}
+
+
 /* ============================================================================
    CSS Custom Properties - Light Mode (Default)
    Cucumber-branded shadcn/ui base theme
@@ -14415,7 +14786,7 @@ var SCREENSHOT_MIME_BY_EXT = {
 };
 function readScreenshotAsDataUri(filePath) {
   try {
-    const ext = path2.extname(filePath).slice(1).toLowerCase();
+    const ext = path3.extname(filePath).slice(1).toLowerCase();
     const mime = SCREENSHOT_MIME_BY_EXT[ext];
     if (!mime) return void 0;
     if (!fs2.existsSync(filePath)) return void 0;
@@ -15892,8 +16263,8 @@ function extractDocAttachments(step) {
   }
   return attachments;
 }
-function guessMediaType(path9) {
-  const lower = path9.toLowerCase();
+function guessMediaType(path10) {
+  const lower = path10.toLowerCase();
   if (lower.endsWith(".png")) return "image/png";
   if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
   if (lower.endsWith(".gif")) return "image/gif";
@@ -16968,7 +17339,7 @@ function selectTestCases(args, deps) {
 
 // src/bundler/bundle-assets.ts
 import * as fs4 from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 
 // src/bundler/scan-html-assets.ts
 function scanHtmlAssets(html) {
@@ -16999,7 +17370,7 @@ function isLocalAssetRef(ref) {
 
 // src/bundler/copy-asset.ts
 import * as fs3 from "fs";
-import * as path3 from "path";
+import * as path4 from "path";
 import * as crypto from "crypto";
 function copyAsset(sourcePath, assetsDir) {
   if (!fs3.existsSync(assetsDir)) {
@@ -17007,10 +17378,10 @@ function copyAsset(sourcePath, assetsDir) {
   }
   const content = fs3.readFileSync(sourcePath);
   const hash = crypto.createHash("sha256").update(content).digest("hex").slice(0, 8);
-  const ext = path3.extname(sourcePath);
-  const baseName = sanitize(path3.basename(sourcePath, ext));
+  const ext = path4.extname(sourcePath);
+  const baseName = sanitize(path4.basename(sourcePath, ext));
   const destName = `${baseName}-${hash}${ext}`;
-  const destPath = path3.join(assetsDir, destName);
+  const destPath = path4.join(assetsDir, destName);
   if (!fs3.existsSync(destPath)) {
     fs3.copyFileSync(sourcePath, destPath);
   }
@@ -17022,14 +17393,14 @@ function sanitize(name) {
 
 // src/bundler/bundle-assets.ts
 function bundleAssets(htmlPath, options = {}) {
-  const htmlDir = path4.dirname(htmlPath);
-  const assetsDir = path4.join(htmlDir, "assets");
+  const htmlDir = path5.dirname(htmlPath);
+  const assetsDir = path5.join(htmlDir, "assets");
   let html = fs4.readFileSync(htmlPath, "utf8");
   const refs = scanHtmlAssets(html);
   let copiedCount = 0;
   const missing = [];
   for (const ref of refs) {
-    const absolutePath = path4.resolve(htmlDir, ref);
+    const absolutePath = path5.resolve(htmlDir, ref);
     if (!fs4.existsSync(absolutePath)) {
       missing.push(ref);
       continue;
@@ -17527,14 +17898,14 @@ function groupBy7(items, keyFn) {
 
 // src/formatters/astro-assets.ts
 import * as fs5 from "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 var SKIP_PREFIXES = ["http://", "https://", "data:", "#"];
 function isLocalPath(src) {
   const trimmed = src.trim();
   if (SKIP_PREFIXES.some((prefix) => trimmed.startsWith(prefix))) {
     return false;
   }
-  return !path5.posix.isAbsolute(trimmed) && !path5.win32.isAbsolute(trimmed);
+  return !path6.posix.isAbsolute(trimmed) && !path6.win32.isAbsolute(trimmed);
 }
 function stripCodeContent(markdown) {
   let result = markdown.replace(/^[ \t]*(`{3,}|~{3,})[^\n]*\n[\s\S]*?^[ \t]*\1\s*$/gm, "");
@@ -17628,7 +17999,7 @@ function copyMarkdownAssets(options) {
   const pathMap = /* @__PURE__ */ new Map();
   const missing = [];
   for (const ref of refs) {
-    const absPath = path5.resolve(markdownDir, ref);
+    const absPath = path6.resolve(markdownDir, ref);
     if (!fs5.existsSync(absPath)) {
       if (!allowMissing) {
         throw new Error(`Asset not found: ${absPath}`);
@@ -18905,7 +19276,8 @@ var FORMAT_EXTENSIONS = {
   junit: ".junit.xml",
   "cucumber-json": ".cucumber.json",
   "cucumber-messages": ".ndjson",
-  confluence: ".adf.json"
+  confluence: ".adf.json",
+  "story-report-json": ".story-report.json"
 };
 var TEST_EXTENSIONS = [
   ".test.ts",
@@ -18932,11 +19304,11 @@ function computeOutputPath(sourceFile, format, mode, colocatedStyle, baseOutputD
   const ext = FORMAT_EXTENSIONS[format];
   const effectiveName = outputName + (outputNameSuffix ?? "");
   if (mode === "aggregated") {
-    return toPosix(path6.join(baseOutputDir, `${effectiveName}${ext}`));
+    return toPosix(path7.join(baseOutputDir, `${effectiveName}${ext}`));
   }
   const normalizedSource = toPosix(sourceFile);
-  const dirOfSource = path6.posix.dirname(normalizedSource);
-  let baseName = path6.posix.basename(normalizedSource);
+  const dirOfSource = path7.posix.dirname(normalizedSource);
+  let baseName = path7.posix.basename(normalizedSource);
   for (const testExt of TEST_EXTENSIONS) {
     if (baseName.endsWith(testExt)) {
       baseName = baseName.slice(0, -testExt.length);
@@ -18945,9 +19317,9 @@ function computeOutputPath(sourceFile, format, mode, colocatedStyle, baseOutputD
   }
   const fileName = `${baseName}.${effectiveName}${ext}`;
   if (colocatedStyle === "adjacent") {
-    return toPosix(path6.posix.join(dirOfSource, fileName));
+    return toPosix(path7.posix.join(dirOfSource, fileName));
   }
-  return toPosix(path6.posix.join(baseOutputDir, dirOfSource, fileName));
+  return toPosix(path7.posix.join(baseOutputDir, dirOfSource, fileName));
 }
 function groupTestCasesByOutput(testCases, format, options, logger, outputNameSuffix) {
   const groups = /* @__PURE__ */ new Map();
@@ -19030,6 +19402,9 @@ var ReportGenerator = class {
       cucumberJson: {
         pretty: options.cucumberJson?.pretty ?? false
       },
+      storyReportJson: {
+        pretty: options.storyReportJson?.pretty ?? true
+      },
       cucumberMessages: {
         uriStrategy: options.cucumberMessages?.uriStrategy ?? "sourceFile",
         includeSynthetics: options.cucumberMessages?.includeSynthetics ?? true,
@@ -19145,8 +19520,8 @@ var ReportGenerator = class {
       if (astroPaths) {
         for (const mdPath of astroPaths) {
           const content = await fsPromises.readFile(mdPath, "utf8");
-          const mdDir = path6.dirname(mdPath);
-          const assetsDir = path6.resolve(this.options.astro.assetsDir);
+          const mdDir = path7.dirname(mdPath);
+          const assetsDir = path7.resolve(this.options.astro.assetsDir);
           const result = copyMarkdownAssets({
             markdown: content,
             markdownDir: mdDir,
@@ -19177,9 +19552,9 @@ var ReportGenerator = class {
     if (groups.size === 0 && this.options.output.mode === "aggregated") {
       const ext = FORMAT_EXTENSIONS[format];
       const effectiveName = this.options.outputName + (outputNameSuffix ?? "");
-      const outputPath = toPosix(path6.join(this.options.outputDir, `${effectiveName}${ext}`));
+      const outputPath = toPosix(path7.join(this.options.outputDir, `${effectiveName}${ext}`));
       const content = await this.formatContent(run, format);
-      const dir = path6.dirname(outputPath);
+      const dir = path7.dirname(outputPath);
       await fsPromises.mkdir(dir, { recursive: true });
       await this.deps.writeFile(outputPath, content);
       return [outputPath];
@@ -19191,7 +19566,7 @@ var ReportGenerator = class {
         testCases
       };
       const content = await this.formatContent(groupRun, format);
-      const dir = path6.dirname(outputPath);
+      const dir = path7.dirname(outputPath);
       await fsPromises.mkdir(dir, { recursive: true });
       await this.deps.writeFile(outputPath, content);
       writtenPaths.push(outputPath);
@@ -19298,6 +19673,12 @@ var ReportGenerator = class {
         });
         return formatter.format(run);
       }
+      case "story-report-json": {
+        const formatter = new StoryReportJsonFormatter({
+          pretty: this.options.storyReportJson.pretty
+        });
+        return formatter.format(run);
+      }
       default:
         throw new Error(`Unknown format: ${format}`);
     }
@@ -19311,7 +19692,7 @@ async function generateRunComparison(args) {
   await fsPromises.mkdir(outputDir, { recursive: true });
   for (const format of args.formats) {
     const ext = format === "html" ? ".html" : ".md";
-    const outputPath = toPosix(path6.join(outputDir, `${outputName}${ext}`));
+    const outputPath = toPosix(path7.join(outputDir, `${outputName}${ext}`));
     const content = format === "html" ? new RunDiffHtmlFormatter({ title: args.title }).format(diff) : new RunDiffMarkdownFormatter({ title: args.title }).format(diff);
     await fsPromises.writeFile(outputPath, content, "utf8");
     files.push(outputPath);
@@ -19321,9 +19702,9 @@ async function generateRunComparison(args) {
 
 // src/init-astro.ts
 import * as fs7 from "fs";
-import * as path7 from "path";
+import * as path8 from "path";
 import { fileURLToPath } from "url";
-var __dirname = path7.dirname(fileURLToPath(import.meta.url));
+var __dirname = path8.dirname(fileURLToPath(import.meta.url));
 function initAstro(options = {}) {
   const targetDir = options.targetDir ?? "./story-docs";
   const force = options.force ?? false;
@@ -19335,7 +19716,7 @@ function initAstro(options = {}) {
       );
     }
   }
-  const templateDir = path7.resolve(__dirname, "..", "templates", "astro-starlight");
+  const templateDir = path8.resolve(__dirname, "..", "templates", "astro-starlight");
   if (!fs7.existsSync(templateDir)) {
     throw new Error(
       `Template directory not found at ${templateDir}. Ensure the package is installed correctly.`
@@ -19348,8 +19729,8 @@ function copyDirRecursive(src, dest) {
   fs7.mkdirSync(dest, { recursive: true });
   const entries = fs7.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path7.join(src, entry.name);
-    const destPath = path7.join(dest, entry.name);
+    const srcPath = path8.join(src, entry.name);
+    const destPath = path8.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath);
     } else {
@@ -19380,6 +19761,7 @@ var EXIT_SCHEMA_VALIDATION = 1;
 var EXIT_CANONICAL_VALIDATION = 2;
 var EXIT_GENERATION = 3;
 var EXIT_USAGE = 4;
+var EXIT_COMPARE_GATE = 5;
 var HELP_TEXT = `
 executable-stories \u2014 Generate reports from test results JSON.
 
@@ -19404,7 +19786,7 @@ SUBCOMMANDS
   publish-jira       Publish an ADF JSON file to a Jira issue (as comment or description)
 
 OPTIONS
-  --format <formats>            Comma-separated formats: html, markdown, junit, cucumber-json, cucumber-messages, cucumber-html, astro, confluence, or custom names from config (default: html)
+  --format <formats>            Comma-separated formats: html, markdown, junit, cucumber-json, cucumber-messages, cucumber-html, astro, confluence, story-report-json, or custom names from config (default: html)
                                   astro             Themed Markdown (for Astro docs sites with matching CSS)
                                   confluence        Atlassian Document Format (ADF) JSON for Confluence / Jira
                                   html              Custom HTML report (accessible, dark mode, mermaid)
@@ -19413,6 +19795,7 @@ OPTIONS
                                   junit             JUnit XML
                                   cucumber-json     Cucumber JSON
                                   cucumber-messages Raw NDJSON (Cucumber Messages)
+                                  story-report-json StoryReport v1 JSON (consumed by executable-stories-react and other UI renderers)
   --config <path>               Path to executable-stories.config.js (default: ./executable-stories.config.js)
   --input-type <type>           Input type: raw, canonical, or ndjson (default: raw)
   --output-dir <dir>            Output directory (default: reports)
@@ -19443,6 +19826,9 @@ OPTIONS
   --baseline-dir <dir>          Directory to scan when --baseline auto is used
   --pr-summary                  Print a PR-friendly markdown summary after compare
   --pr-summary-file <path>      Write the PR-friendly markdown summary to a file
+  --fail-on-regression          Exit non-zero when any regression is detected in compare
+  --fail-on-added-failures      Exit non-zero when newly added scenarios are failing
+  --max-regressions <n>         Exit non-zero when regressions exceed threshold
   --emit-canonical <path>       Write canonical JSON to given path
   --help                        Show this help message
 
@@ -19506,6 +19892,7 @@ EXIT CODES
   2  Canonical validation failure
   3  Formatter/generation failure
   4  Bad arguments / usage error
+  5  Compare gate failed
 `.trim();
 async function parseCliArgs(argv) {
   const args = argv.slice(2);
@@ -19607,6 +19994,9 @@ async function parseCliArgs(argv) {
       "allow-missing-assets": { type: "boolean", default: false },
       "pr-summary": { type: "boolean", default: false },
       "pr-summary-file": { type: "string" },
+      "fail-on-regression": { type: "boolean", default: false },
+      "fail-on-added-failures": { type: "boolean", default: false },
+      "max-regressions": { type: "string" },
       "config": { type: "string" },
       help: { type: "boolean", default: false }
     },
@@ -19647,7 +20037,7 @@ async function parseCliArgs(argv) {
   }
   const pluginConfig = await loadConfig(values["config"]);
   const customFormatterNames = new Set(Object.keys(pluginConfig.formatters ?? {}));
-  const builtInFormats = /* @__PURE__ */ new Set(["astro", "confluence", "html", "markdown", "junit", "cucumber-json", "cucumber-messages", "cucumber-html"]);
+  const builtInFormats = /* @__PURE__ */ new Set(["astro", "confluence", "html", "markdown", "junit", "cucumber-json", "cucumber-messages", "cucumber-html", "story-report-json"]);
   const formatStr = values.format;
   const allRequestedFormats = formatStr.split(",").map((f) => f.trim());
   const builtInRequested = allRequestedFormats.filter((f) => builtInFormats.has(f));
@@ -19655,7 +20045,7 @@ async function parseCliArgs(argv) {
   const unknownFormats = allRequestedFormats.filter((f) => !builtInFormats.has(f) && !customFormatterNames.has(f));
   if (unknownFormats.length > 0) {
     const knownCustom = customFormatterNames.size > 0 ? `, ${[...customFormatterNames].join(", ")}` : "";
-    console.error(`Error: Unknown format(s): ${unknownFormats.join(", ")}. Valid built-in: astro, confluence, html, markdown, junit, cucumber-json, cucumber-messages, cucumber-html${knownCustom}.`);
+    console.error(`Error: Unknown format(s): ${unknownFormats.join(", ")}. Valid built-in: astro, confluence, html, markdown, junit, cucumber-json, cucumber-messages, cucumber-html, story-report-json${knownCustom}.`);
     process.exit(EXIT_USAGE);
   }
   const formats = builtInRequested;
@@ -19714,6 +20104,12 @@ async function parseCliArgs(argv) {
     console.error(`Error: --max-history-runs must be a positive integer, got "${maxHistoryRunsStr}".`);
     process.exit(EXIT_USAGE);
   }
+  const maxRegressionsStr = values["max-regressions"];
+  const maxRegressions = maxRegressionsStr !== void 0 ? parseInt(maxRegressionsStr, 10) : void 0;
+  if (maxRegressionsStr !== void 0 && (isNaN(maxRegressions) || maxRegressions < 0)) {
+    console.error(`Error: --max-regressions must be a non-negative integer, got "${maxRegressionsStr}".`);
+    process.exit(EXIT_USAGE);
+  }
   const sortTestCasesRaw = values["sort-test-cases"];
   const validSortModes = /* @__PURE__ */ new Set(["id", "source", "none"]);
   if (!validSortModes.has(sortTestCasesRaw)) {
@@ -19774,6 +20170,9 @@ async function parseCliArgs(argv) {
     allowMissingAssets: values["allow-missing-assets"],
     prSummary: values["pr-summary"],
     prSummaryFile: values["pr-summary-file"],
+    failOnRegression: values["fail-on-regression"],
+    failOnAddedFailures: values["fail-on-added-failures"],
+    maxRegressions,
     config: values["config"]
   };
   return { args: cliArgs, pluginConfig, customRequested };
@@ -19782,7 +20181,7 @@ async function readInput(args) {
   if (args.stdin) {
     return readStdin();
   }
-  const filePath = path8.resolve(args.inputFile);
+  const filePath = path9.resolve(args.inputFile);
   if (!fs8.existsSync(filePath)) {
     console.error(`Error: File not found: ${filePath}`);
     process.exit(EXIT_USAGE);
@@ -19790,7 +20189,7 @@ async function readInput(args) {
   return fs8.readFileSync(filePath, "utf8");
 }
 function readFileInput(filePath) {
-  const resolved = path8.resolve(filePath);
+  const resolved = path9.resolve(filePath);
   if (!fs8.existsSync(resolved)) {
     console.error(`Error: File not found: ${resolved}`);
     process.exit(EXIT_USAGE);
@@ -19928,14 +20327,14 @@ function tryNormalizeRunFromText(text2, args) {
   }
 }
 function listBaselineCandidates(currentFile, args) {
-  const baselineDir = path8.resolve(args.baselineDir ?? path8.dirname(currentFile));
-  const currentResolved = path8.resolve(currentFile);
+  const baselineDir = path9.resolve(args.baselineDir ?? path9.dirname(currentFile));
+  const currentResolved = path9.resolve(currentFile);
   if (!fs8.existsSync(baselineDir)) {
     console.error(`Error: baseline directory not found: ${baselineDir}`);
     process.exit(EXIT_USAGE);
   }
   const entries = fs8.readdirSync(baselineDir, { withFileTypes: true });
-  return entries.filter((entry) => entry.isFile()).map((entry) => path8.join(baselineDir, entry.name)).filter((candidate) => path8.resolve(candidate) !== currentResolved).filter(
+  return entries.filter((entry) => entry.isFile()).map((entry) => path9.join(baselineDir, entry.name)).filter((candidate) => path9.resolve(candidate) !== currentResolved).filter(
     (candidate) => args.inputType === "ndjson" ? candidate.endsWith(".ndjson") : candidate.endsWith(".json")
   );
 }
@@ -19950,7 +20349,7 @@ function resolveBaselineAuto(currentFile, currentRun, args) {
   }
   if (comparable.length === 0) {
     console.error(
-      `Error: no compatible baseline files found in ${path8.resolve(args.baselineDir ?? path8.dirname(currentFile))}.`
+      `Error: no compatible baseline files found in ${path9.resolve(args.baselineDir ?? path9.dirname(currentFile))}.`
     );
     process.exit(EXIT_USAGE);
   }
@@ -19973,6 +20372,13 @@ async function main() {
     try {
       const result = await generateCompareReports(baseline, current, baselineFile, args);
       printCompareResult(result, args, startMs);
+      const gateFailures = evaluateCompareGate(result, args);
+      if (gateFailures.length > 0) {
+        for (const failure of gateFailures) {
+          console.error(`Compare gate failed: ${failure}`);
+        }
+        process.exit(EXIT_COMPARE_GATE);
+      }
       process.exit(EXIT_SUCCESS);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -20039,8 +20445,8 @@ async function main() {
       process.exit(EXIT_SCHEMA_VALIDATION);
     }
     if (args.emitCanonical) {
-      const outPath = path8.resolve(args.emitCanonical);
-      fs8.mkdirSync(path8.dirname(outPath), { recursive: true });
+      const outPath = path9.resolve(args.emitCanonical);
+      fs8.mkdirSync(path9.dirname(outPath), { recursive: true });
       fs8.writeFileSync(outPath, JSON.stringify(run, null, 2), "utf8");
     }
     try {
@@ -20098,8 +20504,8 @@ ${msg}`);
     }
     const run = data;
     if (args.emitCanonical) {
-      const outPath = path8.resolve(args.emitCanonical);
-      fs8.mkdirSync(path8.dirname(outPath), { recursive: true });
+      const outPath = path9.resolve(args.emitCanonical);
+      fs8.mkdirSync(path9.dirname(outPath), { recursive: true });
       fs8.writeFileSync(outPath, JSON.stringify(run, null, 2), "utf8");
     }
     try {
@@ -20156,8 +20562,8 @@ ${msg}`);
     process.exit(EXIT_CANONICAL_VALIDATION);
   }
   if (args.emitCanonical) {
-    const outPath = path8.resolve(args.emitCanonical);
-    fs8.mkdirSync(path8.dirname(outPath), { recursive: true });
+    const outPath = path9.resolve(args.emitCanonical);
+    fs8.mkdirSync(path9.dirname(outPath), { recursive: true });
     fs8.writeFileSync(outPath, JSON.stringify(canonical, null, 2), "utf8");
   }
   try {
@@ -20183,7 +20589,7 @@ function runCustomFormatters(run, customRequested, formatters, args) {
       const ext = formatter.fileExtension ?? formatName;
       const baseName = args.outputName ?? "report";
       const filename = args.outputNameTimestamp ? `${baseName}-${Math.floor(run.startedAtMs / 1e3)}.${ext}` : `${baseName}.${ext}`;
-      const filepath = path8.join(outputDir, filename);
+      const filepath = path9.join(outputDir, filename);
       fs8.mkdirSync(outputDir, { recursive: true });
       fs8.writeFileSync(filepath, content, "utf8");
       console.log(`Generated: ${filepath}`);
@@ -20235,7 +20641,7 @@ async function dispatchNotifications(run, args) {
 }
 function runHistoryPipeline(run, args) {
   if (!args.historyFile) return;
-  const historyPath = path8.resolve(args.historyFile);
+  const historyPath = path9.resolve(args.historyFile);
   const store = loadHistory(
     { filePath: historyPath },
     {
@@ -20254,7 +20660,7 @@ function runHistoryPipeline(run, args) {
     run,
     maxRuns: args.maxHistoryRuns
   });
-  const dir = path8.dirname(historyPath);
+  const dir = path9.dirname(historyPath);
   fs8.mkdirSync(dir, { recursive: true });
   saveHistory(
     { filePath: historyPath, store: updated },
@@ -20331,6 +20737,9 @@ async function generateCompareReports(baseline, current, baselineFile, args) {
   return {
     files: result.files,
     baselineFile,
+    addedFailures: result.diff.scenarios.filter(
+      (scenario) => scenario.kind === "added" && scenario.current?.status === "failed"
+    ).length,
     summary: result.diff.summary,
     prSummary: args.prSummary || args.prSummaryFile ? createPrCommentSummary(result.diff) : void 0
   };
@@ -20356,8 +20765,8 @@ function printResult(result, args, startMs, droppedMissingStory = 0) {
 function printCompareResult(result, args, startMs) {
   const durationMs = Date.now() - startMs;
   if (result.prSummary && args.prSummaryFile) {
-    const outputPath = path8.resolve(args.prSummaryFile);
-    fs8.mkdirSync(path8.dirname(outputPath), { recursive: true });
+    const outputPath = path9.resolve(args.prSummaryFile);
+    fs8.mkdirSync(path9.dirname(outputPath), { recursive: true });
     fs8.writeFileSync(outputPath, result.prSummary, "utf8");
   }
   if (args.jsonSummary) {
@@ -20366,6 +20775,7 @@ function printCompareResult(result, args, startMs) {
         {
           files: result.files,
           baselineFile: result.baselineFile,
+          addedFailures: result.addedFailures,
           diff: result.summary,
           prSummary: result.prSummary,
           durationMs
@@ -20385,6 +20795,25 @@ function printCompareResult(result, args, startMs) {
     console.log(result.prSummary);
   }
 }
+function evaluateCompareGate(result, args) {
+  const failures = [];
+  if (args.failOnRegression && result.summary.regressed > 0) {
+    failures.push(
+      `regressions detected (${result.summary.regressed}) with --fail-on-regression`
+    );
+  }
+  if (args.failOnAddedFailures && result.addedFailures > 0) {
+    failures.push(
+      `new failing scenarios detected (${result.addedFailures}) with --fail-on-added-failures`
+    );
+  }
+  if (args.maxRegressions !== void 0 && result.summary.regressed > args.maxRegressions) {
+    failures.push(
+      `regressions ${result.summary.regressed} exceed --max-regressions ${args.maxRegressions}`
+    );
+  }
+  return failures;
+}
 async function runPublishConfluence(rawArgs) {
   const { values, positionals } = parseArgs({
     args: rawArgs,
@@ -20457,7 +20886,7 @@ Generate an API token at https://id.atlassian.com/manage-profile/security/api-to
     console.error("Error: --title is required when creating a new page");
     process.exit(EXIT_USAGE);
   }
-  const adf = fs8.readFileSync(path8.resolve(inputFile), "utf8");
+  const adf = fs8.readFileSync(path9.resolve(inputFile), "utf8");
   if (dryRun) {
     console.log(
       JSON.stringify(
@@ -20563,7 +20992,7 @@ Generate an API token at https://id.atlassian.com/manage-profile/security/api-to
     process.exit(EXIT_USAGE);
   }
   const mode = modeRaw;
-  const adf = fs8.readFileSync(path8.resolve(inputFile), "utf8");
+  const adf = fs8.readFileSync(path9.resolve(inputFile), "utf8");
   if (dryRun) {
     console.log(
       JSON.stringify(