executable-stories-formatters 1.9.2 → 1.11.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import * as path9 from "path";
+import * as path10 from "path";
 import * as fsPromises from "fs/promises";
 import { toStoryReportWithIndex } from "executable-stories-core/converters/story-report";
 
@@ -647,50 +647,50 @@ function scenarioLines(scenario) {
   if (scenario.errorMessage) lines.push(indent(`error: ${scenario.errorMessage}`, "  "));
   return lines;
 }
-function docLines(entry, pad) {
-  const lines = ownDocLines(entry, pad);
-  for (const child of entry.children ?? []) lines.push(...docLines(child, pad + "  "));
+function docLines(entry, pad2) {
+  const lines = ownDocLines(entry, pad2);
+  for (const child of entry.children ?? []) lines.push(...docLines(child, pad2 + "  "));
   return lines;
 }
-function ownDocLines(entry, pad) {
+function ownDocLines(entry, pad2) {
   switch (entry.kind) {
     case "note":
-      return [indent(entry.text, pad)];
+      return [indent(entry.text, pad2)];
     case "tag":
       return [];
     // already on the scenario's tag line
     case "kv":
-      return [`${pad}${entry.label}: ${compact(entry.value)}`];
+      return [`${pad2}${entry.label}: ${compact(entry.value)}`];
     case "code":
-      return [`${pad}code ${entry.label}${entry.lang ? ` (${entry.lang})` : ""}:`, indent(entry.content, pad + "  ")];
+      return [`${pad2}code ${entry.label}${entry.lang ? ` (${entry.lang})` : ""}:`, indent(entry.content, pad2 + "  ")];
     case "table":
       return [
-        `${pad}table ${entry.label}: ${entry.columns.join(" | ")}`,
-        ...entry.rows.map((row) => `${pad}  ${row.join(" | ")}`)
+        `${pad2}table ${entry.label}: ${entry.columns.join(" | ")}`,
+        ...entry.rows.map((row) => `${pad2}  ${row.join(" | ")}`)
       ];
     case "link":
-      return [`${pad}link ${entry.label}: ${entry.url}`];
+      return [`${pad2}link ${entry.label}: ${entry.url}`];
     case "section":
-      return [`${pad}section ${entry.title}:`, indent(entry.markdown, pad + "  ")];
+      return [`${pad2}section ${entry.title}:`, indent(entry.markdown, pad2 + "  ")];
     case "mermaid":
-      return [`${pad}mermaid${entry.title ? ` ${entry.title}` : ""}:`, indent(entry.code, pad + "  ")];
+      return [`${pad2}mermaid${entry.title ? ` ${entry.title}` : ""}:`, indent(entry.code, pad2 + "  ")];
     case "screenshot":
-      return [`${pad}screenshot ${entry.path}${entry.alt ? ` \u2014 ${entry.alt}` : ""}`];
+      return [`${pad2}screenshot ${entry.path}${entry.alt ? ` \u2014 ${entry.alt}` : ""}`];
     case "video":
-      return [`${pad}video ${entry.path}${entry.caption ? ` \u2014 ${entry.caption}` : ""}`];
+      return [`${pad2}video ${entry.path}${entry.caption ? ` \u2014 ${entry.caption}` : ""}`];
     case "html":
-      return [`${pad}html ${entry.title ?? entry.path ?? entry.url ?? "(inline)"}`];
+      return [`${pad2}html ${entry.title ?? entry.path ?? entry.url ?? "(inline)"}`];
     case "state":
-      return [`${pad}state${entry.label ? ` ${entry.label}` : ""}: ${compact(entry.value)}`];
+      return [`${pad2}state${entry.label ? ` ${entry.label}` : ""}: ${compact(entry.value)}`];
     case "custom":
-      return [`${pad}custom ${entry.type}: ${compact(entry.data)}`];
+      return [`${pad2}custom ${entry.type}: ${compact(entry.data)}`];
   }
 }
 function compact(value) {
   return typeof value === "string" ? value : JSON.stringify(value);
 }
-function indent(text2, pad) {
-  return text2.split("\n").map((line) => pad + line).join("\n");
+function indent(text2, pad2) {
+  return text2.split("\n").map((line) => pad2 + line).join("\n");
 }
 
 // src/formatters/junit-xml.ts
@@ -1593,9 +1593,9 @@ var MAX_FUZZ = 2;
 var normalize = (line) => line.trim();
 var HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@ ?(.*)$/;
 function stripPathPrefix(raw) {
-  const path10 = raw.split("	")[0].trim();
-  if (path10 === "/dev/null") return void 0;
-  return path10.replace(/^[ab]\//, "");
+  const path11 = raw.split("	")[0].trim();
+  if (path11 === "/dev/null") return void 0;
+  return path11.replace(/^[ab]\//, "");
 }
 function parseUnifiedDiff(patch) {
   const files = [];
@@ -1675,7 +1675,7 @@ function createAnchor(args) {
   };
 }
 function changedRunCandidates(anchor, file, fileIndex) {
-  const path10 = file.newPath ?? file.oldPath ?? "";
+  const path11 = file.newPath ?? file.oldPath ?? "";
   const out = [];
   file.hunks.forEach((hunk, hunkIndex) => {
     outer: for (let i = 0; i + anchor.changed.length <= hunk.lines.length; i++) {
@@ -1686,7 +1686,7 @@ function changedRunCandidates(anchor, file, fileIndex) {
           continue outer;
         }
       }
-      out.push({ fileIndex, file: path10, hunkIndex, lineIndex: i, lines: hunk.lines });
+      out.push({ fileIndex, file: path11, hunkIndex, lineIndex: i, lines: hunk.lines });
     }
   });
   return out;
@@ -1783,18 +1783,18 @@ function deriveChangeType(tags) {
   }
   return "unknown";
 }
-function extensionOf(path10) {
-  const base = path10.split("/").pop() ?? path10;
+function extensionOf(path11) {
+  const base = path11.split("/").pop() ?? path11;
   const dot = base.lastIndexOf(".");
   return dot === -1 ? "" : base.slice(dot + 1).toLowerCase();
 }
-function isTestFile(path10) {
-  return TEST_INFIX.test(path10);
+function isTestFile(path11) {
+  return TEST_INFIX.test(path11);
 }
-function isReviewableSource(path10) {
-  if (isTestFile(path10)) return false;
-  if (path10.endsWith(".d.ts")) return false;
-  return CODE_EXTENSIONS.has(extensionOf(path10));
+function isReviewableSource(path11) {
+  if (isTestFile(path11)) return false;
+  if (path11.endsWith(".d.ts")) return false;
+  return CODE_EXTENSIONS.has(extensionOf(path11));
 }
 function testBaseKey(testFile) {
   return testFile.replace(TEST_INFIX, "");
@@ -1898,7 +1898,7 @@ function toClaim(testCase, changedSourcePaths) {
   const { strength, reasons } = gradeEvidence(testCase, audience);
   const key = testBaseKey(testCase.sourceFile);
   const coversFiles = changedSourcePaths.filter(
-    (path10) => sourceBaseKey(path10) === key
+    (path11) => sourceBaseKey(path11) === key
   );
   return {
     id: testCase.id,
@@ -2070,14 +2070,14 @@ var TraceabilityMatrixFormatter = class {
       lines.push("");
       lines.push(`Status: ${renderRequirementStatus(req.status)}`);
       if (req.covers.length > 0) {
-        lines.push(`Covers: ${req.covers.map((path10) => `\`${path10}\``).join(", ")}`);
+        lines.push(`Covers: ${req.covers.map((path11) => `\`${path11}\``).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((path10) => `\`${path10}\``).join(", ") : "";
+        const covers = scenario.covers.length > 0 ? scenario.covers.map((path11) => `\`${path11}\``).join(", ") : "";
         lines.push(`| ${scenario.status} | ${escapePipe2(scenario.title)} | \`${source}\` | ${covers} |`);
       }
       lines.push("");
@@ -2842,8 +2842,8 @@ function extractDocAttachments(step) {
   }
   return attachments;
 }
-function guessMediaType(path10) {
-  const lower = path10.toLowerCase();
+function guessMediaType(path11) {
+  const lower = path11.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";
@@ -2984,11 +2984,11 @@ var CucumberHtmlFormatter = class {
     for (const envelope of envelopes) {
       const accepted = htmlStream.write(envelope);
       if (!accepted) {
-        await new Promise((resolve8) => htmlStream.once("drain", resolve8));
+        await new Promise((resolve9) => htmlStream.once("drain", resolve9));
       }
     }
-    await new Promise((resolve8, reject) => {
-      collector.on("finish", resolve8);
+    await new Promise((resolve9, reject) => {
+      collector.on("finish", resolve9);
       collector.on("error", reject);
       htmlStream.end();
     });
@@ -5492,6 +5492,1395 @@ function convertAttachments(attachments) {
 
 // src/index.ts
 import { STORY_META_KEY } from "executable-stories-core/types/story";
+
+// src/sync/engine.ts
+import { behaviourFingerprint as behaviourFingerprint2, behaviourSimilarity as behaviourSimilarity2 } from "executable-stories-core/converters/acl/ids";
+
+// src/sync/lockfile.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+import { createHash as createHash5 } from "crypto";
+var DEFAULT_LOCKFILE_PATH = ".executable-stories/sync.lock.json";
+var LOCKFILE_VERSION = 1;
+function emptyLockfile() {
+  return { version: LOCKFILE_VERSION, providers: {} };
+}
+function hashCaseBody(body) {
+  const canonical = JSON.stringify({
+    title: body.title.trim(),
+    steps: body.steps.map((s) => `${s.keyword.toLowerCase()}:${s.text.trim()}`),
+    description: body.description.trim()
+  });
+  return createHash5("sha1").update(canonical).digest("hex").slice(0, 16);
+}
+function parseLockfile(contents, label) {
+  let parsed;
+  try {
+    parsed = JSON.parse(contents);
+  } catch (err) {
+    throw new Error(
+      `Sync lockfile at ${label} is not valid JSON: ${err.message}
+Fix or delete it \u2014 deleting orphans every existing case binding, so prefer fixing.`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Sync lockfile at ${label} must contain an object.`);
+  }
+  const lock = parsed;
+  if (lock.version !== LOCKFILE_VERSION) {
+    throw new Error(
+      `Sync lockfile at ${label} has version ${String(lock.version)}, expected ${LOCKFILE_VERSION}.`
+    );
+  }
+  return { version: LOCKFILE_VERSION, providers: lock.providers ?? {} };
+}
+function serializeLockfile(lock) {
+  const providers = {};
+  for (const provider of Object.keys(lock.providers).sort()) {
+    const entries = lock.providers[provider] ?? {};
+    const sorted = {};
+    for (const key of Object.keys(entries).sort()) sorted[key] = entries[key];
+    providers[provider] = sorted;
+  }
+  return `${JSON.stringify({ version: LOCKFILE_VERSION, providers }, null, 2)}
+`;
+}
+function readLockfile(file) {
+  if (!fs4.existsSync(file)) return emptyLockfile();
+  return parseLockfile(fs4.readFileSync(file, "utf8"), file);
+}
+function writeLockfile(file, lock) {
+  fs4.mkdirSync(path5.dirname(path5.resolve(file)), { recursive: true });
+  fs4.writeFileSync(file, serializeLockfile(lock), "utf8");
+}
+function entriesFor(lock, provider) {
+  return lock.providers[provider] ?? {};
+}
+function setEntry(lock, provider, fingerprint, entry) {
+  lock.providers[provider] ??= {};
+  lock.providers[provider][fingerprint] = entry;
+}
+
+// src/sync/engine.ts
+var DEFAULT_DUPLICATE_THRESHOLD = 0.7;
+var PARTIAL_RUN_ORPHAN_RATIO = 0.25;
+function normalizeTitle(text2) {
+  return text2.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").replace(/\s+/g, " ").trim();
+}
+function renderDocs(docs, depth = 0) {
+  if (!docs || docs.length === 0) return "";
+  const lines = [];
+  for (const doc of docs) {
+    switch (doc.kind) {
+      case "note":
+        lines.push(doc.text);
+        break;
+      case "kv":
+        lines.push(`**${doc.label}:** ${formatValue(doc.value)}`);
+        break;
+      case "state":
+        lines.push(`**${doc.label ?? "State"}:** ${formatValue(doc.value)}`);
+        break;
+      case "code":
+        lines.push(`**${doc.label}**`, "", "```" + (doc.lang ?? ""), doc.content, "```");
+        break;
+      case "table":
+        lines.push(
+          `**${doc.label}**`,
+          "",
+          `| ${doc.columns.join(" | ")} |`,
+          `| ${doc.columns.map(() => "---").join(" | ")} |`,
+          ...doc.rows.map((row) => `| ${row.join(" | ")} |`)
+        );
+        break;
+      case "link":
+        lines.push(`[${doc.label}](${doc.url})`);
+        break;
+      case "section":
+        lines.push(`${"#".repeat(Math.min(6, depth + 3))} ${doc.title}`, "", doc.markdown);
+        break;
+      case "mermaid":
+        lines.push(...doc.title ? [`**${doc.title}**`, ""] : [], "```mermaid", doc.code, "```");
+        break;
+      case "screenshot":
+        lines.push(`_Screenshot: ${doc.alt ?? doc.path}_`);
+        break;
+      case "video":
+        lines.push(`_Video: ${doc.caption ?? doc.path}_`);
+        break;
+      case "html":
+        lines.push(`_Embedded: ${doc.title ?? doc.url ?? doc.path ?? "html"}_`);
+        break;
+      case "custom":
+        lines.push(`_${doc.type}_: ${formatValue(doc.data)}`);
+        break;
+      case "tag":
+        break;
+    }
+    const children = renderDocs(doc.children, depth + 1);
+    if (children) lines.push(children);
+  }
+  return lines.join("\n");
+}
+function formatValue(value) {
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+function scenarioUrl(config, tc) {
+  if (!config.reportUrl) return void 0;
+  const base = config.reportUrl.replace(/\/$/, "");
+  const anchor = config.scenarioAnchor?.(tc);
+  return anchor ? `${base}#${anchor}` : base;
+}
+function toCaseBody(tc, config) {
+  const sections = [];
+  const docs = renderDocs(tc.story.docs);
+  if (docs) sections.push(docs);
+  const tickets = tc.story.tickets ?? [];
+  if (tickets.length > 0) {
+    sections.push(
+      `**Requirements:** ${tickets.map((t) => t.url ? `[${t.id}](${t.url})` : t.id).join(", ")}`
+    );
+  }
+  if (tc.story.covers?.length) {
+    sections.push(`**Covers:** ${tc.story.covers.join(", ")}`);
+  }
+  sections.push(`_Generated from ${tc.sourceFile}:${tc.sourceLine} by executable-stories. Edit the test, not this case._`);
+  const links = [];
+  const report = scenarioUrl(config, tc);
+  if (report) links.push({ label: "Living documentation", url: report });
+  for (const ticket of tickets) {
+    if (ticket.url) links.push({ label: ticket.id, url: ticket.url });
+  }
+  return {
+    title: tc.story.scenario,
+    steps: tc.story.steps.map((s) => ({ keyword: s.keyword, text: s.text })),
+    description: sections.join("\n\n"),
+    links
+  };
+}
+function projectBehaviours(run, config) {
+  const fingerprints = run.testCases.map(
+    (tc) => behaviourFingerprint2({
+      scenario: tc.story.scenario,
+      sourceFile: tc.sourceFile,
+      steps: tc.story.steps.map((s) => ({ keyword: s.keyword, text: s.text })),
+      covers: tc.story.covers
+    })
+  );
+  const counts = /* @__PURE__ */ new Map();
+  for (const fp of fingerprints) {
+    if (fp) counts.set(fp, (counts.get(fp) ?? 0) + 1);
+  }
+  return run.testCases.map((tc, index) => {
+    const fp = fingerprints[index];
+    const unique = fp !== "" && counts.get(fp) === 1;
+    return {
+      fingerprint: unique ? fp : tc.id,
+      testCase: tc,
+      body: toCaseBody(tc, config)
+    };
+  });
+}
+function roleFor(attachment) {
+  const type = attachment.mediaType.toLowerCase();
+  if (type.startsWith("image/")) return "screenshot";
+  if (type.startsWith("video/")) return "video";
+  if (attachment.name.toLowerCase().includes("trace")) return "trace";
+  return "log";
+}
+function decode(attachment) {
+  return attachment.contentEncoding === "BASE64" ? Uint8Array.from(Buffer.from(attachment.body, "base64")) : new TextEncoder().encode(attachment.body);
+}
+function collectAttachments(args) {
+  const { testCase, policy, maxBytes } = args;
+  if (policy === "none") return { attachments: [], oversized: [] };
+  if (policy === "failed" && testCase.status !== "failed") return { attachments: [], oversized: [] };
+  const attachments = [];
+  const oversized = [];
+  for (const raw of testCase.attachments) {
+    const body = decode(raw);
+    if (maxBytes !== void 0 && body.byteLength > maxBytes) {
+      oversized.push({ filename: raw.name, bytes: body.byteLength, limit: maxBytes });
+      continue;
+    }
+    attachments.push({
+      filename: raw.name,
+      mediaType: raw.mediaType,
+      body,
+      role: roleFor(raw)
+    });
+  }
+  return { attachments, oversized };
+}
+function toCaseResult(args) {
+  const { behaviour, caseId, provider, config } = args;
+  const tc = behaviour.testCase;
+  if (tc.status === "pending") return void 0;
+  const { attachments, oversized } = collectAttachments({
+    testCase: tc,
+    policy: config.attach ?? "failed",
+    maxBytes: provider.maxAttachmentBytes
+  });
+  return {
+    result: {
+      caseId,
+      status: tc.status,
+      durationMs: tc.durationMs,
+      message: tc.errorMessage,
+      url: scenarioUrl(config, tc),
+      attachments: attachments.length > 0 ? attachments : void 0
+    },
+    oversized
+  };
+}
+function ticketBinding(tc, config) {
+  const prefix = config.ticketPrefix;
+  if (!prefix) return void 0;
+  const match = (tc.story.tickets ?? []).find((t) => t.id.startsWith(prefix));
+  if (!match) return void 0;
+  return config.ticketPrefixStrip === false ? match.id : match.id.slice(prefix.length);
+}
+async function analyzeSync(args) {
+  const { run, provider, lockfile, config } = args;
+  const local = projectBehaviours(run, config);
+  const remoteCases = await provider.listCases();
+  const remoteById = new Map(remoteCases.map((c) => [c.id, c]));
+  const locked = entriesFor(lockfile, provider.name);
+  const create = [];
+  const update = [];
+  const unchanged = [];
+  const adopted = [];
+  const skipped = [];
+  const results = [];
+  const oversized = [];
+  const boundCaseIds = /* @__PURE__ */ new Set();
+  let driftUncheckable = 0;
+  for (const behaviour of local) {
+    const entry = locked[behaviour.fingerprint];
+    const caseId = entry?.caseId ?? ticketBinding(behaviour.testCase, config);
+    const remote2 = caseId ? remoteById.get(caseId) : void 0;
+    if (!caseId) {
+      create.push({
+        fingerprint: behaviour.fingerprint,
+        scenario: behaviour.body.title,
+        body: behaviour.body
+      });
+      continue;
+    }
+    if (!remote2) {
+      skipped.push({
+        fingerprint: behaviour.fingerprint,
+        caseId,
+        url: entry?.url ?? "",
+        title: entry?.title ?? behaviour.body.title,
+        reason: "case-missing"
+      });
+      continue;
+    }
+    boundCaseIds.add(caseId);
+    const pending = toCaseResult({ behaviour, caseId, provider, config });
+    if (pending) {
+      results.push(pending.result);
+      oversized.push(...pending.oversized);
+    }
+    const planned = {
+      fingerprint: behaviour.fingerprint,
+      caseId,
+      url: remote2.url,
+      scenario: behaviour.body.title,
+      body: behaviour.body
+    };
+    if (!entry?.owned) {
+      adopted.push(planned);
+      continue;
+    }
+    const remoteHash = remote2.body ? hashCaseBody(remote2.body) : void 0;
+    if (remoteHash !== void 0 && remoteHash !== entry.hash) {
+      skipped.push({
+        fingerprint: behaviour.fingerprint,
+        caseId,
+        url: remote2.url,
+        title: remote2.title,
+        reason: "remote-edited"
+      });
+      continue;
+    }
+    const baseline = remoteHash ?? entry.hash;
+    if (baseline !== "" && hashCaseBody(behaviour.body) === baseline) {
+      unchanged.push(planned);
+    } else {
+      update.push(planned);
+    }
+    if (remoteHash === void 0) driftUncheckable += 1;
+  }
+  const byNormalizedTitle = /* @__PURE__ */ new Map();
+  for (const behaviour of local) byNormalizedTitle.set(normalizeTitle(behaviour.body.title), behaviour);
+  const threshold = config.duplicateThreshold ?? DEFAULT_DUPLICATE_THRESHOLD;
+  const remote = remoteCases.map((remoteCase) => {
+    if (boundCaseIds.has(remoteCase.id)) {
+      return { case: remoteCase, classification: "automated" };
+    }
+    const titleMatch = byNormalizedTitle.get(normalizeTitle(remoteCase.title));
+    if (titleMatch) {
+      return {
+        case: remoteCase,
+        classification: "duplicated",
+        resembles: titleMatch.body.title
+      };
+    }
+    if (remoteCase.body && remoteCase.body.steps.length > 0) {
+      let best;
+      for (const behaviour of local) {
+        const score = behaviourSimilarity2(
+          {
+            scenario: remoteCase.title,
+            sourceFile: "",
+            steps: remoteCase.body.steps
+          },
+          {
+            scenario: behaviour.body.title,
+            sourceFile: behaviour.testCase.sourceFile,
+            steps: behaviour.body.steps
+          }
+        );
+        if (!best || score > best.score) best = { behaviour, score };
+      }
+      if (best && best.score >= threshold) {
+        return {
+          case: remoteCase,
+          classification: "possible-duplicate",
+          resembles: best.behaviour.body.title,
+          similarity: Number(best.score.toFixed(2))
+        };
+      }
+    }
+    return { case: remoteCase, classification: "manual-only" };
+  });
+  const localFingerprints = new Set(local.map((b) => b.fingerprint));
+  const orphaned = Object.entries(locked).filter(([fingerprint]) => !localFingerprints.has(fingerprint)).map(([fingerprint, entry]) => ({
+    fingerprint,
+    caseId: entry.caseId,
+    url: entry.url,
+    title: entry.title
+  }));
+  const lockedCount = Object.keys(locked).length;
+  const partialRunWarning = lockedCount > 0 && orphaned.length / lockedCount > PARTIAL_RUN_ORPHAN_RATIO ? `${orphaned.length} of ${lockedCount} bindings have no matching story. If this run was filtered (a -t/--grep flag, a single file), those are not deletions. Nothing is removed either way.` : void 0;
+  const unsupported = [];
+  if (create.length > 0 && !provider.createCase) unsupported.push("createCase");
+  if (update.length > 0 && !provider.updateCase) unsupported.push("updateCase");
+  if (results.length > 0 && !provider.recordResults) unsupported.push("recordResults");
+  const byRole = {};
+  let files = 0;
+  let bytes = 0;
+  for (const result of results) {
+    for (const attachment of result.attachments ?? []) {
+      files += 1;
+      bytes += attachment.body.byteLength;
+      const role = attachment.role ?? "log";
+      byRole[role] = (byRole[role] ?? 0) + 1;
+    }
+  }
+  return {
+    provider: provider.name,
+    target: provider.describeTarget?.(),
+    local,
+    remote,
+    create,
+    update,
+    unchanged,
+    adopted,
+    skipped,
+    orphaned,
+    results,
+    attachments: { files, bytes, oversized, byRole },
+    unsupported,
+    driftUncheckable,
+    partialRunWarning
+  };
+}
+async function applySync(args, deps) {
+  const { analysis, provider, lockfile, config } = args;
+  const result = {
+    created: [],
+    updated: [],
+    resultsRecorded: 0,
+    resultsSkipped: [],
+    attachmentsUploaded: 0,
+    errors: []
+  };
+  const byFingerprint = new Map(analysis.local.map((b) => [b.fingerprint, b]));
+  const results = [...analysis.results];
+  if (analysis.create.length > 0 && provider.createCase) {
+    for (const planned of analysis.create) {
+      try {
+        const created = await provider.createCase(planned.body);
+        setEntry(lockfile, provider.name, planned.fingerprint, {
+          caseId: created.id,
+          url: created.url,
+          hash: hashCaseBody(created.body ?? planned.body),
+          title: created.title,
+          owned: true
+        });
+        result.created.push({ scenario: planned.scenario, caseId: created.id, url: created.url });
+        const behaviour = byFingerprint.get(planned.fingerprint);
+        if (behaviour) {
+          const pending = toCaseResult({ behaviour, caseId: created.id, provider, config });
+          if (pending) results.push(pending.result);
+        }
+      } catch (err) {
+        result.errors.push(`create "${planned.scenario}": ${err.message}`);
+      }
+    }
+  }
+  if (analysis.update.length > 0 && provider.updateCase) {
+    for (const planned of analysis.update) {
+      try {
+        const updated = await provider.updateCase(planned.caseId, planned.body);
+        setEntry(lockfile, provider.name, planned.fingerprint, {
+          caseId: updated.id,
+          url: updated.url,
+          hash: hashCaseBody(updated.body ?? planned.body),
+          title: updated.title,
+          owned: true
+        });
+        result.updated.push({ scenario: planned.scenario, caseId: updated.id, url: updated.url });
+      } catch (err) {
+        result.errors.push(`update "${planned.scenario}" (${planned.caseId}): ${err.message}`);
+      }
+    }
+  }
+  for (const planned of analysis.unchanged) {
+    const existing = entriesFor(lockfile, provider.name)[planned.fingerprint];
+    if (existing) {
+      setEntry(lockfile, provider.name, planned.fingerprint, { ...existing, url: planned.url });
+    }
+  }
+  for (const planned of analysis.adopted) {
+    setEntry(lockfile, provider.name, planned.fingerprint, {
+      caseId: planned.caseId,
+      url: planned.url,
+      hash: "",
+      title: planned.scenario,
+      owned: false
+    });
+  }
+  if (results.length > 0 && provider.recordResults) {
+    try {
+      const summary = await provider.recordResults(results);
+      result.resultsRecorded = summary.recorded;
+      result.resultsSkipped = summary.skipped;
+      result.attachmentsUploaded = summary.attachmentsUploaded;
+      result.runUrl = summary.runUrl;
+    } catch (err) {
+      result.errors.push(`record results: ${err.message}`);
+    }
+  } else if (results.length > 0) {
+    deps.logger.warn(
+      `${provider.name} does not support recording results \u2014 ${results.length} execution(s) not pushed.`
+    );
+  }
+  return result;
+}
+
+// src/sync/report.ts
+var MANUAL_ONLY_LIMIT = 50;
+function summarize2(analysis) {
+  const count2 = (kind) => analysis.remote.filter((c) => c.classification === kind).length;
+  return {
+    provider: analysis.provider,
+    target: analysis.target,
+    totalCases: analysis.remote.length,
+    automated: count2("automated"),
+    duplicated: count2("duplicated"),
+    possibleDuplicate: count2("possible-duplicate"),
+    manualOnly: count2("manual-only"),
+    untracked: analysis.create.length,
+    adopted: analysis.adopted.length
+  };
+}
+function sectionBreakdown(analysis) {
+  const sections = /* @__PURE__ */ new Map();
+  for (const entry of analysis.remote) {
+    const name = entry.case.section ?? "(no section)";
+    const bucket2 = sections.get(name) ?? { total: 0, automated: 0 };
+    bucket2.total += 1;
+    if (entry.classification === "automated") bucket2.automated += 1;
+    sections.set(name, bucket2);
+  }
+  return [...sections.entries()].map(([name, value]) => ({ name, ...value })).sort((a, b) => b.automated - a.automated || b.total - a.total);
+}
+function renderCoverageText(analysis) {
+  const summary = summarize2(analysis);
+  const lines = [];
+  lines.push(`${analysis.provider}: ${analysis.target ?? "(target not described)"} (${summary.totalCases} cases)`);
+  lines.push("");
+  lines.push(`  ${pad(summary.automated)}  automated        already covered by a story`);
+  lines.push(`  ${pad(summary.duplicated)}  duplicated       manual case duplicates an automated story`);
+  if (summary.possibleDuplicate > 0) {
+    lines.push(`  ${pad(summary.possibleDuplicate)}  possible dupe    similar to a story, needs a human to confirm`);
+  }
+  lines.push(`  ${pad(summary.manualOnly)}  manual only      no automated equivalent`);
+  lines.push(`  ${pad(summary.untracked)}  untracked        story with no case`);
+  if (summary.adopted > 0) {
+    lines.push(`  ${pad(summary.adopted)}  linked           story bound to a hand-authored case`);
+  }
+  const sections = sectionBreakdown(analysis).filter((s) => s.automated > 0);
+  if (sections.length > 0) {
+    const top = sections[0];
+    lines.push("");
+    lines.push(`Biggest overlap: "${top.name}" section, ${top.automated} of ${top.total} automated.`);
+  }
+  if (analysis.orphaned.length > 0) {
+    lines.push("");
+    lines.push(`${analysis.orphaned.length} case(s) bound to a story that no longer exists. Nothing was removed.`);
+  }
+  if (analysis.partialRunWarning) {
+    lines.push("");
+    lines.push(`Note: ${analysis.partialRunWarning}`);
+  }
+  return lines.join("\n");
+}
+function pad(value) {
+  return String(value).padStart(4, " ");
+}
+function renderCoverageMarkdown(analysis) {
+  const summary = summarize2(analysis);
+  const lines = [];
+  lines.push(`# Test coverage vs ${analysis.provider}`);
+  lines.push("");
+  if (analysis.target) lines.push(`**Target:** ${analysis.target}`, "");
+  lines.push("| Cases | Count | Meaning |");
+  lines.push("| --- | ---: | --- |");
+  lines.push(`| Automated | ${summary.automated} | Already covered by a story |`);
+  lines.push(`| Duplicated | ${summary.duplicated} | Manual case duplicates an automated story |`);
+  lines.push(`| Possible duplicate | ${summary.possibleDuplicate} | Similar to a story, needs review |`);
+  lines.push(`| Manual only | ${summary.manualOnly} | No automated equivalent |`);
+  lines.push(`| Untracked stories | ${summary.untracked} | Story with no case |`);
+  lines.push("");
+  const duplicates = analysis.remote.filter(
+    (c) => c.classification === "duplicated" || c.classification === "possible-duplicate"
+  );
+  if (duplicates.length > 0) {
+    lines.push("## Retire these first");
+    lines.push("");
+    lines.push("Manual cases an automated story already covers.");
+    lines.push("");
+    lines.push("| Case | Title | Covered by | Confidence |");
+    lines.push("| --- | --- | --- | --- |");
+    for (const entry of duplicates) {
+      const confidence = entry.classification === "duplicated" ? "exact title" : `similarity ${entry.similarity}`;
+      lines.push(
+        `| [${entry.case.id}](${entry.case.url}) | ${escapeCell2(entry.case.title)} | ${escapeCell2(entry.resembles ?? "")} | ${confidence} |`
+      );
+    }
+    lines.push("");
+  }
+  const manualOnly = analysis.remote.filter((c) => c.classification === "manual-only");
+  if (manualOnly.length > 0) {
+    lines.push("## Not automated yet");
+    lines.push("");
+    lines.push("Cases with no automated equivalent. This is the backlog.");
+    lines.push("");
+    lines.push("| Case | Title | Section |");
+    lines.push("| --- | --- | --- |");
+    for (const entry of manualOnly.slice(0, MANUAL_ONLY_LIMIT)) {
+      lines.push(
+        `| [${entry.case.id}](${entry.case.url}) | ${escapeCell2(entry.case.title)} | ${escapeCell2(entry.case.section ?? "")} |`
+      );
+    }
+    if (manualOnly.length > MANUAL_ONLY_LIMIT) {
+      lines.push("");
+      lines.push(
+        `_${manualOnly.length - MANUAL_ONLY_LIMIT} more not listed here. The JSON artifact has all ${manualOnly.length}._`
+      );
+    }
+    lines.push("");
+  }
+  if (analysis.create.length > 0) {
+    lines.push("## Stories with no case");
+    lines.push("");
+    for (const planned of analysis.create) lines.push(`- ${planned.scenario}`);
+    lines.push("");
+  }
+  if (analysis.orphaned.length > 0) {
+    lines.push("## Cases with no story");
+    lines.push("");
+    lines.push("Bound to a story that has since been deleted. Nothing was removed automatically.");
+    lines.push("");
+    for (const orphan of analysis.orphaned) {
+      lines.push(`- [${orphan.caseId}](${orphan.url}) ${escapeCell2(orphan.title)}`);
+    }
+    lines.push("");
+  }
+  const sections = sectionBreakdown(analysis);
+  if (sections.length > 1) {
+    lines.push("## By section");
+    lines.push("");
+    lines.push("| Section | Automated | Total |");
+    lines.push("| --- | ---: | ---: |");
+    for (const section of sections) {
+      lines.push(`| ${escapeCell2(section.name)} | ${section.automated} | ${section.total} |`);
+    }
+    lines.push("");
+  }
+  if (analysis.partialRunWarning) {
+    lines.push(`> ${analysis.partialRunWarning}`, "");
+  }
+  return lines.join("\n");
+}
+function escapeCell2(text2) {
+  return text2.replace(/\|/g, "\\|");
+}
+function buildCoverageJson(analysis) {
+  return {
+    schema: "executable-stories/sync-coverage/v1",
+    ...summarize2(analysis),
+    cases: analysis.remote.map((entry) => ({
+      id: entry.case.id,
+      url: entry.case.url,
+      title: entry.case.title,
+      section: entry.case.section,
+      classification: entry.classification,
+      resembles: entry.resembles,
+      similarity: entry.similarity
+    })),
+    untrackedScenarios: analysis.create.map((c) => c.scenario),
+    orphaned: analysis.orphaned.map((o) => ({ caseId: o.caseId, url: o.url, title: o.title })),
+    sections: sectionBreakdown(analysis)
+  };
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function renderPlan(analysis, opts) {
+  const lines = [];
+  lines.push(`${analysis.provider}: ${analysis.target ?? "(target not described)"}`);
+  lines.push("");
+  lines.push(`  + create    ${pad(analysis.create.length)} cases`);
+  lines.push(`  ~ update    ${pad(analysis.update.length)} cases`);
+  lines.push(`  = unchanged ${pad(analysis.unchanged.length)} cases`);
+  if (analysis.adopted.length > 0) {
+    lines.push(`  \xB7 linked    ${pad(analysis.adopted.length)} cases  (hand-authored, results only)`);
+  }
+  if (analysis.skipped.length > 0) {
+    const edited = analysis.skipped.filter((s) => s.reason === "remote-edited").length;
+    const missing = analysis.skipped.filter((s) => s.reason === "case-missing").length;
+    if (edited > 0) {
+      lines.push(`  ! skipped   ${pad(edited)} cases  (edited in ${analysis.provider} since last sync)`);
+    }
+    if (missing > 0) {
+      lines.push(`  ! skipped   ${pad(missing)} cases  (bound case no longer exists)`);
+    }
+  }
+  if (analysis.orphaned.length > 0) {
+    lines.push(`  ? orphaned  ${pad(analysis.orphaned.length)} cases  (story deleted from codebase, never removed)`);
+  }
+  lines.push(`  \u2192 results   ${pad(analysis.results.length)} executions`);
+  if (analysis.attachments.files > 0) {
+    const roles = Object.entries(analysis.attachments.byRole).map(([role, count2]) => `${count2} ${role}${count2 === 1 ? "" : "s"}`).join(", ");
+    lines.push(
+      `  \u2191 upload    ${pad(analysis.attachments.files)} attachments (${roles}, ${formatBytes(analysis.attachments.bytes)})`
+    );
+  }
+  for (const oversized of analysis.attachments.oversized) {
+    lines.push(
+      `  ! oversized ${oversized.filename} (${formatBytes(oversized.bytes)}, provider limit ${formatBytes(oversized.limit)})`
+    );
+  }
+  for (const capability of analysis.unsupported) {
+    lines.push(`  ! ${analysis.provider} does not support ${capability} \u2014 those changes are not applied`);
+  }
+  if (analysis.driftUncheckable > 0) {
+    lines.push(
+      `  ! ${analysis.driftUncheckable} case(s): ${analysis.provider} returned no body, so a hand edit to them cannot be detected`
+    );
+  }
+  if (analysis.partialRunWarning) {
+    lines.push("");
+    lines.push(`Note: ${analysis.partialRunWarning}`);
+  }
+  if (analysis.skipped.some((s) => s.reason === "remote-edited")) {
+    lines.push("");
+    lines.push("Skipped cases were edited by hand after we last wrote them. Nothing overwrites them.");
+    for (const skip of analysis.skipped.filter((s) => s.reason === "remote-edited")) {
+      lines.push(`  ${skip.caseId} ${skip.title} ${skip.url}`);
+    }
+  }
+  if (opts.dryRun && hasWork(analysis)) {
+    lines.push("");
+    lines.push("Nothing was written. Run the same command with --apply to make these changes.");
+  }
+  return lines.join("\n");
+}
+function hasWork(analysis) {
+  return analysis.create.length > 0 || analysis.update.length > 0 || analysis.results.length > 0;
+}
+function renderApplyResult(result) {
+  const lines = [];
+  for (const created of result.created) {
+    lines.push(`  + ${created.caseId}  ${created.scenario}  ${created.url}`);
+  }
+  for (const updated of result.updated) {
+    lines.push(`  ~ ${updated.caseId}  ${updated.scenario}`);
+  }
+  lines.push("");
+  lines.push(
+    `Created ${result.created.length}, updated ${result.updated.length}, recorded ${result.resultsRecorded} execution(s), uploaded ${result.attachmentsUploaded} attachment(s).`
+  );
+  if (result.runUrl) lines.push(`Run: ${result.runUrl}`);
+  for (const skipped of result.resultsSkipped) {
+    lines.push(`  ! result for case ${skipped.caseId} not recorded: ${skipped.reason}`);
+  }
+  for (const error of result.errors) {
+    lines.push(`  \u2717 ${error}`);
+  }
+  return lines.join("\n");
+}
+
+// src/sync/adapters/case-text.ts
+var BDD_KEYWORDS = ["Given", "When", "Then", "And", "But"];
+function encodeStepText(step) {
+  const keyword = step.keyword.trim();
+  return keyword ? `${keyword} ${step.text}` : step.text;
+}
+function decodeStepText(content) {
+  const trimmed = content.trim();
+  const firstSpace = trimmed.indexOf(" ");
+  if (firstSpace > 0) {
+    const head = trimmed.slice(0, firstSpace);
+    if (BDD_KEYWORDS.some((keyword) => keyword.toLowerCase() === head.toLowerCase())) {
+      return { keyword: head, text: trimmed.slice(firstSpace + 1) };
+    }
+  }
+  return { keyword: "", text: trimmed };
+}
+function encodeDescription(body) {
+  if (body.links.length === 0) return body.description;
+  const links = body.links.map((link2) => `- [${link2.label}](${link2.url})`).join("\n");
+  return `${body.description}
+
+${links}`;
+}
+function decodeDescription(raw) {
+  const links = [];
+  const lines = raw.split("\n");
+  let cut = lines.length;
+  for (let index = lines.length - 1; index >= 0; index--) {
+    const line = lines[index].trim();
+    if (line === "") continue;
+    const match = /^- \[([^\]]+)\]\(([^)]+)\)$/.exec(line);
+    if (!match) break;
+    links.unshift({ label: match[1], url: match[2] });
+    cut = index;
+  }
+  return { description: lines.slice(0, cut).join("\n").trim(), links };
+}
+
+// src/sync/adapters/testrail.ts
+var DEFAULT_STEPS_FIELD = "custom_steps_separated";
+var DEFAULT_DESCRIPTION_FIELD = "custom_preconds";
+var DEFAULT_MAX_ATTACHMENT_BYTES = 64 * 1024 * 1024;
+var PAGE_LIMIT = 250;
+var MAX_ATTEMPTS = 3;
+function unwrapList(payload, key) {
+  if (Array.isArray(payload)) return payload;
+  if (payload && typeof payload === "object") {
+    const list = payload[key];
+    if (Array.isArray(list)) return list;
+  }
+  return [];
+}
+function encodeElapsed(durationMs) {
+  const seconds = Math.floor(durationMs / 1e3);
+  if (seconds < 1) return void 0;
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const rest = seconds % 60;
+  return rest === 0 ? `${minutes}m` : `${minutes}m ${rest}s`;
+}
+function authHint(status) {
+  if (status === 401) {
+    return "\n  TESTRAIL_USERNAME must be the login email and TESTRAIL_API_KEY an API key from My Settings -> API Keys. A password fails here when the instance enforces API keys.";
+  }
+  if (status === 403) {
+    return "\n  The credentials were accepted but the request was refused. Usually the API is disabled: an admin enables it under Administration -> Site Settings -> API.";
+  }
+  return "";
+}
+function createTestRailProvider(config, auth, deps) {
+  const base = config.url.replace(/\/$/, "");
+  const stepsField = config.fields?.steps ?? DEFAULT_STEPS_FIELD;
+  const descriptionField = config.fields?.description ?? DEFAULT_DESCRIPTION_FIELD;
+  const basicAuth = Buffer.from(`${auth.username}:${auth.apiKey}`).toString("base64");
+  let projectName;
+  let suiteName;
+  const sectionNames = /* @__PURE__ */ new Map();
+  async function api(method, init) {
+    const url = `${base}/index.php?/api/v2/${method}`;
+    const headers = {
+      Authorization: `Basic ${basicAuth}`
+    };
+    let body;
+    if (init?.form) {
+      body = init.form;
+    } else if (init?.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(init.body);
+    }
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+      const response = await deps.fetch(url, {
+        method: body === void 0 ? "GET" : "POST",
+        headers,
+        body
+      });
+      if (response.status === 429 && attempt < MAX_ATTEMPTS - 1) {
+        const retryAfter = Number(response.headers.get("retry-after") ?? "1");
+        deps.logger.warn(`TestRail rate limit hit, retrying in ${retryAfter}s`);
+        await new Promise((resolve9) => setTimeout(resolve9, Math.max(1, retryAfter) * 1e3));
+        continue;
+      }
+      const text2 = await response.text();
+      if (text2.length === 0) {
+        if (response.ok) return void 0;
+        throw new Error(
+          `TestRail ${method} failed (${response.status}) with an empty response${authHint(response.status)}`
+        );
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(text2);
+      } catch {
+        throw new Error(
+          `TestRail ${method} returned HTML rather than JSON (status ${response.status}).
+  Check that sync.testrail.url is the instance root, e.g. https://acme.testrail.io, with no path after it.`
+        );
+      }
+      if (!response.ok) {
+        const detail = parsed.error ?? text2;
+        throw new Error(
+          `TestRail ${method} failed (${response.status}): ${detail}${authHint(response.status)}`
+        );
+      }
+      return parsed;
+    }
+    throw new Error(`TestRail ${method} failed: rate limited after ${MAX_ATTEMPTS} attempts`);
+  }
+  async function paginate(method, key) {
+    const all = [];
+    for (let offset = 0; ; offset += PAGE_LIMIT) {
+      const page = await api(`${method}&limit=${PAGE_LIMIT}&offset=${offset}`);
+      const items = unwrapList(page, key);
+      all.push(...items);
+      if (items.length < PAGE_LIMIT) return all;
+    }
+  }
+  function caseUrl(id) {
+    return `${base}/index.php?/cases/view/${id}`;
+  }
+  function toRemoteCase(raw, context) {
+    if (raw?.id === void 0) {
+      throw new Error(
+        `TestRail ${context} returned no case id. The response was: ${JSON.stringify(raw)?.slice(0, 200)}`
+      );
+    }
+    const title = typeof raw.title === "string" ? raw.title : "";
+    const steps = Array.isArray(raw[stepsField]) ? raw[stepsField] : [];
+    const rawDescription = typeof raw[descriptionField] === "string" ? raw[descriptionField] : "";
+    const { description, links } = decodeDescription(rawDescription);
+    return {
+      id: String(raw.id),
+      url: caseUrl(raw.id),
+      title,
+      section: raw.section_id === void 0 ? void 0 : sectionNames.get(raw.section_id),
+      body: {
+        title,
+        steps: steps.map((step) => decodeStepText(step.content ?? "")),
+        description,
+        links
+      }
+    };
+  }
+  function bodyToPayload(body) {
+    const payload = {
+      title: body.title,
+      [stepsField]: body.steps.map((step) => ({ content: encodeStepText(step), expected: "" })),
+      [descriptionField]: encodeDescription(body)
+    };
+    if (config.templateId !== void 0) payload["template_id"] = config.templateId;
+    return payload;
+  }
+  const suiteQuery = config.suiteId === void 0 ? "" : `&suite_id=${config.suiteId}`;
+  return {
+    name: "testrail",
+    maxAttachmentBytes: config.maxAttachmentBytes ?? DEFAULT_MAX_ATTACHMENT_BYTES,
+    describeTarget() {
+      const project = projectName ?? `project ${config.projectId}`;
+      const suite = suiteName ?? (config.suiteId === void 0 ? void 0 : `suite ${config.suiteId}`);
+      return suite ? `${project} / ${suite}` : project;
+    },
+    async listCases() {
+      try {
+        const project = await api(`get_project/${config.projectId}`);
+        projectName = project?.name;
+        if (config.suiteId !== void 0) {
+          const suite = await api(`get_suite/${config.suiteId}`);
+          suiteName = suite?.name;
+        }
+        const sections = await paginate(
+          `get_sections/${config.projectId}${suiteQuery}`,
+          "sections"
+        );
+        for (const section of sections) sectionNames.set(section.id, section.name);
+      } catch (err) {
+        deps.logger.warn(`TestRail metadata lookup failed, continuing without names: ${err.message}`);
+      }
+      const cases = await paginate(`get_cases/${config.projectId}${suiteQuery}`, "cases");
+      return cases.map((raw) => toRemoteCase(raw, "get_cases"));
+    },
+    async createCase(body) {
+      if (config.sectionId === void 0) {
+        throw new Error(
+          "TestRail needs a sectionId to create cases. Set sync.testrail.sectionId to the section new cases should land in."
+        );
+      }
+      const created = await api(`add_case/${config.sectionId}`, {
+        body: bodyToPayload(body)
+      });
+      return toRemoteCase(created, `add_case/${config.sectionId}`);
+    },
+    async updateCase(id, body) {
+      const updated = await api(`update_case/${id}`, { body: bodyToPayload(body) });
+      return toRemoteCase(updated, `update_case/${id}`);
+    },
+    async recordResults(results) {
+      const statusIds = {
+        passed: config.statusIds?.passed ?? 1,
+        failed: config.statusIds?.failed ?? 5,
+        skipped: config.statusIds?.skipped
+      };
+      const skipped = [];
+      const sendable = [];
+      for (const result of results) {
+        const caseId = Number(result.caseId);
+        if (!Number.isFinite(caseId)) {
+          skipped.push({ caseId: result.caseId, reason: "case id is not numeric" });
+          continue;
+        }
+        const statusId = result.status === "skipped" ? statusIds.skipped : statusIds[result.status];
+        if (statusId === void 0) {
+          skipped.push({
+            caseId: result.caseId,
+            reason: "no TestRail status id configured for skipped (set sync.testrail.statusIds.skipped)"
+          });
+          continue;
+        }
+        sendable.push({ result, caseId, statusId });
+      }
+      if (sendable.length === 0) {
+        return { recorded: 0, skipped, attachmentsUploaded: 0 };
+      }
+      let runId = config.runId;
+      if (runId === void 0) {
+        const name = `${config.runName ?? "executable-stories"} ${(/* @__PURE__ */ new Date()).toISOString()}`;
+        const run = await api(`add_run/${config.projectId}`, {
+          body: {
+            ...config.suiteId === void 0 ? {} : { suite_id: config.suiteId },
+            name,
+            include_all: false,
+            // Deduplicated: two stories can carry the same ticket id, and
+            // TestRail rejects a run whose case list repeats one.
+            case_ids: [...new Set(sendable.map((s) => s.caseId))]
+          }
+        });
+        runId = run.id;
+      }
+      const runUrl = `${base}/index.php?/runs/view/${runId}`;
+      const payload = sendable.map(({ result, caseId, statusId }) => {
+        const elapsed = encodeElapsed(result.durationMs);
+        const comment = [result.message, result.url ? `Living documentation: ${result.url}` : void 0].filter(Boolean).join("\n\n");
+        return {
+          case_id: caseId,
+          status_id: statusId,
+          ...comment ? { comment } : {},
+          ...elapsed ? { elapsed } : {}
+        };
+      });
+      const recorded = unwrapList(
+        await api(`add_results_for_cases/${runId}`, { body: { results: payload } }),
+        "results"
+      );
+      let attachmentsUploaded = 0;
+      for (const [index, entry] of recorded.entries()) {
+        const source = sendable[index]?.result;
+        for (const attachment of source?.attachments ?? []) {
+          try {
+            const form = new FormData();
+            const bytes = attachment.body.buffer.slice(
+              attachment.body.byteOffset,
+              attachment.body.byteOffset + attachment.body.byteLength
+            );
+            form.append(
+              "attachment",
+              new Blob([bytes], { type: attachment.mediaType }),
+              attachment.filename
+            );
+            await api(`add_attachment_to_result/${entry.id}`, { form });
+            attachmentsUploaded += 1;
+          } catch (err) {
+            deps.logger.warn(
+              `TestRail attachment "${attachment.filename}" failed: ${err.message}`
+            );
+          }
+        }
+      }
+      if (config.closeRun && config.runId === void 0) {
+        await api(`close_run/${runId}`, { body: {} });
+      }
+      return {
+        runId: String(runId),
+        runUrl,
+        recorded: recorded.length,
+        skipped,
+        attachmentsUploaded
+      };
+    }
+  };
+}
+
+// src/sync/adapters/xray.ts
+var DEFAULT_XRAY_BASE = "https://xray.cloud.getxray.app";
+var DEFAULT_TEST_TYPE = "Manual";
+var DEFAULT_MAX_ATTACHMENT_BYTES2 = 32 * 1024 * 1024;
+var PAGE_LIMIT2 = 100;
+function toAdf(text2) {
+  const paragraphs = text2.split("\n\n").filter((block) => block.trim() !== "");
+  return {
+    version: 1,
+    type: "doc",
+    content: paragraphs.length === 0 ? [{ type: "paragraph", content: [] }] : paragraphs.map((block) => ({
+      type: "paragraph",
+      content: [{ type: "text", text: block }]
+    }))
+  };
+}
+function fromAdf(value) {
+  if (typeof value === "string") return value;
+  if (!value || typeof value !== "object") return "";
+  const blocks = [];
+  const walk = (node, collected) => {
+    if (!node || typeof node !== "object") return;
+    const typed = node;
+    if (typed.type === "text" && typeof typed.text === "string") collected.push(typed.text);
+    for (const child of typed.content ?? []) walk(child, collected);
+  };
+  for (const node of value.content ?? []) {
+    const collected = [];
+    walk(node, collected);
+    blocks.push(collected.join(""));
+  }
+  return blocks.join("\n\n").trim();
+}
+function createXrayProvider(config, auth, deps) {
+  const xrayBase = (config.xrayBaseUrl ?? DEFAULT_XRAY_BASE).replace(/\/$/, "");
+  const jiraBase = config.jiraBaseUrl.replace(/\/$/, "");
+  const jql = config.jql ?? `project = "${config.projectKey}" AND issuetype = Test`;
+  const issueIds = /* @__PURE__ */ new Map();
+  let token;
+  async function authenticate() {
+    if (token) return token;
+    const response = await deps.fetch(`${xrayBase}/api/v2/authenticate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ client_id: auth.clientId, client_secret: auth.clientSecret })
+    });
+    const text2 = await response.text();
+    if (!response.ok) {
+      throw new Error(
+        `Xray authentication failed (${response.status}): ${text2}
+  XRAY_CLIENT_ID and XRAY_CLIENT_SECRET come from Jira -> Apps -> Xray -> API Keys. A Jira API token is a different credential and is rejected here.`
+      );
+    }
+    token = JSON.parse(text2).replace(/^"|"$/g, "");
+    return token;
+  }
+  async function graphql(query, variables) {
+    const bearer = await authenticate();
+    const response = await deps.fetch(`${xrayBase}/api/v2/graphql`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${bearer}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ query, variables })
+    });
+    const text2 = await response.text();
+    if (!response.ok) throw new Error(`Xray GraphQL failed (${response.status}): ${text2}`);
+    const payload = JSON.parse(text2);
+    if (payload.errors?.length) {
+      throw new Error(`Xray GraphQL error: ${payload.errors.map((e) => e.message).join("; ")}`);
+    }
+    return payload.data;
+  }
+  function issueUrl(key) {
+    return `${jiraBase}/browse/${key}`;
+  }
+  function toRemoteCase(test) {
+    const key = test.jira?.key ?? test.issueId;
+    if (!key) {
+      throw new Error(
+        `Xray returned a test with neither a Jira key nor an issue id: ${JSON.stringify(test)?.slice(0, 200)}`
+      );
+    }
+    if (test.jira?.key) issueIds.set(test.jira.key, test.issueId);
+    const { description, links } = decodeDescription(fromAdf(test.jira?.description));
+    return {
+      id: key,
+      url: issueUrl(key),
+      title: test.jira?.summary ?? key,
+      body: {
+        title: test.jira?.summary ?? key,
+        steps: (test.steps ?? []).map((step) => decodeStepText(step.action ?? "")),
+        description,
+        links
+      }
+    };
+  }
+  async function jiraUpdate(key, fields) {
+    if (!auth.jiraEmail || !auth.jiraToken) {
+      deps.logger.warn(
+        `Xray: summary/description for ${key} left unchanged. Set JIRA_EMAIL and JIRA_TOKEN to update Jira fields (steps are updated either way).`
+      );
+      return;
+    }
+    const basic = Buffer.from(`${auth.jiraEmail}:${auth.jiraToken}`).toString("base64");
+    const response = await deps.fetch(`${jiraBase}/rest/api/3/issue/${key}`, {
+      method: "PUT",
+      headers: { Authorization: `Basic ${basic}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ fields })
+    });
+    if (!response.ok) {
+      throw new Error(`Jira update of ${key} failed (${response.status}): ${await response.text()}`);
+    }
+  }
+  return {
+    name: "xray",
+    maxAttachmentBytes: config.maxAttachmentBytes ?? DEFAULT_MAX_ATTACHMENT_BYTES2,
+    describeTarget() {
+      return `${config.projectKey} (${jiraBase})`;
+    },
+    async listCases() {
+      const tests = [];
+      for (let start = 0; ; start += PAGE_LIMIT2) {
+        const data = await graphql(
+          `query($jql: String!, $limit: Int!, $start: Int!) {
+             getTests(jql: $jql, limit: $limit, start: $start) {
+               total
+               results {
+                 issueId
+                 jira(fields: ["key", "summary", "description"])
+                 steps { id action data result }
+               }
+             }
+           }`,
+          { jql, limit: PAGE_LIMIT2, start }
+        );
+        const page = data.getTests?.results ?? [];
+        tests.push(...page);
+        if (page.length < PAGE_LIMIT2) break;
+      }
+      return tests.map(toRemoteCase);
+    },
+    async createCase(body) {
+      const data = await graphql(
+        `mutation($testType: UpdateTestTypeInput!, $steps: [CreateStepInput], $jira: JSON!) {
+           createTest(testType: $testType, steps: $steps, jira: $jira) {
+             test { issueId jira(fields: ["key", "summary", "description"]) }
+             warnings
+           }
+         }`,
+        {
+          testType: { name: config.testType ?? DEFAULT_TEST_TYPE },
+          steps: body.steps.map((step) => ({ action: encodeStepText(step), result: "" })),
+          jira: {
+            fields: {
+              summary: body.title,
+              description: toAdf(encodeDescription(body)),
+              project: { key: config.projectKey }
+            }
+          }
+        }
+      );
+      const created = data.createTest?.test;
+      if (!created) throw new Error(`Xray createTest returned no test for "${body.title}"`);
+      for (const warning of data.createTest?.warnings ?? []) deps.logger.warn(`Xray: ${warning}`);
+      return toRemoteCase(created);
+    },
+    async updateCase(id, body) {
+      const issueId = issueIds.get(id);
+      if (!issueId) {
+        throw new Error(`Xray: no internal issue id cached for ${id}. Run listCases first.`);
+      }
+      const current = await graphql(
+        `query($issueId: String!) { getTest(issueId: $issueId) { steps { id } } }`,
+        { issueId }
+      );
+      const existing = current.getTest?.steps ?? [];
+      for (const [index, step] of body.steps.entries()) {
+        const action = encodeStepText(step);
+        const target = existing[index];
+        if (target) {
+          await graphql(
+            `mutation($stepId: String!, $step: UpdateStepInput!) {
+               updateTestStep(stepId: $stepId, step: $step)
+             }`,
+            { stepId: target.id, step: { action, result: "" } }
+          );
+        } else {
+          await graphql(
+            `mutation($issueId: String!, $step: CreateStepInput!) {
+               addTestStep(issueId: $issueId, step: $step) { id }
+             }`,
+            { issueId, step: { action, result: "" } }
+          );
+        }
+      }
+      for (const surplus of existing.slice(body.steps.length).reverse()) {
+        await graphql(`mutation($stepId: String!) { removeTestStep(stepId: $stepId) }`, {
+          stepId: surplus.id
+        });
+      }
+      await jiraUpdate(id, {
+        summary: body.title,
+        description: toAdf(encodeDescription(body))
+      });
+      return {
+        id,
+        url: issueUrl(id),
+        title: body.title,
+        body
+      };
+    },
+    async recordResults(results) {
+      const statuses = {
+        passed: config.statuses?.passed ?? "PASSED",
+        failed: config.statuses?.failed ?? "FAILED",
+        skipped: config.statuses?.skipped ?? "TODO"
+      };
+      let attachmentsUploaded = 0;
+      const tests = results.map((result) => {
+        const evidence = (result.attachments ?? []).map((attachment) => {
+          attachmentsUploaded += 1;
+          return {
+            data: Buffer.from(attachment.body).toString("base64"),
+            filename: attachment.filename,
+            contentType: attachment.mediaType
+          };
+        });
+        const comment = [result.message, result.url ? `Living documentation: ${result.url}` : void 0].filter(Boolean).join("\n\n");
+        return {
+          testKey: result.caseId,
+          status: statuses[result.status],
+          ...comment ? { comment } : {},
+          ...evidence.length > 0 ? { evidence } : {}
+        };
+      });
+      const bearer = await authenticate();
+      const payload = {
+        ...config.testExecutionKey ? { testExecutionKey: config.testExecutionKey } : {},
+        info: {
+          summary: `${config.executionSummary ?? "executable-stories"} ${(/* @__PURE__ */ new Date()).toISOString()}`,
+          project: config.projectKey,
+          ...config.testPlanKey ? { testPlanKey: config.testPlanKey } : {}
+        },
+        tests
+      };
+      const response = await deps.fetch(`${xrayBase}/api/v2/import/execution`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${bearer}`, "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      const text2 = await response.text();
+      if (!response.ok) {
+        throw new Error(`Xray import execution failed (${response.status}): ${text2}`);
+      }
+      const imported = JSON.parse(text2);
+      return {
+        runId: imported.key,
+        runUrl: imported.key ? issueUrl(imported.key) : void 0,
+        recorded: tests.length,
+        skipped: [],
+        attachmentsUploaded
+      };
+    }
+  };
+}
+
+// src/sync/adapters/index.ts
+var PROVIDER_NAMES = ["testrail", "xray"];
+function isProviderName(value) {
+  return PROVIDER_NAMES.includes(value);
+}
+function required(env, name, hint) {
+  const value = env[name];
+  if (!value) throw new Error(`Missing ${name}. ${hint}`);
+  return value;
+}
+function buildProvider(args, deps) {
+  const { name, targets, env } = args;
+  if (name === "testrail") {
+    const config2 = targets.testrail;
+    if (!config2) {
+      throw new Error(
+        'No TestRail config found. Add a `sync: { testrail: { url, projectId } }` block to executable-stories.config.mjs, or run "executable-stories sync testrail --init".'
+      );
+    }
+    const provider2 = createTestRailProvider(
+      config2,
+      {
+        username: required(env, "TESTRAIL_USERNAME", "This is the login email of the TestRail account."),
+        apiKey: required(
+          env,
+          "TESTRAIL_API_KEY",
+          "Generate one in TestRail under My Settings -> API Keys. A password will not work when the instance requires API keys."
+        )
+      },
+      deps
+    );
+    return {
+      provider: provider2,
+      // TestRail ids are numeric and conventionally written "C1234" in a ticket,
+      // so the prefix is decoration and gets stripped.
+      engineDefaults: { ticketPrefix: "C", ticketPrefixStrip: true }
+    };
+  }
+  const config = targets.xray;
+  if (!config) {
+    throw new Error(
+      'No Xray config found. Add a `sync: { xray: { jiraBaseUrl, projectKey } }` block to executable-stories.config.mjs, or run "executable-stories sync xray --init".'
+    );
+  }
+  const provider = createXrayProvider(
+    config,
+    {
+      clientId: required(env, "XRAY_CLIENT_ID", "Create an API key pair in Jira under Apps -> Xray -> API Keys."),
+      clientSecret: required(env, "XRAY_CLIENT_SECRET", "This is the secret half of the Xray API key pair."),
+      jiraEmail: env["JIRA_EMAIL"],
+      jiraToken: env["JIRA_TOKEN"]
+    },
+    deps
+  );
+  return {
+    provider,
+    // An Xray case id is a Jira issue key, so the project prefix is part of the
+    // id and must survive.
+    engineDefaults: { ticketPrefix: `${config.projectKey}-`, ticketPrefixStrip: false }
+  };
+}
+
+// src/index.ts
 import {
   STORY_REPORT_SCHEMA_VERSION,
   STORY_REPORT_SCHEMA_MAJOR
@@ -5512,21 +6901,21 @@ import {
 } from "executable-stories-core/converters/acl/validate";
 
 // src/coverage-index.ts
-function normalizePath(path10) {
-  return path10.replace(/^\.\//, "");
+function normalizePath(path11) {
+  return path11.replace(/^\.\//, "");
 }
 function scenariosCoveringPaths(index, paths) {
   const queries = paths.map(normalizePath);
   return index.scenarios.filter(
     (scenario) => scenario.covers.some(
-      (glob) => queries.some((path10) => matchesPattern(normalizePath(glob), path10))
+      (glob) => queries.some((path11) => matchesPattern(normalizePath(glob), path11))
     )
   );
 }
 
 // src/watch.ts
-import * as fs4 from "fs";
-import * as path5 from "path";
+import * as fs5 from "fs";
+import * as path6 from "path";
 import { canonicalizeRun } from "executable-stories-core/converters/acl/index";
 import { synthesizeStories } from "executable-stories-core/converters/synthesize";
 function toRun(data, inputType, synthesize) {
@@ -5536,8 +6925,8 @@ function toRun(data, inputType, synthesize) {
   return canonicalizeRun(raw);
 }
 async function regenerateRun(options, deps = {}) {
-  const read = deps.readFile ?? ((filePath) => fs4.readFileSync(filePath, "utf8"));
-  const data = JSON.parse(read(path5.resolve(options.input)));
+  const read = deps.readFile ?? ((filePath) => fs5.readFileSync(filePath, "utf8"));
+  const data = JSON.parse(read(path6.resolve(options.input)));
   const run = toRun(data, options.inputType ?? "raw", options.synthesize !== false);
   const generator = new ReportGenerator({
     formats: options.formats,
@@ -5553,7 +6942,7 @@ async function regenerateArtifacts(options, deps = {}) {
 function startWatch(options, deps = {}) {
   const log = deps.log ?? ((message) => console.log(message));
   const regenerate = deps.regenerate ?? ((input) => regenerateArtifacts({ ...options, input }, deps));
-  const watchFn = deps.watch ?? ((filePath, listener) => fs4.watch(filePath, listener));
+  const watchFn = deps.watch ?? ((filePath, listener) => fs5.watch(filePath, listener));
   const debounceMs = options.debounceMs ?? 150;
   let timer;
   let running = false;
@@ -5582,7 +6971,7 @@ function startWatch(options, deps = {}) {
     timer = setTimeout(() => void run(), debounceMs);
   };
   trigger();
-  const watcher = watchFn(path5.resolve(options.input), trigger);
+  const watcher = watchFn(path6.resolve(options.input), trigger);
   return {
     close: () => {
       if (timer) clearTimeout(timer);
@@ -5874,27 +7263,27 @@ async function updateDescription(issueKey, base, adf, headers, fetchFn) {
 import { parseNdjson, parseEnvelopes } from "executable-stories-core/converters/ndjson-parser";
 
 // src/utils/git-info.ts
-import * as fs5 from "fs";
-import * as path6 from "path";
+import * as fs6 from "fs";
+import * as path7 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 = path6.join(gitDir, "HEAD");
-    const head = fs5.readFileSync(headPath, "utf8").trim();
+    const headPath = path7.join(gitDir, "HEAD");
+    const head = fs6.readFileSync(headPath, "utf8").trim();
     if (!head.startsWith("ref:")) {
       return head;
     }
     const refPath = head.replace("ref:", "").trim();
-    const refFile = path6.join(gitDir, refPath);
-    if (fs5.existsSync(refFile)) {
-      return fs5.readFileSync(refFile, "utf8").trim();
+    const refFile = path7.join(gitDir, refPath);
+    if (fs6.existsSync(refFile)) {
+      return fs6.readFileSync(refFile, "utf8").trim();
     }
-    const packedRefs = path6.join(gitDir, "packed-refs");
-    if (fs5.existsSync(packedRefs)) {
-      const content = fs5.readFileSync(packedRefs, "utf8");
+    const packedRefs = path7.join(gitDir, "packed-refs");
+    if (fs6.existsSync(packedRefs)) {
+      const content = fs6.readFileSync(packedRefs, "utf8");
       for (const line of content.split("\n")) {
         if (!line || line.startsWith("#") || line.startsWith("^")) continue;
         const [sha, ref] = line.split(" ");
@@ -5909,19 +7298,19 @@ function readGitSha(cwd = process.cwd()) {
 function findGitDir(start) {
   let current = start;
   while (true) {
-    const candidate = path6.join(current, ".git");
-    if (fs5.existsSync(candidate)) {
-      const stat = fs5.statSync(candidate);
+    const candidate = path7.join(current, ".git");
+    if (fs6.existsSync(candidate)) {
+      const stat = fs6.statSync(candidate);
       if (stat.isFile()) {
-        const content = fs5.readFileSync(candidate, "utf8").trim();
+        const content = fs6.readFileSync(candidate, "utf8").trim();
         const match = content.match(/^gitdir: (.+)$/);
         if (match) {
-          return path6.resolve(current, match[1]);
+          return path7.resolve(current, match[1]);
         }
       }
       return candidate;
     }
-    const parent = path6.dirname(current);
+    const parent = path7.dirname(current);
     if (parent === current) return void 0;
     current = parent;
   }
@@ -5932,8 +7321,8 @@ function readBranchName(cwd = process.cwd()) {
   const gitDir = findGitDir(cwd);
   if (!gitDir) return void 0;
   try {
-    const headPath = path6.join(gitDir, "HEAD");
-    const head = fs5.readFileSync(headPath, "utf8").trim();
+    const headPath = path7.join(gitDir, "HEAD");
+    const head = fs6.readFileSync(headPath, "utf8").trim();
     if (head.startsWith("ref:")) {
       const refPath = head.replace("ref:", "").trim();
       const match = refPath.match(/^refs\/heads\/(.+)$/);
@@ -5951,8 +7340,8 @@ import { msToNanoseconds } from "executable-stories-core/utils/duration";
 import { nanosecondsToMs } from "executable-stories-core/utils/duration";
 
 // src/utils/metadata.ts
-import * as fs6 from "fs";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as path8 from "path";
 var versionCache = /* @__PURE__ */ new Map();
 function readPackageVersion(root) {
   if (versionCache.has(root)) {
@@ -5963,18 +7352,18 @@ function readPackageVersion(root) {
   return version;
 }
 function findPackageVersion(startDir) {
-  let current = path7.resolve(startDir);
+  let current = path8.resolve(startDir);
   while (true) {
-    const pkgPath = path7.join(current, "package.json");
+    const pkgPath = path8.join(current, "package.json");
     try {
-      if (fs6.existsSync(pkgPath)) {
-        const raw = fs6.readFileSync(pkgPath, "utf8");
+      if (fs7.existsSync(pkgPath)) {
+        const raw = fs7.readFileSync(pkgPath, "utf8");
         const parsed = JSON.parse(raw);
         return parsed.version;
       }
     } catch {
     }
-    const parent = path7.dirname(current);
+    const parent = path8.dirname(current);
     if (parent === current) {
       return void 0;
     }
@@ -6542,24 +7931,8 @@ function calculateFlakiness(args) {
   const countable = entries.filter(
     (e) => e.status === "passed" || e.status === "failed"
   );
-  if (countable.length < MIN_FLAKINESS_SAMPLES) {
-    return {
-      flakinessLevel: "stable",
-      flakinessScore: 0,
-      failureRate: 0,
-      longestPassStreak: countable.length,
-      longestFailStreak: 0
-    };
-  }
-  let transitions = 0;
-  for (let i = 1; i < countable.length; i++) {
-    if (countable[i].status !== countable[i - 1].status) {
-      transitions++;
-    }
-  }
-  const transitionScore = transitions / (countable.length - 1);
   const failures = countable.filter((e) => e.status === "failed").length;
-  const failureRate = failures / countable.length;
+  const failureRate = countable.length > 0 ? failures / countable.length : 0;
   let longestPassStreak = 0;
   let longestFailStreak = 0;
   let currentPassStreak = 0;
@@ -6579,6 +7952,22 @@ function calculateFlakiness(args) {
       }
     }
   }
+  if (countable.length < MIN_FLAKINESS_SAMPLES) {
+    return {
+      flakinessLevel: "stable",
+      flakinessScore: 0,
+      failureRate,
+      longestPassStreak,
+      longestFailStreak
+    };
+  }
+  let transitions = 0;
+  for (let i = 1; i < countable.length; i++) {
+    if (countable[i].status !== countable[i - 1].status) {
+      transitions++;
+    }
+  }
+  const transitionScore = transitions / (countable.length - 1);
   let flakinessLevel;
   if (transitionScore > 0.5 || transitionScore > 0.3 && failureRate > 0.2) {
     flakinessLevel = "flaky";
@@ -7171,7 +8560,7 @@ function statusIcon2(status) {
       return "\u2022";
   }
 }
-function escapeCell2(value) {
+function escapeCell3(value) {
   return value.replace(/\|/g, "\\|").replace(/\n/g, " ");
 }
 function intentSummary(intent) {
@@ -7200,7 +8589,7 @@ function renderWeakBand(lines, files) {
   lines.push(`## \u{1F7E1} Changed code with weak evidence (${weak.length})`);
   lines.push("");
   for (const file of weak) {
-    const covered = file.claims.map((c) => `${escapeCell2(c.scenario)} (${c.strength})`).join(", ");
+    const covered = file.claims.map((c) => `${escapeCell3(c.scenario)} (${c.strength})`).join(", ");
     lines.push(`- \`${file.path}\` _(${file.changeKind})_ \u2014 only: ${covered}`);
   }
   lines.push("");
@@ -7225,7 +8614,7 @@ function renderClaim(lines, claim) {
     );
   }
   if (claim.intent) {
-    lines.push(`- Why: ${escapeCell2(intentSummary(claim.intent))}`);
+    lines.push(`- Why: ${escapeCell3(intentSummary(claim.intent))}`);
   }
   lines.push("");
 }
@@ -7282,7 +8671,7 @@ function renderCodeDiff(lines, evidence) {
     } else {
       for (const ref of annotation.scenarios) {
         lines.push(
-          ref.resolved && ref.status ? `- ${statusIcon2(ref.status)} ${escapeCell2(ref.scenario ?? ref.id)} (\`${ref.id}\`)` : `- \u26A0\uFE0F \`${ref.id}\` \u2014 unverified reference (scenario not in this run)`
+          ref.resolved && ref.status ? `- ${statusIcon2(ref.status)} ${escapeCell3(ref.scenario ?? ref.id)} (\`${ref.id}\`)` : `- \u26A0\uFE0F \`${ref.id}\` \u2014 unverified reference (scenario not in this run)`
         );
       }
     }
@@ -7501,9 +8890,9 @@ function renderDiffHunk(file, hunk, anchoredStart, anchoredCount) {
     const sign = line.kind === "add" ? "+" : line.kind === "del" ? "-" : " ";
     return `<tr class="${cls}"><td class="diff-ln">${o}</td><td class="diff-ln">${n}</td><td class="diff-sign">${sign}</td><td class="diff-code">${escapeHtml3(line.text)}</td></tr>`;
   });
-  const path10 = file.newPath ?? file.oldPath ?? "";
+  const path11 = file.newPath ?? file.oldPath ?? "";
   return `<div class="diff-hunk">
-    <div class="diff-file-header"><code>${escapeHtml3(path10)}</code> <span class="subtle">@@ -${hunk.oldStart} +${hunk.newStart} @@ ${escapeHtml3(hunk.header)}</span></div>
+    <div class="diff-file-header"><code>${escapeHtml3(path11)}</code> <span class="subtle">@@ -${hunk.oldStart} +${hunk.newStart} @@ ${escapeHtml3(hunk.header)}</span></div>
     <table class="diff-table"><tbody>${rows.join("")}</tbody></table>
   </div>`;
 }
@@ -7738,8 +9127,8 @@ applyTheme(getEffectiveTheme());` : "";
 };
 
 // src/deploy/ledger.ts
-import * as fs7 from "fs";
-import * as path8 from "path";
+import * as fs8 from "fs";
+import * as path9 from "path";
 function createEmptyLedger() {
   return {
     deployments: [],
@@ -7747,12 +9136,12 @@ function createEmptyLedger() {
   };
 }
 function loadLedger(ledgerPath) {
-  const resolved = path8.resolve(ledgerPath);
-  if (!fs7.existsSync(resolved)) {
+  const resolved = path9.resolve(ledgerPath);
+  if (!fs8.existsSync(resolved)) {
     return createEmptyLedger();
   }
   try {
-    const raw = JSON.parse(fs7.readFileSync(resolved, "utf8"));
+    const raw = JSON.parse(fs8.readFileSync(resolved, "utf8"));
     if (raw.schemaVersion !== 1) {
       throw new Error(`Unsupported ledger schemaVersion: ${raw.schemaVersion}`);
     }
@@ -7763,10 +9152,10 @@ function loadLedger(ledgerPath) {
   }
 }
 function saveLedger(ledger, ledgerPath) {
-  const resolved = path8.resolve(ledgerPath);
-  const dir = path8.dirname(resolved);
-  fs7.mkdirSync(dir, { recursive: true });
-  fs7.writeFileSync(resolved, JSON.stringify(ledger, null, 2), "utf8");
+  const resolved = path9.resolve(ledgerPath);
+  const dir = path9.dirname(resolved);
+  fs8.mkdirSync(dir, { recursive: true });
+  fs8.writeFileSync(resolved, JSON.stringify(ledger, null, 2), "utf8");
 }
 function getLatestDeployment(ledger, environment) {
   return [...ledger.deployments].reverse().find((d) => d.environment === environment);
@@ -7893,11 +9282,11 @@ function computeOutputPath(sourceFile, format, mode, colocatedStyle, baseOutputD
   const ext = FORMAT_EXTENSIONS[format];
   const effectiveName = outputName + (outputNameSuffix ?? "");
   if (mode === "aggregated") {
-    return toPosix(path9.join(baseOutputDir, joinNameAndExt(effectiveName, ext)));
+    return toPosix(path10.join(baseOutputDir, joinNameAndExt(effectiveName, ext)));
   }
   const normalizedSource = toPosix(sourceFile);
-  const dirOfSource = path9.posix.dirname(normalizedSource);
-  let baseName = path9.posix.basename(normalizedSource);
+  const dirOfSource = path10.posix.dirname(normalizedSource);
+  let baseName = path10.posix.basename(normalizedSource);
   for (const testExt of TEST_EXTENSIONS) {
     if (baseName.endsWith(testExt)) {
       baseName = baseName.slice(0, -testExt.length);
@@ -7906,12 +9295,12 @@ function computeOutputPath(sourceFile, format, mode, colocatedStyle, baseOutputD
   }
   const fileName = `${baseName}.${effectiveName}${ext}`;
   if (colocatedStyle === "adjacent") {
-    return toPosix(path9.posix.join(dirOfSource, fileName));
+    return toPosix(path10.posix.join(dirOfSource, fileName));
   }
   if (colocatedStyle === "flat") {
-    return toPosix(path9.posix.join(baseOutputDir, `${cleanTestStem(normalizedSource)}${ext}`));
+    return toPosix(path10.posix.join(baseOutputDir, `${cleanTestStem(normalizedSource)}${ext}`));
   }
-  return toPosix(path9.posix.join(baseOutputDir, dirOfSource, fileName));
+  return toPosix(path10.posix.join(baseOutputDir, dirOfSource, fileName));
 }
 function groupTestCasesByOutput(testCases, format, options, logger, outputNameSuffix) {
   const groups = /* @__PURE__ */ new Map();
@@ -8131,8 +9520,8 @@ var ReportGenerator = class {
       if (astroPaths) {
         for (const mdPath of astroPaths) {
           const content = await fsPromises.readFile(mdPath, "utf8");
-          const mdDir = path9.dirname(mdPath);
-          const assetsDir = path9.resolve(this.options.astro.assetsDir);
+          const mdDir = path10.dirname(mdPath);
+          const assetsDir = path10.resolve(this.options.astro.assetsDir);
           const result = copyMarkdownAssets({
             markdown: content,
             markdownDir: mdDir,
@@ -8180,16 +9569,16 @@ var ReportGenerator = class {
       bySourceFile.set(sourceFile, outputPath);
     }
     if (bySourceFile.size === 0) return void 0;
-    const indexPath = toPosix(path9.join(this.options.outputDir, "index.html"));
+    const indexPath = toPosix(path10.join(this.options.outputDir, "index.html"));
     if (htmlPaths.some((p) => toPosix(p) === indexPath)) {
       this.deps.logger.warn?.(
         `Skipping colocated index: a report already occupies ${indexPath}.`
       );
       return void 0;
     }
-    const entries = buildIndexEntries(run, bySourceFile, path9.dirname(indexPath));
+    const entries = buildIndexEntries(run, bySourceFile, path10.dirname(indexPath));
     const html = renderColocatedIndex(entries, this.options.html.title);
-    await fsPromises.mkdir(path9.dirname(indexPath), { recursive: true });
+    await fsPromises.mkdir(path10.dirname(indexPath), { recursive: true });
     await this.deps.writeFile(indexPath, html);
     return indexPath;
   }
@@ -8208,9 +9597,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(path9.join(this.options.outputDir, joinNameAndExt(effectiveName, ext)));
+      const outputPath = toPosix(path10.join(this.options.outputDir, joinNameAndExt(effectiveName, ext)));
       const content = await this.formatContent(run, format);
-      const dir = path9.dirname(outputPath);
+      const dir = path10.dirname(outputPath);
       await fsPromises.mkdir(dir, { recursive: true });
       await this.deps.writeFile(outputPath, content);
       return [outputPath];
@@ -8222,7 +9611,7 @@ var ReportGenerator = class {
         testCases
       };
       const content = await this.formatContent(groupRun, format);
-      const dir = path9.dirname(outputPath);
+      const dir = path10.dirname(outputPath);
       await fsPromises.mkdir(dir, { recursive: true });
       await this.deps.writeFile(outputPath, content);
       writtenPaths.push(outputPath);
@@ -8413,7 +9802,7 @@ async function generateRunComparison(args) {
   await fsPromises.mkdir(outputDir, { recursive: true });
   for (const format of args.formats) {
     const ext = format === "html" ? ".html" : format === "changelog" ? ".changelog.md" : ".md";
-    const outputPath = toPosix(path9.join(outputDir, `${outputName}${ext}`));
+    const outputPath = toPosix(path10.join(outputDir, `${outputName}${ext}`));
     const content = format === "html" ? new RunDiffHtmlFormatter({ title: args.title }).format(diff) : format === "changelog" ? new RunDiffChangelogFormatter().format(diff) : new RunDiffMarkdownFormatter({ title: args.title }).format(diff);
     await fsPromises.writeFile(outputPath, content, "utf8");
     files.push(outputPath);
@@ -8440,6 +9829,7 @@ export {
   CucumberHtmlFormatter,
   CucumberJsonFormatter,
   CucumberMessagesFormatter,
+  DEFAULT_LOCKFILE_PATH,
   ES_THEME_TOKENS_CSS2 as ES_THEME_TOKENS_CSS,
   ES_THEME_TOKEN_VALUES,
   JUnitFormatter,
@@ -8447,6 +9837,7 @@ export {
   MIN_METRIC_SAMPLES,
   MIN_PERF_SAMPLES,
   MarkdownFormatter,
+  PROVIDER_NAMES,
   ReleaseManifestFormatter,
   ReportGenerator,
   ReviewHtmlFormatter,
@@ -8465,11 +9856,15 @@ export {
   adaptPlaywrightRun,
   adaptVitestRun,
   advanceState,
+  analyzeSync,
+  applySync,
   assembleCodeDiff,
   assertValidRun,
   buildCheck,
+  buildCoverageJson,
   buildGoal,
   buildHtmlDocEntry,
+  buildProvider,
   buildReview,
   buildTriage,
   bundleAssets,
@@ -8479,11 +9874,14 @@ export {
   classifyStatusChange,
   clearVersionCache,
   codeDiffDiagnostics,
+  collectAttachments,
   computeTestMetrics,
   copyMarkdownAssets,
   createAnchor,
   createPrCommentSummary,
   createReportGenerator,
+  createTestRailProvider,
+  createXrayProvider,
   deriveAudience,
   deriveChangeType,
   deriveStepResults,
@@ -8491,6 +9889,7 @@ export {
   detectPerformanceTrend,
   diffRuns,
   diffStoryReports,
+  emptyLockfile,
   findGitDir,
   formatDuration4 as formatDuration,
   generateRunComparison,
@@ -8500,7 +9899,9 @@ export {
   getEnvironmentDrift,
   gradeEvidence,
   hasSufficientHistory,
+  hashCaseBody,
   initialRunState,
+  isProviderName,
   isReviewableSource,
   isTestFile,
   joinNameAndExt,
@@ -8515,19 +9916,26 @@ export {
   normalizeStatus,
   normalizeVitestResults,
   parseEnvelopes,
+  parseLockfile,
   parseNdjson,
   parseUnifiedDiff,
+  projectBehaviours,
   publishConfluencePage,
   publishJiraIssue,
   readBranchName,
   readGitSha,
+  readLockfile,
   readPackageVersion,
   recordDeployment,
   regenerateArtifacts,
   regenerateRun,
   relocateAnchor,
+  renderApplyResult,
   renderCheck,
+  renderCoverageMarkdown,
+  renderCoverageText,
   renderGoal,
+  renderPlan,
   renderTriage,
   resolveAttachment,
   resolveAttachments,
@@ -8539,6 +9947,7 @@ export {
   sendSlackNotification,
   sendTeamsNotification,
   sendWebhookNotification,
+  serializeLockfile,
   signBody,
   slugify2 as slugify,
   startWatch,
@@ -8546,6 +9955,7 @@ export {
   toAgentText,
   toBehaviorManifest,
   toCIInfo,
+  toCaseBody,
   toRawCIInfo,
   toReleaseManifest,
   toScenarioIndex,
@@ -8553,6 +9963,7 @@ export {
   toTraceabilityMatrix,
   tryGetActiveOtelContext,
   updateHistory,
-  validateCanonicalRun
+  validateCanonicalRun,
+  writeLockfile
 };
 //# sourceMappingURL=index.js.map