executable-stories-formatters 0.16.0 → 0.17.0

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
 import "fs";
-import * as path11 from "path";
+import * as path12 from "path";
 import * as fsPromises from "fs/promises";
 
 // src/converters/acl/status.ts
@@ -51,7 +51,7 @@ function tokenize(text2) {
 }
 function behaviourFingerprint(input) {
   const steps = input.steps.map((step) => `${step.keyword.toLowerCase()}:${normalizeText(step.text)}`).join("\n");
-  const covers = [...input.covers ?? []].map((path12) => path12.trim()).filter(Boolean).sort().join(",");
+  const covers = [...input.covers ?? []].map((path13) => path13.trim()).filter(Boolean).sort().join(",");
   if (steps.length === 0 && covers.length === 0) return "";
   return createHash("sha1").update(`${steps}\0${covers}`).digest("hex").slice(0, 16);
 }
@@ -14274,12 +14274,12 @@ function hasSufficientHistory(entries, min) {
 }
 
 // src/formatters/html/renderers/scenario.ts
-function renderTicket(ticket, template, escapeHtml4) {
+function renderTicket(ticket, template, escapeHtml5) {
   const url = ticket.url ?? (template ? template.replace("{ticket}", ticket.id) : void 0);
   if (url) {
-    return `<a class="tag ticket-tag" href="${escapeHtml4(url)}" target="_blank" rel="noopener noreferrer">${escapeHtml4(ticket.id)}</a>`;
+    return `<a class="tag ticket-tag" href="${escapeHtml5(url)}" target="_blank" rel="noopener noreferrer">${escapeHtml5(ticket.id)}</a>`;
   }
-  return `<span class="tag ticket-tag">${escapeHtml4(ticket.id)}</span>`;
+  return `<span class="tag ticket-tag">${escapeHtml5(ticket.id)}</span>`;
 }
 function renderScenario(args, deps) {
   const { tc } = args;
@@ -14479,7 +14479,7 @@ function flattenTree(roots) {
   }
   return result;
 }
-function buildTooltip(span, escapeHtml4) {
+function buildTooltip(span, escapeHtml5) {
   const parts = [];
   parts.push(`${span.name} (${formatDuration(span.durationMs)})`);
   if (span.statusMessage) {
@@ -14497,7 +14497,7 @@ function buildTooltip(span, escapeHtml4) {
   if (text2.length > TOOLTIP_MAX_LENGTH) {
     text2 = text2.slice(0, TOOLTIP_MAX_LENGTH - 3) + "...";
   }
-  return escapeHtml4(text2);
+  return escapeHtml5(text2);
 }
 function renderTraceView(args, deps) {
   if (!args.spans || args.spans.length === 0) return "";
@@ -15792,14 +15792,14 @@ var TraceabilityMatrixFormatter = class {
       lines.push("");
       lines.push(`Status: ${renderRequirementStatus(req.status)}`);
       if (req.covers.length > 0) {
-        lines.push(`Covers: ${req.covers.map((path12) => `\`${path12}\``).join(", ")}`);
+        lines.push(`Covers: ${req.covers.map((path13) => `\`${path13}\``).join(", ")}`);
       }
       lines.push("");
       lines.push("| Status | Scenario | Source | Covers |");
       lines.push("| --- | --- | --- | --- |");
       for (const scenario of req.scenarios) {
         const source = `${scenario.sourceFile}:${scenario.sourceLine}`;
-        const covers = scenario.covers.length > 0 ? scenario.covers.map((path12) => `\`${path12}\``).join(", ") : "";
+        const covers = scenario.covers.length > 0 ? scenario.covers.map((path13) => `\`${path13}\``).join(", ") : "";
         lines.push(`| ${scenario.status} | ${escapePipe2(scenario.title)} | \`${source}\` | ${covers} |`);
       }
       lines.push("");
@@ -15901,8 +15901,8 @@ function extractFeatureName(testCases, uri) {
       return tc.titlePath[0];
     }
   }
-  const basename3 = uri.replace(/^.*[\\/]/, "").replace(/\.[^.]+$/, "");
-  return basename3.replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  const basename4 = uri.replace(/^.*[\\/]/, "").replace(/\.[^.]+$/, "");
+  return basename4.replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
 function synthesizeFeature(uri, testCases) {
   const featureName = extractFeatureName(testCases, uri);
@@ -16514,8 +16514,8 @@ function extractDocAttachments(step) {
   }
   return attachments;
 }
-function guessMediaType(path12) {
-  const lower = path12.toLowerCase();
+function guessMediaType(path13) {
+  const lower = path13.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";
@@ -16656,11 +16656,11 @@ var CucumberHtmlFormatter = class {
     for (const envelope of envelopes) {
       const accepted = htmlStream.write(envelope);
       if (!accepted) {
-        await new Promise((resolve9) => htmlStream.once("drain", resolve9));
+        await new Promise((resolve10) => htmlStream.once("drain", resolve10));
       }
     }
-    await new Promise((resolve9, reject) => {
-      collector.on("finish", resolve9);
+    await new Promise((resolve10, reject) => {
+      collector.on("finish", resolve10);
       collector.on("error", reject);
       htmlStream.end();
     });
@@ -18824,14 +18824,14 @@ ${result.errors.join("\n")}`);
 }
 
 // src/coverage-index.ts
-function normalizePath(path12) {
-  return path12.replace(/^\.\//, "");
+function normalizePath(path13) {
+  return path13.replace(/^\.\//, "");
 }
 function scenariosCoveringPaths(index, paths) {
   const queries = paths.map(normalizePath);
   return index.scenarios.filter(
     (scenario) => scenario.covers.some(
-      (glob) => queries.some((path12) => matchesPattern(normalizePath(glob), path12))
+      (glob) => queries.some((path13) => matchesPattern(normalizePath(glob), path13))
     )
   );
 }
@@ -18907,7 +18907,7 @@ function toRun(data, inputType, synthesize) {
   if (synthesize) raw = synthesizeStories(raw);
   return canonicalizeRun(raw);
 }
-async function regenerateArtifacts(options, deps = {}) {
+async function regenerateRun(options, deps = {}) {
   const read = deps.readFile ?? ((filePath) => fs6.readFileSync(filePath, "utf8"));
   const data = JSON.parse(read(path7.resolve(options.input)));
   const run = toRun(data, options.inputType ?? "raw", options.synthesize !== false);
@@ -18917,7 +18917,10 @@ async function regenerateArtifacts(options, deps = {}) {
     outputName: options.outputName
   });
   const result = await generator.generate(run);
-  return [...result.values()].flat();
+  return { files: [...result.values()].flat(), run };
+}
+async function regenerateArtifacts(options, deps = {}) {
+  return (await regenerateRun(options, deps)).files;
 }
 function startWatch(options, deps = {}) {
   const log = deps.log ?? ((message) => console.log(message));
@@ -18960,6 +18963,203 @@ function startWatch(options, deps = {}) {
   };
 }
 
+// src/serve.ts
+import * as fs7 from "fs";
+import * as http from "http";
+import * as path8 from "path";
+function advanceState(prev, run) {
+  if (prev.sessionBaseline === null) {
+    return { sessionBaseline: run, previous: null, current: run, runCount: 1 };
+  }
+  return {
+    sessionBaseline: prev.sessionBaseline,
+    previous: prev.current,
+    current: run,
+    runCount: prev.runCount + 1
+  };
+}
+function computeDeltas(state) {
+  if (state.current === null || state.sessionBaseline === null || state.runCount <= 1) {
+    return { session: null, iteration: null };
+  }
+  return {
+    session: diffRuns(state.sessionBaseline, state.current),
+    iteration: state.previous ? diffRuns(state.previous, state.current) : null
+  };
+}
+function pluralize(n, word) {
+  return `${n} ${word}${n === 1 ? "" : "s"}`;
+}
+function summarizeDiff(diff) {
+  const s = diff.summary;
+  const parts = [];
+  if (s.fixed > 0) parts.push(`+${pluralize(s.fixed, "passing")}`);
+  if (s.regressed > 0) parts.push(`${pluralize(s.regressed, "regressed")}`);
+  if (s.added > 0) parts.push(`${pluralize(s.added, "new behaviour")}`);
+  if (s.removed > 0) parts.push(`${pluralize(s.removed, "removed")}`);
+  const moved = s.renamed + s.moved;
+  if (moved > 0) parts.push(`${pluralize(moved, "renamed")}`);
+  if (s.changed > 0) parts.push(`${pluralize(s.changed, "changed")}`);
+  return parts.length > 0 ? parts.join(", ") : null;
+}
+function escapeHtml3(text2) {
+  return text2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function renderDeltaStrip(state) {
+  if (state.current === null) return "";
+  const { session, iteration } = computeDeltas(state);
+  if (session === null) {
+    const label = `Run #${state.runCount} captured \u2014 baseline pinned. Watching for changes\u2026`;
+    return `<div data-es-live="strip"><strong>Live</strong> \xB7 ${escapeHtml3(label)}</div>`;
+  }
+  const sessionLine = summarizeDiff(session) ?? "no change yet";
+  let detail = "";
+  if (iteration) {
+    const iterationLine = summarizeDiff(iteration);
+    if (iterationLine) detail = ` \xB7 <span data-es-live="iteration">this iteration: ${escapeHtml3(iterationLine)}</span>`;
+  }
+  return [
+    `<div data-es-live="strip">`,
+    `<strong>Live</strong> \xB7 run #${state.runCount} \xB7 `,
+    `<span data-es-live="session">since you started: ${escapeHtml3(sessionLine)}</span>`,
+    detail,
+    `</div>`
+  ].join("");
+}
+var RELOAD_CLIENT = `<script data-es-live="client">
+(function () {
+  try {
+    var es = new EventSource("/__es_reload");
+    es.onmessage = function (e) { if (e.data === "reload") location.reload(); };
+  } catch (err) { /* SSE unavailable: stay static */ }
+})();
+</script>`;
+var STRIP_STYLE = `<style data-es-live="style">
+[data-es-live="strip"]{position:sticky;top:0;z-index:9999;font:14px/1.5 system-ui,sans-serif;
+padding:8px 16px;background:#0b1021;color:#e6e9f5;border-bottom:1px solid #2a3052}
+[data-es-live="strip"] strong{color:#7dd3fc}
+</style>`;
+function injectLiveBits(html, stripHtml) {
+  let out = html;
+  const bodyOpen = out.match(/<body[^>]*>/i);
+  if (bodyOpen) {
+    const at = bodyOpen.index + bodyOpen[0].length;
+    out = out.slice(0, at) + stripHtml + out.slice(at);
+  } else {
+    out = stripHtml + out;
+  }
+  const tail = STRIP_STYLE + RELOAD_CLIENT;
+  if (/<\/body>/i.test(out)) {
+    out = out.replace(/<\/body>/i, tail + "</body>");
+  } else {
+    out += tail;
+  }
+  return out;
+}
+var CONTENT_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png"
+};
+function watchInputDir(filePath, listener) {
+  const dir = path8.dirname(filePath);
+  const base = path8.basename(filePath);
+  fs7.mkdirSync(dir, { recursive: true });
+  const watcher = fs7.watch(dir, (_event, changed) => {
+    if (!changed || changed === base) listener();
+  });
+  return { close: () => watcher.close() };
+}
+function plainText(html) {
+  return html.replace(/<[^>]+>/g, "").trim();
+}
+function startServe(options, deps = {}) {
+  const log = deps.log ?? ((message) => console.log(message));
+  const read = deps.readFile ?? ((filePath) => fs7.readFileSync(filePath, "utf8"));
+  const port = options.port ?? 4321;
+  const host = options.host ?? "127.0.0.1";
+  let state = { sessionBaseline: null, previous: null, current: null, runCount: 0 };
+  let htmlPath = null;
+  let stripHtml = renderDeltaStrip(state);
+  const clients = /* @__PURE__ */ new Set();
+  const pushReload = () => {
+    for (const res of clients) res.write("data: reload\n\n");
+  };
+  const handler = (req, res) => {
+    const url = (req.url ?? "/").split("?")[0];
+    if (url === "/__es_reload") {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      });
+      res.write("retry: 1000\n\n");
+      clients.add(res);
+      req.on("close", () => clients.delete(res));
+      return;
+    }
+    if (url === "/" || url === "/index.html") {
+      const html = htmlPath ? read(htmlPath) : "<!doctype html><html><body><h1>executable-stories</h1></body></html>";
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(injectLiveBits(html, stripHtml));
+      return;
+    }
+    const safe = path8.normalize(url).replace(/^(\.\.[/\\])+/, "");
+    const filePath = path8.join(path8.resolve(options.outputDir), safe);
+    if (filePath.startsWith(path8.resolve(options.outputDir)) && fs7.existsSync(filePath)) {
+      const ext = path8.extname(filePath).toLowerCase();
+      res.writeHead(200, { "Content-Type": CONTENT_TYPES[ext] ?? "application/octet-stream" });
+      res.end(read(filePath));
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not found");
+  };
+  const server = deps.createServer ? deps.createServer(handler) : http.createServer(handler);
+  const watchOptions = {
+    input: options.input,
+    outputDir: options.outputDir,
+    outputName: options.outputName,
+    formats: options.formats,
+    inputType: options.inputType ?? "raw",
+    synthesize: options.synthesize !== false,
+    debounceMs: options.debounceMs
+  };
+  const watchHandle = startWatch(watchOptions, {
+    readFile: read,
+    watch: deps.watch ?? watchInputDir,
+    log: () => {
+    },
+    // serve emits its own per-run line below
+    regenerate: async (input) => {
+      if (!fs7.existsSync(path8.resolve(input))) return [];
+      const { files, run } = await regenerateRun({ ...watchOptions, input }, { readFile: read });
+      htmlPath = files.find((f) => f.endsWith(".html")) ?? htmlPath;
+      state = advanceState(state, run);
+      stripHtml = renderDeltaStrip(state);
+      log(`Run #${state.runCount}: ${plainText(stripHtml)}`);
+      pushReload();
+      return files;
+    }
+  });
+  server.listen(port, host);
+  const address = server.address();
+  const boundPort = typeof address === "object" && address ? address.port : port;
+  log(`Live docs: http://${host}:${boundPort} (Ctrl+C to stop)`);
+  return {
+    port: boundPort,
+    close: () => {
+      watchHandle.close();
+      for (const res of clients) res.end();
+      clients.clear();
+      server.close();
+    }
+  };
+}
+
 // src/behavior-diff.ts
 function classifyStatusChange(baseline, current) {
   if (baseline === void 0) return "added";
@@ -19599,27 +19799,27 @@ function pickleStepArgumentToDocs(ps) {
 }
 
 // src/utils/git-info.ts
-import * as fs7 from "fs";
-import * as path8 from "path";
+import * as fs8 from "fs";
+import * as path9 from "path";
 function readGitSha(cwd = process.cwd()) {
   const envSha = process.env.GITHUB_SHA || process.env.GIT_COMMIT || process.env.CI_COMMIT_SHA;
   if (envSha) return envSha;
   const gitDir = findGitDir(cwd);
   if (!gitDir) return void 0;
   try {
-    const headPath = path8.join(gitDir, "HEAD");
-    const head = fs7.readFileSync(headPath, "utf8").trim();
+    const headPath = path9.join(gitDir, "HEAD");
+    const head = fs8.readFileSync(headPath, "utf8").trim();
     if (!head.startsWith("ref:")) {
       return head;
     }
     const refPath = head.replace("ref:", "").trim();
-    const refFile = path8.join(gitDir, refPath);
-    if (fs7.existsSync(refFile)) {
-      return fs7.readFileSync(refFile, "utf8").trim();
+    const refFile = path9.join(gitDir, refPath);
+    if (fs8.existsSync(refFile)) {
+      return fs8.readFileSync(refFile, "utf8").trim();
     }
-    const packedRefs = path8.join(gitDir, "packed-refs");
-    if (fs7.existsSync(packedRefs)) {
-      const content = fs7.readFileSync(packedRefs, "utf8");
+    const packedRefs = path9.join(gitDir, "packed-refs");
+    if (fs8.existsSync(packedRefs)) {
+      const content = fs8.readFileSync(packedRefs, "utf8");
       for (const line of content.split("\n")) {
         if (!line || line.startsWith("#") || line.startsWith("^")) continue;
         const [sha, ref] = line.split(" ");
@@ -19634,19 +19834,19 @@ function readGitSha(cwd = process.cwd()) {
 function findGitDir(start) {
   let current = start;
   while (true) {
-    const candidate = path8.join(current, ".git");
-    if (fs7.existsSync(candidate)) {
-      const stat = fs7.statSync(candidate);
+    const candidate = path9.join(current, ".git");
+    if (fs8.existsSync(candidate)) {
+      const stat = fs8.statSync(candidate);
       if (stat.isFile()) {
-        const content = fs7.readFileSync(candidate, "utf8").trim();
+        const content = fs8.readFileSync(candidate, "utf8").trim();
         const match = content.match(/^gitdir: (.+)$/);
         if (match) {
-          return path8.resolve(current, match[1]);
+          return path9.resolve(current, match[1]);
         }
       }
       return candidate;
     }
-    const parent = path8.dirname(current);
+    const parent = path9.dirname(current);
     if (parent === current) return void 0;
     current = parent;
   }
@@ -19657,8 +19857,8 @@ function readBranchName(cwd = process.cwd()) {
   const gitDir = findGitDir(cwd);
   if (!gitDir) return void 0;
   try {
-    const headPath = path8.join(gitDir, "HEAD");
-    const head = fs7.readFileSync(headPath, "utf8").trim();
+    const headPath = path9.join(gitDir, "HEAD");
+    const head = fs8.readFileSync(headPath, "utf8").trim();
     if (head.startsWith("ref:")) {
       const refPath = head.replace("ref:", "").trim();
       const match = refPath.match(/^refs\/heads\/(.+)$/);
@@ -19695,8 +19895,8 @@ function nanosecondsToMs(ns) {
 }
 
 // src/utils/metadata.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
+import * as fs9 from "fs";
+import * as path10 from "path";
 var versionCache = /* @__PURE__ */ new Map();
 function readPackageVersion(root) {
   if (versionCache.has(root)) {
@@ -19707,18 +19907,18 @@ function readPackageVersion(root) {
   return version;
 }
 function findPackageVersion(startDir) {
-  let current = path9.resolve(startDir);
+  let current = path10.resolve(startDir);
   while (true) {
-    const pkgPath = path9.join(current, "package.json");
+    const pkgPath = path10.join(current, "package.json");
     try {
-      if (fs8.existsSync(pkgPath)) {
-        const raw = fs8.readFileSync(pkgPath, "utf8");
+      if (fs9.existsSync(pkgPath)) {
+        const raw = fs9.readFileSync(pkgPath, "utf8");
         const parsed = JSON.parse(raw);
         return parsed.version;
       }
     } catch {
     }
-    const parent = path9.dirname(current);
+    const parent = path10.dirname(current);
     if (parent === current) {
       return void 0;
     }
@@ -21046,18 +21246,18 @@ function deriveChangeType(tags) {
   }
   return "unknown";
 }
-function extensionOf(path12) {
-  const base = path12.split("/").pop() ?? path12;
+function extensionOf(path13) {
+  const base = path13.split("/").pop() ?? path13;
   const dot = base.lastIndexOf(".");
   return dot === -1 ? "" : base.slice(dot + 1).toLowerCase();
 }
-function isTestFile(path12) {
-  return TEST_INFIX.test(path12);
+function isTestFile(path13) {
+  return TEST_INFIX.test(path13);
 }
-function isReviewableSource(path12) {
-  if (isTestFile(path12)) return false;
-  if (path12.endsWith(".d.ts")) return false;
-  return CODE_EXTENSIONS.has(extensionOf(path12));
+function isReviewableSource(path13) {
+  if (isTestFile(path13)) return false;
+  if (path13.endsWith(".d.ts")) return false;
+  return CODE_EXTENSIONS.has(extensionOf(path13));
 }
 function testBaseKey(testFile) {
   return testFile.replace(TEST_INFIX, "");
@@ -21161,7 +21361,7 @@ function toClaim(testCase, changedSourcePaths) {
   const { strength, reasons } = gradeEvidence(testCase, audience);
   const key = testBaseKey(testCase.sourceFile);
   const coversFiles = changedSourcePaths.filter(
-    (path12) => sourceBaseKey(path12) === key
+    (path13) => sourceBaseKey(path13) === key
   );
   return {
     id: testCase.id,
@@ -21410,7 +21610,7 @@ var ReviewMarkdownFormatter = class {
 };
 
 // src/formatters/review-html.ts
-function escapeHtml3(value) {
+function escapeHtml4(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 var STRENGTH_LABEL = {
@@ -21432,22 +21632,22 @@ function statusIcon3(status) {
   }
 }
 function formatStep3(step) {
-  return `<li><strong>${escapeHtml3(step.keyword)}</strong> ${escapeHtml3(step.text)}</li>`;
+  return `<li><strong>${escapeHtml4(step.keyword)}</strong> ${escapeHtml4(step.text)}</li>`;
 }
 function inlineDoc(doc) {
   switch (doc.kind) {
     case "note":
-      return escapeHtml3(doc.text);
+      return escapeHtml4(doc.text);
     case "section":
-      return `<strong>${escapeHtml3(doc.title)}</strong>: ${escapeHtml3(doc.markdown)}`;
+      return `<strong>${escapeHtml4(doc.title)}</strong>: ${escapeHtml4(doc.markdown)}`;
     case "kv":
-      return `${escapeHtml3(doc.label)}: ${escapeHtml3(String(doc.value))}`;
+      return `${escapeHtml4(doc.label)}: ${escapeHtml4(String(doc.value))}`;
     case "code":
-      return `${escapeHtml3(doc.label)}: <code>${escapeHtml3(doc.content)}</code>`;
+      return `${escapeHtml4(doc.label)}: <code>${escapeHtml4(doc.content)}</code>`;
     case "link":
-      return `${escapeHtml3(doc.label)}: ${escapeHtml3(doc.url)}`;
+      return `${escapeHtml4(doc.label)}: ${escapeHtml4(doc.url)}`;
     default:
-      return escapeHtml3(doc.kind);
+      return escapeHtml4(doc.kind);
   }
 }
 function renderEvidenceArtifacts(testCase) {
@@ -21455,7 +21655,7 @@ function renderEvidenceArtifacts(testCase) {
   for (const att of testCase.attachments) {
     if (att.mediaType.startsWith("image/") && att.contentEncoding === "BASE64") {
       parts.push(
-        `<img class="shot" alt="${escapeHtml3(att.name)}" src="data:${escapeHtml3(att.mediaType)};base64,${att.body}" />`
+        `<img class="shot" alt="${escapeHtml4(att.name)}" src="data:${escapeHtml4(att.mediaType)};base64,${att.body}" />`
       );
     }
   }
@@ -21470,22 +21670,22 @@ function renderTicketPills(claim) {
   const tickets = claim.testCase.story.tickets ?? [];
   if (tickets.length === 0) return "";
   return `<div class="ticket-row">${tickets.map((ticket) => {
-    const label = escapeHtml3(ticket.id);
+    const label = escapeHtml4(ticket.id);
     if (ticket.url) {
-      return `<a class="ticket-pill" href="${escapeHtml3(ticket.url)}" target="_blank" rel="noopener noreferrer">${label}</a>`;
+      return `<a class="ticket-pill" href="${escapeHtml4(ticket.url)}" target="_blank" rel="noopener noreferrer">${label}</a>`;
     }
     return `<span class="ticket-pill">${label}</span>`;
   }).join("")}</div>`;
 }
 function renderClaimCard(claim) {
   const ticketSearch = (claim.testCase.story.tickets ?? []).map((ticket) => ticket.id).join(" ");
-  const search = escapeHtml3(
+  const search = escapeHtml4(
     `${claim.scenario} ${claim.sourceFile} ${claim.changeType} ${claim.audience} ${claim.strength} ${ticketSearch}`
   ).toLowerCase();
   const steps = claim.testCase.story.steps.length > 0 ? `<ul class="step-list">${claim.testCase.story.steps.map(formatStep3).join("")}</ul>` : "";
-  const reasons = `<ul class="reasons">${claim.strengthReasons.map((r) => `<li>${escapeHtml3(r)}</li>`).join("")}</ul>`;
-  const intent = claim.intent !== void 0 ? `<div class="intent"><span class="intent-label">Why</span> ${escapeHtml3(claim.intent)}</div>` : "";
-  const covers = claim.coversFiles.length > 0 ? `<p class="covers">Covers ${claim.coversFiles.map((f) => `<code>${escapeHtml3(f)}</code>`).join(", ")}</p>` : "";
+  const reasons = `<ul class="reasons">${claim.strengthReasons.map((r) => `<li>${escapeHtml4(r)}</li>`).join("")}</ul>`;
+  const intent = claim.intent !== void 0 ? `<div class="intent"><span class="intent-label">Why</span> ${escapeHtml4(claim.intent)}</div>` : "";
+  const covers = claim.coversFiles.length > 0 ? `<p class="covers">Covers ${claim.coversFiles.map((f) => `<code>${escapeHtml4(f)}</code>`).join(", ")}</p>` : "";
   const docs = (claim.testCase.story.docs ?? []).filter(
     (d) => d.kind === "section" || d.kind === "note"
   );
@@ -21495,9 +21695,9 @@ function renderClaimCard(claim) {
       <header class="claim-header">
         <div>
           <span class="strength-badge strength-${claim.strength}">${STRENGTH_LABEL[claim.strength]}</span>
-          ${claim.changeType !== "unknown" ? `<span class="change-pill">${escapeHtml3(claim.changeType)}</span>` : ""}
-          <h3>${statusIcon3(claim.status)} ${escapeHtml3(claim.scenario)}</h3>
-          <p class="source">${escapeHtml3(`${claim.sourceFile}:${claim.sourceLine}`)}</p>
+          ${claim.changeType !== "unknown" ? `<span class="change-pill">${escapeHtml4(claim.changeType)}</span>` : ""}
+          <h3>${statusIcon3(claim.status)} ${escapeHtml4(claim.scenario)}</h3>
+          <p class="source">${escapeHtml4(`${claim.sourceFile}:${claim.sourceLine}`)}</p>
           ${renderTicketPills(claim)}
         </div>
       </header>
@@ -21512,18 +21712,18 @@ function renderClaimCard(claim) {
     </article>`;
 }
 function renderChangedFileRow(file) {
-  const claims = file.claims.length > 0 ? file.claims.map((c) => `${escapeHtml3(c.scenario)} <em>(${c.strength})</em>`).join(", ") : "\u2014";
+  const claims = file.claims.length > 0 ? file.claims.map((c) => `${escapeHtml4(c.scenario)} <em>(${c.strength})</em>`).join(", ") : "\u2014";
   return `<tr data-band="${file.band}">
     <td><span class="band-dot band-${file.band}"></span></td>
-    <td><code>${escapeHtml3(file.path)}</code></td>
-    <td>${escapeHtml3(file.changeKind)}</td>
+    <td><code>${escapeHtml4(file.path)}</code></td>
+    <td>${escapeHtml4(file.changeKind)}</td>
     <td>${claims}</td>
   </tr>`;
 }
 function renderAudienceSection2(title, claims) {
   if (claims.length === 0) return "";
   return `<section class="audience-section">
-    <h2>${escapeHtml3(title)} <span class="count">${claims.length}</span></h2>
+    <h2>${escapeHtml4(title)} <span class="count">${claims.length}</span></h2>
     <div class="claim-list">${claims.map(renderClaimCard).join("\n")}</div>
   </section>`;
 }
@@ -21613,13 +21813,13 @@ var ReviewHtmlFormatter = class {
     const themeInitJs = this.darkMode ? `${JS_THEME_TOGGLE2}
 applyTheme(getEffectiveTheme());` : "";
     const themeAttr = this.darkMode ? ' data-theme="light"' : "";
-    const refsLine = context.baseRef || context.headRef ? `<p class="subtle">Comparing ${escapeHtml3(context.baseRef ?? "base")} \u2192 ${escapeHtml3(context.headRef ?? "head")}</p>` : "";
+    const refsLine = context.baseRef || context.headRef ? `<p class="subtle">Comparing ${escapeHtml4(context.baseRef ?? "base")} \u2192 ${escapeHtml4(context.headRef ?? "head")}</p>` : "";
     return `<!doctype html>
 <html lang="en"${themeAttr}>
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>${escapeHtml3(this.title)}</title>
+    <title>${escapeHtml4(this.title)}</title>
     <style>
       ${this.theme.css}
       ${REVIEW_CSS}
@@ -21629,7 +21829,7 @@ applyTheme(getEffectiveTheme());` : "";
     <main>
       <div class="hero-card card">
         <div class="review-header">
-          <h1>${escapeHtml3(this.title)}</h1>
+          <h1>${escapeHtml4(this.title)}</h1>
           ${themeToggleHtml}
         </div>
         ${refsLine}
@@ -21644,7 +21844,7 @@ applyTheme(getEffectiveTheme());` : "";
       </section>
       <section class="card priority-banner">
         <h2>Review priority</h2>
-        <p class="subtle">${escapeHtml3(priority)}</p>
+        <p class="subtle">${escapeHtml4(priority)}</p>
       </section>
       ${changedFilesPanel}
       <section class="toolbar">
@@ -21692,8 +21892,8 @@ applyTheme(getEffectiveTheme());` : "";
 };
 
 // src/deploy/ledger.ts
-import * as fs9 from "fs";
-import * as path10 from "path";
+import * as fs10 from "fs";
+import * as path11 from "path";
 function createEmptyLedger() {
   return {
     deployments: [],
@@ -21701,12 +21901,12 @@ function createEmptyLedger() {
   };
 }
 function loadLedger(ledgerPath) {
-  const resolved = path10.resolve(ledgerPath);
-  if (!fs9.existsSync(resolved)) {
+  const resolved = path11.resolve(ledgerPath);
+  if (!fs10.existsSync(resolved)) {
     return createEmptyLedger();
   }
   try {
-    const raw = JSON.parse(fs9.readFileSync(resolved, "utf8"));
+    const raw = JSON.parse(fs10.readFileSync(resolved, "utf8"));
     if (raw.schemaVersion !== 1) {
       throw new Error(`Unsupported ledger schemaVersion: ${raw.schemaVersion}`);
     }
@@ -21717,10 +21917,10 @@ function loadLedger(ledgerPath) {
   }
 }
 function saveLedger(ledger, ledgerPath) {
-  const resolved = path10.resolve(ledgerPath);
-  const dir = path10.dirname(resolved);
-  fs9.mkdirSync(dir, { recursive: true });
-  fs9.writeFileSync(resolved, JSON.stringify(ledger, null, 2), "utf8");
+  const resolved = path11.resolve(ledgerPath);
+  const dir = path11.dirname(resolved);
+  fs10.mkdirSync(dir, { recursive: true });
+  fs10.writeFileSync(resolved, JSON.stringify(ledger, null, 2), "utf8");
 }
 function getLatestDeployment(ledger, environment) {
   return [...ledger.deployments].reverse().find((d) => d.environment === environment);
@@ -21840,11 +22040,11 @@ function computeOutputPath(sourceFile, format, mode, colocatedStyle, baseOutputD
   const ext = FORMAT_EXTENSIONS[format];
   const effectiveName = outputName + (outputNameSuffix ?? "");
   if (mode === "aggregated") {
-    return toPosix(path11.join(baseOutputDir, joinNameAndExt(effectiveName, ext)));
+    return toPosix(path12.join(baseOutputDir, joinNameAndExt(effectiveName, ext)));
   }
   const normalizedSource = toPosix(sourceFile);
-  const dirOfSource = path11.posix.dirname(normalizedSource);
-  let baseName = path11.posix.basename(normalizedSource);
+  const dirOfSource = path12.posix.dirname(normalizedSource);
+  let baseName = path12.posix.basename(normalizedSource);
   for (const testExt of TEST_EXTENSIONS) {
     if (baseName.endsWith(testExt)) {
       baseName = baseName.slice(0, -testExt.length);
@@ -21853,12 +22053,12 @@ function computeOutputPath(sourceFile, format, mode, colocatedStyle, baseOutputD
   }
   const fileName = `${baseName}.${effectiveName}${ext}`;
   if (colocatedStyle === "adjacent") {
-    return toPosix(path11.posix.join(dirOfSource, fileName));
+    return toPosix(path12.posix.join(dirOfSource, fileName));
   }
   if (colocatedStyle === "flat") {
-    return toPosix(path11.posix.join(baseOutputDir, `${cleanTestStem(normalizedSource)}${ext}`));
+    return toPosix(path12.posix.join(baseOutputDir, `${cleanTestStem(normalizedSource)}${ext}`));
   }
-  return toPosix(path11.posix.join(baseOutputDir, dirOfSource, fileName));
+  return toPosix(path12.posix.join(baseOutputDir, dirOfSource, fileName));
 }
 function groupTestCasesByOutput(testCases, format, options, logger, outputNameSuffix) {
   const groups = /* @__PURE__ */ new Map();
@@ -22071,8 +22271,8 @@ var ReportGenerator = class {
       if (astroPaths) {
         for (const mdPath of astroPaths) {
           const content = await fsPromises.readFile(mdPath, "utf8");
-          const mdDir = path11.dirname(mdPath);
-          const assetsDir = path11.resolve(this.options.astro.assetsDir);
+          const mdDir = path12.dirname(mdPath);
+          const assetsDir = path12.resolve(this.options.astro.assetsDir);
           const result = copyMarkdownAssets({
             markdown: content,
             markdownDir: mdDir,
@@ -22103,9 +22303,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(path11.join(this.options.outputDir, joinNameAndExt(effectiveName, ext)));
+      const outputPath = toPosix(path12.join(this.options.outputDir, joinNameAndExt(effectiveName, ext)));
       const content = await this.formatContent(run, format);
-      const dir = path11.dirname(outputPath);
+      const dir = path12.dirname(outputPath);
       await fsPromises.mkdir(dir, { recursive: true });
       await this.deps.writeFile(outputPath, content);
       return [outputPath];
@@ -22117,7 +22317,7 @@ var ReportGenerator = class {
         testCases
       };
       const content = await this.formatContent(groupRun, format);
-      const dir = path11.dirname(outputPath);
+      const dir = path12.dirname(outputPath);
       await fsPromises.mkdir(dir, { recursive: true });
       await this.deps.writeFile(outputPath, content);
       writtenPaths.push(outputPath);
@@ -22269,7 +22469,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(path11.join(outputDir, `${outputName}${ext}`));
+    const outputPath = toPosix(path12.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);
@@ -22318,6 +22518,7 @@ export {
   adaptJestRun,
   adaptPlaywrightRun,
   adaptVitestRun,
+  advanceState,
   assertValidRun,
   buildCheck,
   buildGoal,
@@ -22330,6 +22531,7 @@ export {
   canonicalizeRun,
   classifyStatusChange,
   clearVersionCache,
+  computeDeltas,
   computeTestMetrics,
   copyMarkdownAssets,
   createPrCommentSummary,
@@ -22352,6 +22554,7 @@ export {
   getEnvironmentDrift,
   gradeEvidence,
   hasSufficientHistory,
+  injectLiveBits,
   isReviewableSource,
   isTestFile,
   joinNameAndExt,
@@ -22373,7 +22576,9 @@ export {
   readPackageVersion,
   recordDeployment,
   regenerateArtifacts,
+  regenerateRun,
   renderCheck,
+  renderDeltaStrip,
   renderGoal,
   renderTriage,
   resolveAttachment,
@@ -22389,6 +22594,7 @@ export {
   sendWebhookNotification,
   signBody,
   slugify,
+  startServe,
   startWatch,
   stripAnsi,
   toBehaviorManifest,