@suveren/gateway 0.18.1 → 0.19.0

package/dist/mcp-server/chunk-ZRRZFGRL.mjs

@@ -0,0 +1,2412 @@
+// src/lib/as-pairing.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+function pairingPath(dataDir) {
+  return join(dataDir, "as-pairing.json");
+}
+function readPairing(dataDir) {
+  const path = pairingPath(dataDir);
+  if (!existsSync(path)) return null;
+  try {
+    const data = JSON.parse(readFileSync(path, "utf-8"));
+    if (typeof data.asUrl !== "string" || typeof data.publicKeyHex !== "string") return null;
+    return {
+      asUrl: data.asUrl,
+      publicKeyHex: data.publicKeyHex,
+      pairedAt: data.pairedAt ?? "",
+      ...typeof data.tlsSpkiPinHex === "string" ? { tlsSpkiPinHex: data.tlsSpkiPinHex } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function fingerprintOf(publicKeyHex) {
+  const raw = Buffer.from(publicKeyHex, "hex");
+  const digest = createHash("sha256").update(raw).digest("hex").toUpperCase();
+  return digest.match(/.{1,4}/g)?.join(":") ?? digest;
+}
+
+// src/lib/report/sanitize.ts
+import sanitizeHtmlLib from "sanitize-html";
+import { parseDocument } from "htmlparser2";
+
+// src/lib/report-brief.ts
+var REPORT_ELEMENTS = [
+  "sv-ticket",
+  "sv-approval",
+  "sv-mandate",
+  "sv-record",
+  "sv-case",
+  "sv-metric"
+];
+var REPORT_BLOCKS = ["sv-ai", "sv-row", "sv-glossary", "sv-term"];
+var REPORT_BRIEF = `How to write a report
+
+Purpose: regular reports on what you did in your reporting window \u2014 this week, this test, this month \u2014 for managers who are not technical. Plain words, short sentences, the result first. Each write replaces the previous report.
+
+Your window: the reporting mandate sets how many days back you may report. list_tickets returns it ("window"), and write_report repeats it. Tickets and records from before it cannot be used.
+
+The format \u2014 only these blocks, one after another. Anything else is dropped (write_report tells you how much):
+
+1. <sv-ai>\u2026</sv-ai> \u2014 your own content: headings, text, tables, inline SVG charts, your assessment. Any HTML inside, styled with inline style="\u2026" attributes only (no <style> blocks, no JavaScript, no external files or links). The gateway draws it in a grey frame labelled "AI analysis \u2014 not verified".
+2. Verified elements \u2014 you give a reference, the gateway checks it and draws the box. You never write their content:
+   - <sv-ticket ref="TICKET_ID" variant="compact"></sv-ticket> \u2014 one action: action + time. variant="full" shows every signed field (incl. its mandate and approval) and the public check link.
+   - <sv-approval ticket="TICKET_ID"></sv-approval> \u2014 when the approval was asked and decided, and by whom.
+   - <sv-mandate ticket="TICKET_ID"></sv-mandate> \u2014 the authority the action ran under: limits, mode, intent.
+   - <sv-record system="email|crm|erp" ref="RECORD_ID"></sv-record> \u2014 an email, CRM entry, quote or order.
+   - <sv-case start="email:MESSAGE_ID" goal="ticket:TICKET_ID" steps="TICKET_ID TICKET_ID"></sv-case> \u2014 one business case from its start email to the ticket that completed it.
+   - <sv-metric kind="KIND" cases="all"></sv-metric> \u2014 a number the gateway computes over your cases. KIND: completed, median-time, average-time, without-approval, approvals, median-approval-wait, tickets, refusals. cases is "all" or case ids, e.g. cases="C1 C3".
+3. <sv-row>\u2026</sv-row> \u2014 puts verified elements side by side (they stack on a phone). Only verified elements inside.
+4. <sv-glossary lang="de"><sv-term key="erp__create_quote">Angebot erstellt</sv-term></sv-glossary> \u2014 optional, once per report. Translates field names and fixed words that appear in the verified boxes (action names, profile, mode, field names such as value_max). Words only: never numbers, amounts, times or ids; plain text, at most 60 characters. The reader sees it small above the raw value, only when they switch translation on. Unknown keys are ignored.
+
+Example:
+<sv-ai><h1>Week 41: three requests answered</h1><p>One quote needed an approval.</p></sv-ai>
+<sv-row><sv-metric kind="completed" cases="all"></sv-metric><sv-metric kind="approvals" cases="all"></sv-metric></sv-row>
+<sv-ai><p>The quote for Huber went out 9 minutes after the request.</p></sv-ai>
+<sv-ticket ref="rcpt_123" variant="full"></sv-ticket>
+
+Rules:
+1. Nothing verified inside sv-ai: an sv-* element there is removed, and class names starting with "sv-" are removed from your HTML. Do not imitate the green boxes \u2014 your content always sits in the grey frame.
+2. Verified boxes show only signed field names and raw values. Explain them in plain words in the sv-ai block next to them.
+3. Use sv-metric for every headline number. Numbers you compute yourself stay "AI analysis \u2014 not verified".
+4. A wrong or unknown reference is shown as "not verifiable". Do not guess IDs \u2014 read them first (list_tickets, get_ticket, list_cases, get_records).
+5. Never claim more than the boxes prove. Say plainly what went wrong or waited for a person.
+
+Cases and coverage apply only when test data is loaded (list_cases shows it):
+- Define every case you worked on with sv-case. The gateway shows how many of the loaded cases your report covers, names the missing ones, and lists every ticket from the window that your report does not reference \u2014 so name every step.
+- A case's goal must be what actually completed it \u2014 for an email reply, the reply to the start email. A case is timed from when its email reached the test (the test data may date its emails earlier \u2014 the gateway uses the later of the two).
+
+Layout: it must read well on a phone, in a narrow side panel (about 360 pixels) and on a large screen. Inside sv-ai use fluid widths, wrapping flex/grid, tables that scroll, and SVG charts with a viewBox.
+
+Suggested structure: the result in one sentence (sv-ai) \u2192 3\u20134 sv-metric in an sv-row \u2192 each case (sv-case, then the tickets and approvals that explain it, each with a short sv-ai caption) \u2192 what was stopped or waited for a person \u2192 your assessment (sv-ai).`;
+
+// src/lib/report/sanitize.ts
+var STRUCTURE_TAGS = new Set(REPORT_BLOCKS);
+var VERIFIED_KINDS = new Set(REPORT_ELEMENTS);
+var MAX_GLOSS_CHARS = 60;
+var CHECK_MARK_RE = /[✓✔✅☑☒✗✘❌❎\u{1f5f8}]/u;
+var FORBIDDEN_IN_AI = /* @__PURE__ */ new Set([
+  "script",
+  "iframe",
+  "object",
+  "embed",
+  "link",
+  "base",
+  "meta",
+  "style",
+  "frame",
+  "frameset",
+  "portal",
+  "fencedframe",
+  "applet",
+  "plaintext",
+  "xmp",
+  "listing",
+  "noembed",
+  "noframes",
+  "dialog",
+  "select"
+]);
+function isUrlAttribute(name) {
+  const n = name.toLowerCase();
+  return n === "href" || n === "src" || n === "srcset" || n === "action" || n === "formaction" || n === "poster" || n === "background" || n === "ping" || n === "data" || n === "xlink:href" || n.endsWith(":href");
+}
+function isAllowedUrl(value) {
+  const v = value.trim();
+  if (v.startsWith("#")) return true;
+  if (/^data:image\//i.test(v)) return true;
+  return false;
+}
+function cleanInlineStyle(value) {
+  return value.split(";").filter((decl) => {
+    if (/@import/i.test(decl)) return false;
+    if (/image-set\s*\(/i.test(decl)) return false;
+    const urls = [...decl.matchAll(/url\s*\(\s*(['"]?)([^'")]*)/gi)];
+    return urls.every((m) => /^data:image\//i.test(m[2].trim()));
+  }).join(";").trim();
+}
+function stripGatewayClasses(value) {
+  return value.split(/\s+/).filter((c) => c && !/^sv-/i.test(c)).join(" ");
+}
+function escapeAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function textOf(node) {
+  if (node.type === "text") return node.data ?? "";
+  return (node.children ?? []).map(textOf).join("");
+}
+function countTags(node, pred) {
+  let n = 0;
+  for (const c of node.children ?? []) {
+    if (c.type === "tag" || c.type === "script" || c.type === "style") {
+      if (pred(c.name ?? "")) {
+        n++;
+        continue;
+      }
+      n += countTags(c, pred);
+    }
+  }
+  return n;
+}
+function isElement(node) {
+  return node.type === "tag" || node.type === "script" || node.type === "style";
+}
+function serializeVerified(node) {
+  const attrs = Object.entries(node.attribs ?? {}).filter(([k]) => /^[a-z][a-z0-9_-]*$/i.test(k) && !/^on/i.test(k)).map(([k, v]) => ` ${k.toLowerCase()}="${escapeAttr(v)}"`).join("");
+  return `<${node.name}${attrs}></${node.name}>`;
+}
+function sanitizeAiContent(inner) {
+  return sanitizeHtmlLib(inner, {
+    // Deny-by-name, not allow-by-name: the AI writes free HTML structure and
+    // inline SVG; `transformTags['*']` below is the ONLY attribute filter.
+    // `allowVulnerableTags` silences sanitize-html's notice about style/script
+    // — both are still removed by `exclusiveFilter`.
+    allowedTags: false,
+    allowedAttributes: false,
+    allowVulnerableTags: true,
+    allowedSchemes: [...sanitizeHtmlLib.defaults.allowedSchemes, "data"],
+    // Keep camelCase SVG attributes (viewBox, …); every check below folds case.
+    parser: { lowerCaseAttributeNames: false },
+    exclusiveFilter: (frame) => {
+      const tag = frame.tag.toLowerCase();
+      if (FORBIDDEN_IN_AI.has(tag)) return true;
+      if (tag.startsWith("sv-")) return true;
+      return false;
+    },
+    transformTags: {
+      "*": (tagName, attribs) => {
+        const lowerTag = tagName.toLowerCase();
+        if (lowerTag === "html" || lowerTag === "head" || lowerTag === "body" || lowerTag === "title") {
+          return { tagName: "div", attribs: {} };
+        }
+        const kept = {};
+        for (const [name, value] of Object.entries(attribs)) {
+          const lower = name.toLowerCase();
+          if (lower.startsWith("on")) continue;
+          if (isUrlAttribute(name) && !isAllowedUrl(value)) continue;
+          if (lower.startsWith("data-sv")) continue;
+          if (lower === "popover" || lower === "popovertarget" || lower === "popovertargetaction") continue;
+          if (lower === "id" && /^sv-/i.test(value.trim())) continue;
+          if (lower === "class") {
+            const classes = stripGatewayClasses(value);
+            if (classes) kept[name] = classes;
+            continue;
+          }
+          if (lower === "style") {
+            const style = cleanInlineStyle(value);
+            if (style) kept[name] = style;
+            continue;
+          }
+          kept[name] = value;
+        }
+        return { tagName, attribs: kept };
+      }
+    }
+  });
+}
+function sanitizeReport(html) {
+  const notes = {
+    droppedBlocks: 0,
+    droppedSvInsideAi: 0,
+    droppedStyles: 0,
+    extraGlossaries: 0,
+    rejectedTerms: []
+  };
+  const doc = parseDocument(html, {
+    withStartIndices: true,
+    withEndIndices: true,
+    recognizeSelfClosing: true,
+    decodeEntities: true
+  });
+  const out = [];
+  let glossarySeen = false;
+  const isBlank = (n) => n.type === "text" && !(n.data ?? "").trim();
+  const isIgnorable = (n) => isBlank(n) || n.type === "comment" || n.type === "directive" || n.type === "cdata";
+  function emitVerified(node, sink, inRow) {
+    sink.push(serializeVerified(node));
+    for (const c of node.children ?? []) processAt(c, sink, inRow);
+  }
+  function emitAi(node) {
+    notes.droppedSvInsideAi += countTags(node, (n) => n.startsWith("sv-"));
+    notes.droppedStyles += countTags(node, (n) => n === "style");
+    const children = node.children ?? [];
+    let inner = "";
+    if (children.length > 0) {
+      const start = children[0].startIndex;
+      const end = children[children.length - 1].endIndex;
+      if (start !== null && end !== null) inner = html.slice(start, end + 1);
+    }
+    out.push(`<sv-ai>${sanitizeAiContent(inner)}</sv-ai>`);
+  }
+  function emitGlossary(node) {
+    if (glossarySeen) {
+      notes.extraGlossaries++;
+      return;
+    }
+    glossarySeen = true;
+    const lang = (node.attribs?.lang ?? "").trim().slice(0, 16);
+    const seen = /* @__PURE__ */ new Set();
+    const terms = [];
+    const visit = (n) => {
+      for (const c of n.children ?? []) {
+        if (!isElement(c)) continue;
+        if (c.name !== "sv-term") {
+          visit(c);
+          continue;
+        }
+        const key2 = (c.attribs?.key ?? "").trim();
+        const text = textOf(c).replace(/\s+/g, " ").trim();
+        if (!key2) continue;
+        if (seen.has(key2)) {
+          notes.rejectedTerms.push({ key: key2, reason: "duplicate key \u2014 the first entry is used" });
+          continue;
+        }
+        if (!text) {
+          notes.rejectedTerms.push({ key: key2, reason: "empty translation" });
+          continue;
+        }
+        if (text.length > MAX_GLOSS_CHARS) {
+          notes.rejectedTerms.push({ key: key2, reason: `longer than ${MAX_GLOSS_CHARS} characters` });
+          continue;
+        }
+        if (CHECK_MARK_RE.test(text)) {
+          notes.rejectedTerms.push({ key: key2, reason: "contains a check mark" });
+          continue;
+        }
+        seen.add(key2);
+        terms.push(`<sv-term key="${escapeAttr(key2)}">${escapeText(text)}</sv-term>`);
+      }
+    };
+    visit(node);
+    out.push(`<sv-glossary${lang ? ` lang="${escapeAttr(lang)}"` : ""}>${terms.join("")}</sv-glossary>`);
+  }
+  function emitRow(node) {
+    const items = [];
+    for (const c of node.children ?? []) processAt(c, items, true);
+    if (items.length > 0) out.push(`<sv-row>${items.join("")}</sv-row>`);
+  }
+  function processAt(node, sink, inRow) {
+    if (isIgnorable(node)) return;
+    if (!isElement(node)) {
+      notes.droppedBlocks++;
+      return;
+    }
+    const name = node.name ?? "";
+    if (!inRow) {
+      if (name === "html" || name === "body") {
+        for (const c of node.children ?? []) processAt(c, sink, false);
+        return;
+      }
+      if (name === "head") {
+        notes.droppedStyles += countTags(node, (n) => n === "style");
+        return;
+      }
+      if (name === "sv-ai") {
+        emitAi(node);
+        return;
+      }
+      if (name === "sv-row") {
+        emitRow(node);
+        return;
+      }
+      if (name === "sv-glossary") {
+        emitGlossary(node);
+        return;
+      }
+    }
+    if (name.startsWith("sv-") && !STRUCTURE_TAGS.has(name)) {
+      emitVerified(node, sink, inRow);
+      return;
+    }
+    if (name === "style") notes.droppedStyles++;
+    else notes.droppedBlocks++;
+  }
+  for (const c of doc.children ?? []) processAt(c, out, false);
+  return { html: out.join("\n"), notes };
+}
+function sanitizeReportHtml(html) {
+  return sanitizeReport(html).html;
+}
+
+// src/lib/report/render-report.ts
+import { parseDocument as parseDocument2 } from "htmlparser2";
+
+// src/lib/report/format.ts
+import { getProfile } from "@hap/core";
+var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+var drawingZone;
+function withDrawingZone(tz, fn) {
+  const prev = drawingZone;
+  drawingZone = tz;
+  try {
+    return fn();
+  } finally {
+    drawingZone = prev;
+  }
+}
+function zonedParts(epochSeconds) {
+  const d = new Date(epochSeconds * 1e3);
+  if (drawingZone === void 0) {
+    return {
+      year: d.getFullYear(),
+      month: d.getMonth() + 1,
+      day: d.getDate(),
+      hour: d.getHours(),
+      minute: d.getMinutes(),
+      second: d.getSeconds(),
+      offsetMin: -d.getTimezoneOffset()
+    };
+  }
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: drawingZone,
+    hourCycle: "h23",
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric"
+  }).formatToParts(d);
+  const get = (t) => Number(parts.find((x) => x.type === t)?.value ?? NaN);
+  const p = { year: get("year"), month: get("month"), day: get("day"), hour: get("hour"), minute: get("minute"), second: get("second") };
+  const wallMs = Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second);
+  const offsetMin = Math.round((wallMs - Math.floor(d.getTime() / 1e3) * 1e3) / 6e4);
+  return { ...p, offsetMin };
+}
+function offsetLabel(offsetMin) {
+  if (offsetMin === 0) return "UTC";
+  const sign = offsetMin > 0 ? "+" : "-";
+  const abs = Math.abs(offsetMin);
+  const mm = abs % 60;
+  return `UTC${sign}${Math.floor(abs / 60)}${mm ? ":" + String(mm).padStart(2, "0") : ""}`;
+}
+function formatDateTime(value) {
+  const n = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(n)) return "unknown time";
+  const z = zonedParts(n);
+  const hh = String(z.hour).padStart(2, "0");
+  const mm = String(z.minute).padStart(2, "0");
+  return `${z.day} ${MONTHS[z.month - 1]}, ${hh}:${mm}`;
+}
+function formatDuration(value) {
+  const n = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(n) || n < 0) return "unknown duration";
+  const mins = Math.round(n / 60);
+  if (mins < 60) return `${mins} min`;
+  const hrs = Math.floor(mins / 60);
+  const rem = mins % 60;
+  return `${hrs} h ${String(rem).padStart(2, "0")} min`;
+}
+function groupThousands(n) {
+  const sign = n < 0 ? "-" : "";
+  const [intPart, frac] = Math.abs(n).toString().split(".");
+  const grouped = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, " ");
+  return sign + grouped + (frac ? `.${frac}` : "");
+}
+var CURRENCY_SYMBOLS = { EUR: "\u20AC", USD: "$", GBP: "\xA3" };
+function formatCurrency(amount, currencyCode) {
+  const n = typeof amount === "number" ? amount : Number(amount);
+  if (!Number.isFinite(n)) return String(amount ?? "");
+  if (!currencyCode) return groupThousands(n);
+  const code = currencyCode.toUpperCase();
+  const symbol = CURRENCY_SYMBOLS[code];
+  return symbol ? `${symbol} ${groupThousands(n)}` : `${code} ${groupThousands(n)}`;
+}
+function formatBoundValue(unit, value, fallbackCurrency) {
+  const n = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(n)) return String(value ?? "");
+  if (!unit || unit === "count") {
+    return fallbackCurrency ? formatCurrency(n, fallbackCurrency) : groupThousands(n);
+  }
+  if (unit === "minutes") return `${groupThousands(n)} min`;
+  if (unit === "hours") return `${groupThousands(n)} h`;
+  if (unit === "days") return `${groupThousands(n)} d`;
+  if (unit === "percent") return `${groupThousands(n)}%`;
+  if (unit.startsWith("currency:")) return formatCurrency(n, unit.slice("currency:".length));
+  return `${groupThousands(n)} ${unit}`;
+}
+function humanizeKey(key2) {
+  return key2.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function formatBoundLabel(profileId, key2, value, fallbackCurrency) {
+  const profile = profileId ? getProfile(profileId) : void 0;
+  const field = profile?.boundsSchema?.fields?.[key2];
+  const displayName = field?.displayName ?? humanizeKey(key2);
+  return `${displayName}: ${formatBoundValue(field?.unit, value, fallbackCurrency)}`;
+}
+var UNDISCLOSED_OWNER_LABEL = "Owner (name not disclosed)";
+function formatOwnerLabel(did) {
+  if (!did) return "Unknown owner";
+  return UNDISCLOSED_OWNER_LABEL;
+}
+function profileShortLabel(profileId) {
+  if (!profileId) return "Unknown profile";
+  const name = profileId.split("@")[0].split("/").pop();
+  if (!name) return profileId;
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+var ACTION_LABELS = {
+  create_quote: "Quote created",
+  update_quote: "Quote updated",
+  send_quote: "Quote sent",
+  convert_quote_to_order: "Order placed",
+  create_order: "Order created",
+  update_order: "Order updated",
+  send_message: "Reply sent",
+  send_email: "Reply sent",
+  create_contact: "Contact created",
+  update_contact: "Contact updated",
+  create_deal: "Deal created",
+  update_deal: "Deal updated",
+  create_task: "Task created",
+  update_task: "Task updated",
+  log_activity: "Activity logged",
+  create_record: "Record created",
+  update_record: "Record updated",
+  delete_record: "Record deleted",
+  create_event: "Event created",
+  update_event: "Event updated",
+  delete_event: "Event deleted",
+  publish_post: "Post published"
+};
+var IRREGULAR_PAST = {
+  write: "written",
+  rewrite: "rewritten",
+  send: "sent",
+  resend: "resent",
+  run: "run",
+  rerun: "rerun",
+  set: "set",
+  reset: "reset",
+  put: "put",
+  make: "made",
+  build: "built",
+  rebuild: "rebuilt",
+  begin: "begun",
+  take: "taken",
+  give: "given",
+  do: "done",
+  redo: "redone",
+  read: "read",
+  find: "found",
+  get: "retrieved",
+  buy: "bought",
+  pay: "paid",
+  sell: "sold",
+  hold: "held",
+  keep: "kept",
+  leave: "left",
+  draw: "drawn",
+  withdraw: "withdrawn",
+  forbid: "forbidden",
+  choose: "chosen",
+  speak: "spoken",
+  meet: "met",
+  lead: "led",
+  split: "split",
+  cut: "cut",
+  upload: "uploaded",
+  forward: "forwarded",
+  bring: "brought",
+  tell: "told",
+  show: "shown",
+  drive: "driven",
+  break: "broken"
+};
+var DOUBLE_FINAL = /* @__PURE__ */ new Set(["stop", "plan", "ship", "tag", "log", "submit", "drop", "flag", "pin", "unpin", "map", "wrap", "chat", "admit", "commit", "permit", "refer", "transfer"]);
+function pastTense(verb) {
+  if (!verb) return verb;
+  const lower = verb.toLowerCase();
+  if (IRREGULAR_PAST[lower]) return IRREGULAR_PAST[lower];
+  if (DOUBLE_FINAL.has(lower)) return `${verb}${verb.slice(-1)}ed`;
+  if (/e$/.test(verb)) return `${verb}d`;
+  if (/[^aeiou]y$/i.test(verb)) return `${verb.slice(0, -1)}ied`;
+  return `${verb}ed`;
+}
+function capitalize(s) {
+  return s.length > 0 ? s.charAt(0).toUpperCase() + s.slice(1) : s;
+}
+function formatActionLabel(action) {
+  const raw = String(action ?? "").trim();
+  if (!raw) return "Action";
+  const withoutSystem = raw.includes("__") ? raw.slice(raw.indexOf("__") + 2) : raw;
+  const known = ACTION_LABELS[withoutSystem];
+  if (known) return known;
+  const parts = withoutSystem.split("_").filter(Boolean);
+  if (parts.length === 0) return capitalize(raw);
+  const [verb, ...rest] = parts;
+  if (rest.length === 0) return capitalize(pastTense(verb));
+  return `${capitalize(rest.join(" "))} ${pastTense(verb)}`;
+}
+function formatTimestamp(value) {
+  const n = typeof value === "number" ? value : parseTimestampSecondsLoose(value);
+  if (n === void 0 || !Number.isFinite(n)) return String(value ?? "");
+  const z = zonedParts(n);
+  const p = (x) => String(x).padStart(2, "0");
+  return `${z.year}-${p(z.month)}-${p(z.day)} ${p(z.hour)}:${p(z.minute)}:${p(z.second)} ${offsetLabel(z.offsetMin)}`;
+}
+function parseTimestampSecondsLoose(value) {
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  if (/^\d+(\.\d+)?$/.test(value.trim())) return Number(value);
+  const iso = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}/.test(value) && !/[zZ]|[+-]\d{2}:?\d{2}$/.test(value) ? `${value.replace(" ", "T")}Z` : value;
+  const ms = Date.parse(iso);
+  return Number.isFinite(ms) ? Math.floor(ms / 1e3) : void 0;
+}
+
+// src/lib/report/render-report.ts
+function escapeHtml(value) {
+  return String(value ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function isGlossableWord(value) {
+  const v = value.trim();
+  if (!v || v.length > 120) return false;
+  if (!/[A-Za-z]/.test(v)) return false;
+  if (/\d{4,}/.test(v)) return false;
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-/i.test(v)) return false;
+  if (/^(rcpt|authz|tkt|msg|q|o)[_-]/i.test(v)) return false;
+  if (/@.+\./.test(v) && !/@\d/.test(v)) return false;
+  return true;
+}
+function glossed(ctx, raw, cls) {
+  const base = `<span class="${cls}">${escapeHtml(raw)}</span>`;
+  if (ctx.mode === "off") return base;
+  const gloss = ctx.terms.get(raw);
+  if (gloss === void 0) return base;
+  ctx.used.add(raw);
+  return `<ruby class="sv-gloss">${base}<rt>${escapeHtml(gloss)}</rt></ruby>`;
+}
+function key(ctx, name) {
+  return glossed(ctx, name, "sv-k");
+}
+function word(ctx, value) {
+  const s = String(value ?? "");
+  if (!isGlossableWord(s)) return val(value);
+  return glossed(ctx, s, "sv-v");
+}
+function val(value) {
+  return `<span class="sv-v">${escapeHtml(value)}</span>`;
+}
+function ts(value) {
+  return val(formatTimestamp(value));
+}
+function kv(k, v, extra = "") {
+  return `<div class="sv-kv${extra}">${k}${v}</div>`;
+}
+function scalar(value) {
+  if (value === null || value === void 0 || value === "") return void 0;
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function rawNumber(value) {
+  const n = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(n)) return String(value ?? "");
+  if (Number.isInteger(n)) return String(n);
+  return String(Math.round(n * 1e4) / 1e4);
+}
+function formula(text) {
+  return `<span class="sv-f">= ${escapeHtml(text)}</span>`;
+}
+var TIME_KEY_RE = /(^|_|\.)(at|timestamp)$|At$|_at$/;
+var SOURCE_BY_KIND = {
+  "sv-ticket": "signed",
+  "sv-mandate": "signed",
+  "sv-approval": "archive",
+  "sv-record": "database",
+  "sv-case": "computed",
+  "sv-metric": "computed"
+};
+function seal(status, source) {
+  if (status === "verified") {
+    return `<span class="sv-badge sv-badge-ok sv-seal" data-sv-source="${source}">\u2713 verified \xB7 ${source}</span>`;
+  }
+  if (status === "warning") {
+    return `<span class="sv-badge sv-badge-warn sv-seal" data-sv-source="${source}">\u26A0 verified \xB7 ${source} \xB7 with a note</span>`;
+  }
+  return `<span class="sv-badge sv-badge-bad">\u2717 not verifiable</span>`;
+}
+function card(el, body, opts = {}) {
+  const source = SOURCE_BY_KIND[el.kind] ?? "computed";
+  const note = el.status === "warning" && el.reason ? `<div class="sv-note">${escapeHtml(el.reason)}</div>` : "";
+  if (opts.compact) {
+    return `<div class="sv-el sv-el-${el.status} sv-compact" data-sv-id="${escapeHtml(el.id)}"><div class="sv-vline"><div class="sv-kv-row">${body}</div>${seal(el.status, source)}</div>${note}</div>`;
+  }
+  return `<div class="sv-el sv-el-${el.status}" data-sv-id="${escapeHtml(el.id)}"><div class="sv-vhead">${opts.head ?? "<span></span>"}${seal(el.status, source)}</div>` + note + body + `</div>`;
+}
+function unverifiableCard(el) {
+  return `<div class="sv-el sv-el-unverifiable" data-sv-id="${escapeHtml(el.id)}"><div class="sv-vhead"><span class="sv-k">${escapeHtml(el.kind)}</span>${seal("unverifiable", "computed")}</div><div class="sv-reason">${escapeHtml(el.reason ?? "This reference could not be checked.")}</div></div>`;
+}
+function checkLink(href) {
+  return typeof href === "string" && href ? `<div class="sv-link"><a href="${escapeHtml(href)}" target="_blank" rel="noopener noreferrer">Check on suveren.ai \u2197</a></div>` : "";
+}
+function contextRows(ctx, entries, indent = false) {
+  return Object.entries(entries).map(([k, v]) => {
+    const s = scalar(v);
+    if (s === void 0) return "";
+    return kv(key(ctx, k), typeof v === "string" ? word(ctx, v) : val(s), indent ? " sv-in" : "");
+  }).join("");
+}
+function mandateRows(ctx, m, indent) {
+  const rows = [];
+  const rawLimits = m.rawLimits ?? {};
+  rows.push(contextRows(ctx, rawLimits, indent));
+  if (typeof m.mode === "string") rows.push(kv(key(ctx, "commitment_mode"), word(ctx, m.mode), indent ? " sv-in" : ""));
+  for (const o of Array.isArray(m.owners) ? m.owners : []) {
+    rows.push(kv(key(ctx, "owner"), val(o), indent ? " sv-in" : ""));
+  }
+  return rows.join("");
+}
+function approvalRows(ctx, a, prefix, indent) {
+  const cls = indent ? " sv-in" : "";
+  const rows = [];
+  if (a.createdAt !== void 0) rows.push(kv(key(ctx, `${prefix}createdAt`), ts(a.createdAt), cls));
+  if (a.decidedAt !== void 0) rows.push(kv(key(ctx, `${prefix}decidedAt`), ts(a.decidedAt), cls));
+  if (typeof a.whoLabel === "string") rows.push(kv(key(ctx, `${prefix}committedBy`), val(a.whoLabel), cls));
+  return rows.join("");
+}
+function group(ctx, name, rows) {
+  if (!rows) return "";
+  return `<div class="sv-group"><div class="sv-group-label">${key(ctx, name)}</div>${rows}</div>`;
+}
+function renderTicket(ctx, el) {
+  if (el.status === "unverifiable" || !el.data) return unverifiableCard(el);
+  const d = el.data;
+  const variant = (el.attrs.variant ?? "").trim().toLowerCase();
+  if (variant !== "full") {
+    return card(el, kv(key(ctx, "action"), word(ctx, d.action)) + kv(key(ctx, "timestamp"), ts(d.time)), { compact: true });
+  }
+  const body = kv(key(ctx, "action"), word(ctx, d.action)) + (d.actionType !== void 0 ? kv(key(ctx, "actionType"), word(ctx, d.actionType)) : "") + kv(key(ctx, "profileId"), word(ctx, d.profile)) + contextRows(ctx, d.executionContext ?? {}) + (d.mandate ? group(ctx, "mandate", mandateRows(ctx, d.mandate, true)) : "") + (d.approval ? group(ctx, "approval", approvalRows(ctx, d.approval, "", true)) : "") + kv(key(ctx, "timestamp"), ts(d.time)) + kv(key(ctx, "ticket"), val(d.ticketId)) + checkLink(d.checkUrl);
+  return card(el, body);
+}
+function renderApproval(ctx, el) {
+  if (el.status === "unverifiable" || !el.data) return unverifiableCard(el);
+  const d = el.data;
+  const wait = typeof d.waitSeconds === "number" ? kv(key(ctx, "wait_s"), val(rawNumber(d.waitSeconds)) + formula("decidedAt \u2212 createdAt")) : "";
+  const status = typeof d.status === "string" ? kv(key(ctx, "status"), word(ctx, d.status)) : "";
+  return card(el, approvalRows(ctx, d, "", false) + status + wait);
+}
+function renderMandate(ctx, el) {
+  if (el.status === "unverifiable" || !el.data) return unverifiableCard(el);
+  const d = el.data;
+  const body = kv(key(ctx, "profileId"), word(ctx, d.profile)) + mandateRows(ctx, d, false) + (typeof d.intent === "string" && d.intent ? kv(key(ctx, "intent"), `<span class="sv-v sv-text">${escapeHtml(d.intent)}</span>`, " sv-block") : "");
+  return card(el, body);
+}
+var RECORD_SKIP = /* @__PURE__ */ new Set(["kind", "folder", "causingReceiptId", "body", "lines", "cc_json"]);
+var RECORD_WORD_FIELDS = /* @__PURE__ */ new Set(["status", "tool", "currency"]);
+function renderRecord(ctx, el) {
+  if (el.status === "unverifiable" || !el.data) return unverifiableCard(el);
+  const d = el.data;
+  const rows = Object.entries(d).filter(([k]) => !RECORD_SKIP.has(k)).map(([k, v]) => {
+    const s = scalar(v);
+    if (s === void 0) return "";
+    if (TIME_KEY_RE.test(k)) return kv(key(ctx, k), ts(v));
+    if (RECORD_WORD_FIELDS.has(k)) return kv(key(ctx, k), word(ctx, s));
+    return kv(key(ctx, k), val(s));
+  }).join("");
+  return card(el, rows);
+}
+function step(tag, rows, cls = "") {
+  return `<div class="sv-step${cls}"><span class="sv-step-tag">${escapeHtml(tag)}</span>${rows}</div>`;
+}
+function stepKv(k, v) {
+  return `<div class="sv-kv sv-kv-col">${k}${v}</div>`;
+}
+function renderCase(ctx, el) {
+  if (el.status === "unverifiable" || !el.data) return unverifiableCard(el);
+  const d = el.data;
+  const steps = Array.isArray(d.steps) ? d.steps : [];
+  const goal = d.goal;
+  const approvalsByTicket = /* @__PURE__ */ new Map();
+  for (const a of Array.isArray(d.approvals) ? d.approvals : []) approvalsByTicket.set(a.ticketId, a);
+  const start = d.start;
+  const items = [];
+  if (start) {
+    const rows = stepKv(key(ctx, "received_at"), ts(start.receivedAt ?? start.emailTime)) + (start.subject !== void 0 ? stepKv(key(ctx, "subject"), val(start.subject)) : "") + (start.sender !== void 0 ? stepKv(key(ctx, "from_email"), val(start.sender)) : "") + (start.basis === "loaded" && start.loadedAt !== void 0 ? stepKv(key(ctx, "simulation_load.loaded_at"), ts(start.loadedAt)) : "");
+    items.push({ time: start.time, html: step("database", rows) });
+  }
+  const ticketNodes = [
+    ...steps.map((s) => ({ node: s, isGoal: false })),
+    ...goal ? [{ node: goal, isGoal: true }] : []
+  ];
+  for (const { node, isGoal } of ticketNodes) {
+    const approval = approvalsByTicket.get(node.ticketId);
+    if (approval) {
+      const t = Math.min(approval.decidedAt ?? approval.createdAt ?? node.time, node.time);
+      const rows2 = (approval.createdAt !== void 0 ? stepKv(key(ctx, "approval.createdAt"), ts(approval.createdAt)) : "") + (approval.decidedAt !== void 0 ? stepKv(key(ctx, "approval.decidedAt"), ts(approval.decidedAt)) : "") + (approval.whoLabel !== void 0 ? stepKv(key(ctx, "approval.committedBy"), val(approval.whoLabel)) : "");
+      items.push({ time: t, html: step("archive", rows2) });
+    }
+    const rows = stepKv(key(ctx, "action"), word(ctx, node.action)) + stepKv(key(ctx, "timestamp"), ts(node.time));
+    items.push({ time: node.time, html: step(isGoal ? "signed \xB7 goal" : "signed", rows, isGoal ? " sv-step-goal" : "") });
+  }
+  items.sort((a, b) => a.time - b.time);
+  const duration = typeof d.totalDurationSeconds === "number" ? kv(key(ctx, "duration_s"), val(rawNumber(d.totalDurationSeconds)) + formula("goal.timestamp \u2212 max(start.received_at, simulation_load.loaded_at)")) : `<div class="sv-note">${escapeHtml(String(d.timeUnverifiableReason ?? "duration_s not verifiable"))}</div>`;
+  const head = kv(key(ctx, "case_id"), val(d.caseId));
+  return card(el, duration + `<div class="sv-tl">${items.map((i) => i.html).join("")}</div>`, { head });
+}
+var METRIC_FIELDS = {
+  completed: { name: "cases_completed", formula: "count(case.goal verified)" },
+  "median-time": { name: "median_duration_s", formula: "median(case.duration_s)" },
+  "average-time": { name: "average_duration_s", formula: "mean(case.duration_s)" },
+  "without-approval": { name: "without_approval_ratio", formula: "count(case.approvals = 0) / count(case)" },
+  approvals: { name: "approvals", formula: "count(case.approval)" },
+  "median-approval-wait": { name: "median_approval_wait_s", formula: "median(approval.decidedAt \u2212 approval.createdAt)" },
+  tickets: { name: "tickets", formula: "count(distinct case.goal, case.steps)" },
+  refusals: { name: "refusals", formula: "count(refusal.at in [case.start, case.goal])" }
+};
+function renderMetric(ctx, el) {
+  if (el.status === "unverifiable" || !el.data) return unverifiableCard(el);
+  const d = el.data;
+  const kind = String(d.kind ?? "");
+  const f = METRIC_FIELDS[kind] ?? { name: kind, formula: "" };
+  const caseIds = Array.isArray(d.caseIds) ? d.caseIds.map(String) : [];
+  const body = `<div class="sv-kv sv-metric">${key(ctx, f.name)}${val(rawNumber(d.value))}${f.formula ? formula(f.formula) : ""}</div>` + (caseIds.length > 0 ? kv(key(ctx, "cases"), val(caseIds.join(" "))) : "");
+  return card(el, body);
+}
+function renderElement(ctx, el) {
+  switch (el.kind) {
+    case "sv-ticket":
+      return renderTicket(ctx, el);
+    case "sv-approval":
+      return renderApproval(ctx, el);
+    case "sv-mandate":
+      return renderMandate(ctx, el);
+    case "sv-record":
+      return renderRecord(ctx, el);
+    case "sv-case":
+      return renderCase(ctx, el);
+    case "sv-metric":
+      return renderMetric(ctx, el);
+    default:
+      return unverifiableCard(el);
+  }
+}
+function pick(d, keys) {
+  const out = {};
+  if (!d) return out;
+  for (const k of keys) if (d[k] !== void 0) out[k] = d[k];
+  return out;
+}
+function drawnElement(el) {
+  const base = {
+    id: el.id,
+    kind: el.kind,
+    attrs: el.attrs,
+    status: el.status,
+    ...el.reason !== void 0 ? { reason: el.reason } : {}
+  };
+  if (el.status === "unverifiable" || !el.data) return base;
+  const d = el.data;
+  let data;
+  switch (el.kind) {
+    case "sv-ticket": {
+      const full = (el.attrs.variant ?? "").trim().toLowerCase() === "full";
+      if (!full) {
+        data = pick(d, ["action", "time"]);
+        break;
+      }
+      data = pick(d, ["ticketId", "action", "actionType", "profile", "executionContext", "time", "checkUrl"]);
+      if (d.mandate) data.mandate = pick(d.mandate, ["rawLimits", "mode", "owners"]);
+      if (d.approval) data.approval = pick(d.approval, ["createdAt", "decidedAt", "whoLabel"]);
+      break;
+    }
+    case "sv-approval":
+      data = pick(d, ["createdAt", "decidedAt", "whoLabel", "status", "waitSeconds"]);
+      break;
+    case "sv-mandate":
+      data = pick(d, ["profile", "rawLimits", "mode", "owners", "intent"]);
+      break;
+    case "sv-record":
+      data = pick(d, Object.keys(d).filter((k) => !RECORD_SKIP.has(k)));
+      break;
+    case "sv-case": {
+      data = pick(d, ["caseId", "totalDurationSeconds", "timeUnverifiableReason"]);
+      if (d.start) data.start = pick(d.start, ["time", "emailTime", "basis", "subject", "sender", "receivedAt", "loadedAt"]);
+      if (d.goal) data.goal = pick(d.goal, ["ticketId", "time", "action"]);
+      data.steps = (Array.isArray(d.steps) ? d.steps : []).map((x) => pick(x, ["ticketId", "time", "action"]));
+      data.approvals = (Array.isArray(d.approvals) ? d.approvals : []).map((x) => pick(x, ["ticketId", "whoLabel", "createdAt", "decidedAt"]));
+      break;
+    }
+    case "sv-metric":
+      data = pick(d, ["kind", "value", "caseIds"]);
+      break;
+    default:
+      return base;
+  }
+  return { ...base, data };
+}
+function line(key2, value) {
+  return { key: key2, value };
+}
+function ticketFields(d) {
+  const out = [line("action", String(d.action ?? ""))];
+  if (d.actionType !== void 0) out.push(line("actionType", String(d.actionType)));
+  if (d.profile !== void 0) out.push(line("profileId", String(d.profile)));
+  for (const [k, v] of Object.entries(d.executionContext ?? {})) {
+    const sv = scalar(v);
+    if (sv !== void 0) out.push(line(k, sv));
+  }
+  out.push(line("timestamp", formatTimestamp(d.time)));
+  return out;
+}
+function approvalFields(d) {
+  const out = [];
+  if (d.createdAt !== void 0) out.push(line("createdAt", formatTimestamp(d.createdAt)));
+  if (d.decidedAt !== void 0) out.push(line("decidedAt", formatTimestamp(d.decidedAt)));
+  if (typeof d.whoLabel === "string") out.push(line("committedBy", d.whoLabel));
+  if (typeof d.status === "string") out.push(line("status", d.status));
+  if (typeof d.waitSeconds === "number") out.push(line("wait_s", `${rawNumber(d.waitSeconds)} = decidedAt \u2212 createdAt`));
+  return out;
+}
+function mandateFields(d) {
+  const out = [];
+  if (d.profile !== void 0) out.push(line("profileId", String(d.profile)));
+  for (const [k, v] of Object.entries(d.rawLimits ?? {})) {
+    const sv = scalar(v);
+    if (sv !== void 0) out.push(line(k, sv));
+  }
+  if (typeof d.mode === "string") out.push(line("commitment_mode", d.mode));
+  for (const o of Array.isArray(d.owners) ? d.owners : []) out.push(line("owner", String(o)));
+  if (typeof d.intent === "string" && d.intent) out.push(line("intent", d.intent));
+  return out;
+}
+var fmt = (lines) => lines.map((l) => `${l.key} ${l.value}`).join(" \xB7 ");
+function checkedValueLine(el) {
+  const d = el.data ?? {};
+  switch (el.kind) {
+    case "sv-ticket":
+      return fmt([line("action", String(d.action ?? "")), line("timestamp", formatTimestamp(d.time))]);
+    case "sv-approval": {
+      const a = approvalFields(d);
+      const pick2 = a.filter((l) => l.key === "wait_s" || l.key === "committedBy");
+      return fmt(pick2.length > 0 ? pick2 : a);
+    }
+    case "sv-mandate":
+      return fmt(mandateFields(d).filter((l) => l.key === "profileId" || l.key === "commitment_mode"));
+    case "sv-record": {
+      const k = ["number", "id", "subject"].find((x) => scalar(d[x]) !== void 0);
+      return k ? fmt([line(k, String(scalar(d[k])))]) : el.id;
+    }
+    case "sv-case": {
+      const out = [line("case_id", String(d.caseId ?? ""))];
+      if (typeof d.totalDurationSeconds === "number") out.push(line("duration_s", rawNumber(d.totalDurationSeconds)));
+      return fmt(out);
+    }
+    case "sv-metric": {
+      const kind = String(d.kind ?? "");
+      return fmt([line(METRIC_FIELDS[kind]?.name ?? kind, rawNumber(d.value))]);
+    }
+    default:
+      return el.id;
+  }
+}
+var AI_ANALYSIS_LABEL = "AI analysis \u2014 not verified";
+var VERIFIED_LEGEND_TEXT = "Green = verified by the gateway \u2014 raw signed fields only";
+var AI_LEGEND_TEXT = "Grey dashed = the AI's own analysis, not verified";
+var GLOSS_LEGEND_TEXT = "= translation by the AI, not verified";
+var MONO = "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace";
+var DRAWN_ELEMENT_STYLES = `
+.sv-report { font:14px/1.55 system-ui, -apple-system, "Segoe UI", sans-serif; color:#111; max-width:900px; }
+.sv-legend { display:flex; flex-wrap:wrap; gap:6px 14px; align-items:center; font-size:12px; color:#555; border-bottom:1px solid #e5e5e5; padding:0 0 8px; margin:0 0 10px; }
+.sv-legend-chip { display:inline-flex; align-items:center; gap:6px; }
+.sv-sw { width:11px; height:11px; border-radius:3px; display:inline-block; flex:none; }
+.sv-sw-v { background:#ecfdf3; border:2px solid #15803d; }
+.sv-sw-a { border:2px dashed #9a9a9a; }
+.sv-gloss-swatch { font-style:italic; color:#666; border-bottom:1px dotted #666; }
+.sv-el { border:2px solid #15803d; border-radius:10px; background:#fff; padding:12px 14px; margin:12px 0; min-width:0; }
+.sv-el.sv-compact { padding:8px 12px; }
+.sv-el-warning { border-color:#b45309; }
+.sv-el-unverifiable { border:2px solid #b91c1c; background:#fff; }
+.sv-vhead { display:flex; justify-content:space-between; align-items:center; gap:10px; flex-wrap:wrap; margin-bottom:4px; }
+.sv-vline { display:flex; justify-content:space-between; align-items:center; gap:10px; flex-wrap:wrap; }
+.sv-kv-row { display:flex; gap:4px 16px; flex-wrap:wrap; }
+.sv-kv { font-family:${MONO}; font-size:12.5px; display:flex; gap:7px; flex-wrap:wrap; align-items:flex-end; margin:3px 0; line-height:1.5; min-width:0; }
+.sv-kv.sv-in { padding-left:14px; }
+.sv-kv.sv-block { flex-direction:column; align-items:flex-start; gap:0; }
+.sv-k { color:#666; }
+.sv-v { color:#111; font-weight:600; word-break:break-word; overflow-wrap:anywhere; }
+.sv-text { font-weight:400; white-space:pre-wrap; }
+.sv-f { color:#444; font-weight:400; }
+.sv-metric { font-size:13px; }
+.sv-group { margin:6px 0 2px; }
+.sv-group-label { font-family:${MONO}; font-size:11px; color:#666; }
+.sv-badge { display:inline-flex; align-items:center; gap:4px; white-space:nowrap; font:600 10.5px/1.6 system-ui, sans-serif; border-radius:999px; padding:1px 8px; }
+.sv-badge-ok { color:#15803d; background:#ecfdf3; }
+.sv-badge-warn { color:#b45309; background:#fff7e6; }
+.sv-badge-bad { color:#b91c1c; background:#fdecea; }
+.sv-note, .sv-reason { color:#b45309; font-size:12px; margin:2px 0 4px; }
+.sv-reason { color:#b91c1c; }
+.sv-link { margin-top:4px; }
+.sv-link a { color:#1d4ed8; text-decoration:none; font-size:12px; }
+.sv-row { display:grid; grid-template-columns:repeat(auto-fit, minmax(190px, 1fr)); gap:10px; margin:12px 0; }
+.sv-row > .sv-el { margin:0; }
+.sv-tl { display:flex; gap:16px; overflow-x:auto; padding:10px 2px 4px; margin-top:6px; }
+.sv-step { width:180px; min-width:180px; flex:none; border:1px solid #e5e5e5; border-radius:8px; padding:9px 9px 7px; position:relative; background:#fafafa; }
+.sv-step-goal { border-color:#15803d; }
+.sv-step .sv-kv-col { flex-direction:column; gap:0; align-items:flex-start; margin:1px 0; font-size:11px; }
+.sv-step .sv-kv-col .sv-k { font-size:9.5px; }
+.sv-step:not(:last-child)::after { content:"\\2192"; position:absolute; right:-14px; top:38%; color:#888; font-size:12px; }
+.sv-step-tag { position:absolute; top:-8px; right:8px; background:#fff; border:1px solid #e5e5e5; color:#666; font:9px/1.5 system-ui, sans-serif; padding:0 6px; border-radius:999px; }
+.sv-ai-wrap { margin:14px 0 12px; }
+.sv-ai-label { display:inline-flex; align-items:center; background:#eee; color:#555; font:600 10.5px/1.6 system-ui, sans-serif; padding:1px 8px; border-radius:999px; margin:0 0 6px 10px; }
+.sv-ai-block { position:relative; isolation:isolate; contain:paint; overflow:hidden; border:2px dashed #9a9a9a; border-radius:10px; background:#fafafa; padding:14px; }
+.sv-ai-content { font-size:13.5px; overflow-wrap:anywhere; }
+.sv-ai-content img, .sv-ai-content svg { max-width:100%; height:auto; }
+ruby.sv-gloss { ruby-position:over; }
+ruby.sv-gloss rt { font:italic 400 14.5px/1.4 system-ui, sans-serif; color:#666; border-bottom:1px dotted #666; }
+.sv-gloss-toggle-mode ruby.sv-gloss rt { display:none; }
+@media (max-width: 480px) {
+  .sv-tl { flex-direction:column; overflow:visible; }
+  .sv-step { width:auto; min-width:0; margin-bottom:6px; }
+  .sv-step:not(:last-child)::after { content:"\\2193"; right:auto; left:10px; top:auto; bottom:-17px; }
+}
+`;
+var GLOSS_ON_STYLES = `
+ruby.sv-gloss { font-size:11.5px; }
+`;
+function reportLegend(showGloss) {
+  return `<div class="sv-legend" role="note"><span class="sv-legend-chip"><span class="sv-sw sv-sw-v"></span>${escapeHtml(VERIFIED_LEGEND_TEXT)}</span><span class="sv-legend-chip"><span class="sv-sw sv-sw-a"></span>${escapeHtml(AI_LEGEND_TEXT)}</span>` + (showGloss ? `<span class="sv-legend-chip"><span class="sv-gloss-swatch">Abc</span>&nbsp;${escapeHtml(GLOSS_LEGEND_TEXT)}</span>` : "") + `</div>`;
+}
+function walkTopLevel(sanitized) {
+  const doc = parseDocument2(sanitized, {
+    withStartIndices: true,
+    withEndIndices: true,
+    recognizeSelfClosing: true,
+    decodeEntities: true
+  });
+  return { html: sanitized, nodes: (doc.children ?? []).filter((n) => n.type === "tag") };
+}
+function readGlossary(walk) {
+  const g = walk.nodes.find((n) => n.name === "sv-glossary");
+  if (!g) return void 0;
+  const terms = /* @__PURE__ */ new Map();
+  for (const t of g.children ?? []) {
+    if (t.type !== "tag" || t.name !== "sv-term") continue;
+    const k = t.attribs?.key ?? "";
+    const text = (t.children ?? []).map((c) => c.data ?? "").join("");
+    if (k && !terms.has(k)) terms.set(k, text);
+  }
+  return { lang: g.attribs?.lang ?? "", terms };
+}
+function innerOf(walk, node) {
+  const children = node.children ?? [];
+  if (children.length === 0) return "";
+  const start = children[0].startIndex;
+  const end = children[children.length - 1].endIndex;
+  return start !== null && end !== null ? walk.html.slice(start, end + 1) : "";
+}
+function drawBody(walk, elements, ctx) {
+  const byId = new Map(elements.map((e) => [e.id, e]));
+  const seen = /* @__PURE__ */ new Map();
+  const nextEl = (node) => {
+    const kind = node.name ?? "";
+    const n = seen.get(kind) ?? 0;
+    seen.set(kind, n + 1);
+    const id = `${kind}-${n}`;
+    const el = byId.get(id) ?? { id, kind, attrs: node.attribs ?? {}, status: "unverifiable", reason: "No verification result for this element." };
+    return renderElement(ctx, el);
+  };
+  const parts = [];
+  for (const node of walk.nodes) {
+    const name = node.name ?? "";
+    if (name === "sv-ai") {
+      parts.push(
+        `<div class="sv-ai-wrap"><span class="sv-ai-label">${escapeHtml(AI_ANALYSIS_LABEL)}</span><div class="sv-ai-block"><div class="sv-ai-content">${innerOf(walk, node)}</div></div></div>`
+      );
+    } else if (name === "sv-row") {
+      const cells = (node.children ?? []).filter((c) => c.type === "tag" && (c.name ?? "").startsWith("sv-") && !STRUCTURE_TAGS.has(c.name ?? ""));
+      parts.push(`<div class="sv-row">${cells.map(nextEl).join("")}</div>`);
+    } else if (name === "sv-glossary") {
+      continue;
+    } else if (name.startsWith("sv-")) {
+      parts.push(nextEl(node));
+    }
+  }
+  return parts.join("\n");
+}
+var NOT_IN_BOXES = "not a field name or fixed word in your verified boxes (numbers, timestamps and ids are never translated)";
+function glossaryUsage(rawHtml, elements) {
+  const sanitized = sanitizeReport(rawHtml);
+  const walk = walkTopLevel(sanitized.html);
+  const g = readGlossary(walk);
+  if (!g && sanitized.notes.rejectedTerms.length === 0) return void 0;
+  const ctx = { mode: "on", terms: g?.terms ?? /* @__PURE__ */ new Map(), used: /* @__PURE__ */ new Set() };
+  drawBody(walk, elements, ctx);
+  const rejected = [...sanitized.notes.rejectedTerms];
+  for (const k of ctx.terms.keys()) if (!ctx.used.has(k)) rejected.push({ key: k, reason: NOT_IN_BOXES });
+  return { lang: g?.lang ?? "", applied: [...ctx.used], rejected };
+}
+function renderReportHtml(rawHtml, elements, opts = {}) {
+  const mode = opts.gloss ?? "off";
+  const walk = walkTopLevel(sanitizeReport(rawHtml).html);
+  const g = readGlossary(walk);
+  const ctx = { mode, terms: g?.terms ?? /* @__PURE__ */ new Map(), used: /* @__PURE__ */ new Set() };
+  const body = drawBody(walk, elements, ctx);
+  const showGloss = mode !== "off" && ctx.used.size > 0;
+  void showGloss;
+  const styles = `<style data-sv-drawn-styles="1">${DRAWN_ELEMENT_STYLES}${mode === "on" ? GLOSS_ON_STYLES : ""}</style>`;
+  const langAttr = showGloss && g?.lang ? ` data-sv-gloss-lang="${escapeHtml(g.lang)}"` : "";
+  const cls = mode === "toggle" ? "sv-report sv-gloss-toggle-mode" : "sv-report";
+  return `${styles}<div class="${cls}"${langAttr}>${body}</div>`;
+}
+
+// src/lib/report/export-report.ts
+import { decodeAttestationBlob, getProfile as getProfile2 } from "@hap/core";
+function processTimeZone() {
+  try {
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (tz) return tz;
+  } catch {
+  }
+  return "UTC";
+}
+function canonicalOrder(profileId, bounds) {
+  const keyOrder = getProfile2(profileId)?.boundsSchema?.keyOrder;
+  if (!Array.isArray(keyOrder)) return bounds;
+  const out = {};
+  for (const k of keyOrder) if (bounds[k] !== void 0) out[k] = bounds[k];
+  for (const [k, v] of Object.entries(bounds)) if (!(k in out)) out[k] = v;
+  return out;
+}
+function disclosedNames(blobs) {
+  const names = /* @__PURE__ */ new Map();
+  for (const blob of blobs) {
+    try {
+      for (const sub of decodeAttestationBlob(blob).payload.subjects ?? []) {
+        if (sub.assurance === "high" && sub.disclose?.name) {
+          if (!names.has(sub.did)) names.set(sub.did, /* @__PURE__ */ new Set());
+          names.get(sub.did).add(sub.disclose.name);
+        }
+      }
+    } catch {
+    }
+  }
+  return names;
+}
+function firstOwnerDids(auth) {
+  const blob = auth?.attestations[0]?.blob;
+  if (!blob) return [];
+  try {
+    return decodeAttestationBlob(blob).payload.resolved_owners ?? [];
+  } catch {
+    return [];
+  }
+}
+function receiptId(receipt) {
+  return typeof receipt.id === "string" ? receipt.id : "";
+}
+function buildExportBundle(params) {
+  const { stored, archive, authorityServer, gatewayVersion, now = Math.floor(Date.now() / 1e3) } = params;
+  const timeZone = params.timeZone ?? processTimeZone();
+  const elements = stored.result.elements.map(drawnElement);
+  const proof = {
+    ...stored.result.proof,
+    verifiedValues: withDrawingZone(timeZone, () => elements.filter((e) => e.status !== "unverifiable").map((e) => ({ elementId: e.id, kind: e.kind, summary: checkedValueLine(e) })))
+  };
+  const coverage = stored.result.coverage;
+  const ticketIdSet = /* @__PURE__ */ new Set([...proof.ticketsReferenced, ...coverage.ticketsInPeriod]);
+  const entries = archive.getReceipts().filter((r) => ticketIdSet.has(receiptId(r.receipt)));
+  const tickets = entries.map((r) => r.receipt);
+  const placed = stored.result.elements.filter((e) => e.status !== "unverifiable");
+  const mandateCardTickets = new Set(
+    placed.filter((e) => e.kind === "sv-mandate" && e.attrs.ticket).map((e) => e.attrs.ticket)
+  );
+  const fullTicketTickets = new Set(
+    placed.filter((e) => e.kind === "sv-ticket" && e.attrs.ref && e.data?.mandate).map((e) => e.attrs.ref)
+  );
+  const authOf = (set) => new Set(entries.filter((r) => set.has(receiptId(r.receipt))).map((r) => r.authorizationId));
+  const withIntent = authOf(mandateCardTickets);
+  const withoutIntent = authOf(fullTicketTickets);
+  const authorizations = {};
+  for (const a of archive.getAuthorizations()) {
+    if (!withIntent.has(a.authorizationId) && !withoutIntent.has(a.authorizationId)) continue;
+    const out = {
+      authorizationId: a.authorizationId,
+      profileId: a.profileId,
+      ...a.boundsHash !== void 0 ? { boundsHash: a.boundsHash } : {},
+      ...a.contextHash !== void 0 ? { contextHash: a.contextHash } : {},
+      ...a.bounds !== void 0 ? { bounds: canonicalOrder(a.profileId, a.bounds) } : {},
+      ...withIntent.has(a.authorizationId) && a.intent !== void 0 ? { intent: a.intent } : {},
+      attestations: a.attestations,
+      archivedAt: a.archivedAt
+    };
+    authorizations[a.authorizationId] = out;
+  }
+  const bundledBlobs = Object.values(authorizations).flatMap((a) => a.attestations.map((x) => x.blob));
+  const known = disclosedNames(bundledBlobs);
+  const identityAttestations = [];
+  const archiveBlobs = archive.getAuthorizations().flatMap((a) => a.attestations.map((x) => x.blob));
+  const ticketAuth = new Map(entries.map((r) => [receiptId(r.receipt), r.authorizationId]));
+  for (const el of elements) {
+    const owners = el.kind === "sv-mandate" ? el.data?.owners : el.kind === "sv-ticket" ? el.data?.mandate?.owners : void 0;
+    if (!Array.isArray(owners)) continue;
+    const ref = el.kind === "sv-mandate" ? el.attrs.ticket : el.attrs.ref;
+    const dids = firstOwnerDids(authorizations[ticketAuth.get(ref ?? "") ?? ""]);
+    owners.forEach((label, i) => {
+      const did = dids[i];
+      if (!did || typeof label !== "string" || label === UNDISCLOSED_OWNER_LABEL) return;
+      if (known.get(did)?.has(label)) return;
+      const blob = archiveBlobs.find((b) => disclosedNames([b]).get(did)?.has(label));
+      if (!blob) return;
+      identityAttestations.push(blob);
+      for (const [d, set] of disclosedNames([blob])) {
+        if (!known.has(d)) known.set(d, /* @__PURE__ */ new Set());
+        for (const n of set) known.get(d).add(n);
+      }
+    });
+  }
+  return {
+    format: "suveren-report-export",
+    version: 2,
+    exportedAt: now,
+    gatewayVersion,
+    report: { html: stored.html, savedAt: stored.savedAt, checkedAt: stored.checkedAt },
+    proof,
+    coverage,
+    authorityServer,
+    tickets,
+    authorizations,
+    elements,
+    timeZone,
+    identityAttestations
+  };
+}
+function countLine(count, noneText = "none in this report") {
+  return count > 0 ? `${count} \u2713` : noneText;
+}
+function renderProofCoveragePanels(proof, coverage) {
+  const casesLine = coverage.emailExportError ? "unknown \u2014 the email simulator could not be read" : `${coverage.coveredCases.length} of ${coverage.loadedCases.length}`;
+  const periodNote = coverage.periodStart === null ? `<p class="sv-export-note">${coverage.emailExportError ? "Test period start unknown \u2014 the email simulator could not be read. All saved tickets were counted." : "Test period start unknown \u2014 all saved tickets were counted."}</p>` : "";
+  const missingParts = [];
+  if (coverage.missingCases.length > 0) missingParts.push(`cases ${coverage.missingCases.map(escapeHtml).join(", ")}`);
+  if (coverage.ticketsNotReferenced.length > 0) missingParts.push(`${coverage.ticketsNotReferenced.length} ticket${coverage.ticketsNotReferenced.length === 1 ? "" : "s"}`);
+  const missingLine = missingParts.length > 0 ? `<p class="sv-export-missing">Not in the report: ${missingParts.join(" \xB7 ")}</p>` : "";
+  const checkedValues = proof.verifiedValues.length > 0 ? `<div class="sv-export-card"><div class="sv-export-card-title">Checked values</div>${proof.verifiedValues.map((v) => `<div class="sv-export-row"><span>${escapeHtml(v.summary)}</span></div>`).join("")}</div>` : "";
+  return `<aside class="sv-export-side"><div class="sv-export-card"><div class="sv-export-card-title">Proof</div><div class="sv-export-row"><span>Tickets referenced</span><b>${proof.ticketsReferenced.length}</b></div><div class="sv-export-row"><span>Signatures valid</span><b>${escapeHtml(countLine(proof.signaturesValid))}</b></div><div class="sv-export-row"><span>Records checked</span><b>${escapeHtml(countLine(proof.recordsChecked))}</b></div><div class="sv-export-row"><span>Not verifiable</span><b>${proof.unverifiableCount}</b></div></div><div class="sv-export-card"><div class="sv-export-card-title">Coverage</div><div class="sv-export-row"><span>Cases</span><b>${casesLine}</b></div><div class="sv-export-row"><span>Tickets in test period</span><b>${coverage.ticketsReferenced.length} of ${coverage.ticketsInPeriod.length}</b></div>` + periodNote + missingLine + `</div>` + checkedValues + `</aside>`;
+}
+var GLOSS_ON_TOGGLED = GLOSS_ON_STYLES.trim().split("\n").filter(Boolean).map((rule) => `#sv-gloss-toggle:checked ~ .sv-export-layout ${rule}`).join("\n");
+var EXPORT_PAGE_STYLES = `
+.sv-export-header { font:13px/1.5 system-ui, sans-serif; background:#f6f6f4; border-bottom:1px solid #e5e5e5; padding:14px 20px; }
+.sv-export-meta { margin:0 0 6px 0; font-weight:600; }
+.sv-export-howto { margin:0; color:#444; }
+.sv-export-howto code { background:#eee; border-radius:4px; padding:1px 5px; font-size:12px; }
+.sv-export-layout { display:flex; gap:20px; align-items:flex-start; padding:20px; font:13px/1.5 system-ui, sans-serif; }
+.sv-export-main { flex:1 1 auto; min-width:0; }
+.sv-export-side { flex:0 0 260px; }
+.sv-export-card { border:1px solid #e5e5e5; border-radius:10px; padding:10px 12px; margin-bottom:12px; background:#fff; }
+.sv-export-card-title { font-weight:700; margin-bottom:6px; }
+.sv-export-row { display:flex; justify-content:space-between; gap:10px; margin:2px 0; }
+.sv-export-note, .sv-export-missing { color:#b45309; font-size:12px; margin:4px 0 0 0; }
+.sv-export-legend { margin:8px 0 0 0; }
+.sv-export-legend .sv-legend { border-bottom:0; padding:0; margin:0; }
+.sv-toggle-input { position:absolute; opacity:0; width:1px; height:1px; }
+.sv-translate { display:flex; align-items:center; gap:10px; flex-wrap:wrap; margin:8px 0 0 0; }
+.sv-toggle-switch { display:inline-flex; cursor:pointer; }
+.sv-toggle-track { width:34px; height:18px; border-radius:999px; background:#d4d4d4; position:relative; flex:none; transition:background .15s ease; }
+.sv-toggle-thumb { position:absolute; top:2px; left:2px; width:14px; height:14px; border-radius:50%; background:#fff; box-shadow:0 1px 2px rgba(0,0,0,.25); transition:transform .15s ease; }
+.sv-toggle-text { font-size:13px; font-weight:600; cursor:pointer; }
+#sv-gloss-toggle:checked ~ .sv-export-header .sv-toggle-track { background:#111; }
+#sv-gloss-toggle:checked ~ .sv-export-header .sv-toggle-thumb { transform:translateX(16px); }
+#sv-gloss-toggle:focus-visible ~ .sv-export-header .sv-toggle-track { outline:2px solid #1d4ed8; outline-offset:2px; }
+#sv-gloss-toggle:checked ~ .sv-export-layout .sv-gloss-toggle-mode ruby.sv-gloss rt { display:ruby-text; }
+${GLOSS_ON_TOGGLED}
+@media (max-width: 720px) {
+  .sv-export-layout { flex-direction:column; }
+  .sv-export-side { flex:1 1 auto; width:100%; }
+}
+`;
+function formatDateTimeWithYear(value) {
+  const base = formatDateTime(value);
+  const year = zonedParts(value).year;
+  return base.replace(",", ` ${year},`);
+}
+function utcOffsetLabel(value) {
+  return offsetLabel(zonedParts(value).offsetMin);
+}
+function renderExportBody(bundle) {
+  return renderReportHtml(bundle.report.html, bundle.elements, { gloss: "toggle" });
+}
+function buildExportDocument(params) {
+  return withDrawingZone(params.bundle.timeZone, () => drawExportDocument(params.bundle));
+}
+function drawExportDocument(bundle) {
+  const renderedHtml = renderExportBody(bundle);
+  const exportedDate = new Date(bundle.exportedAt * 1e3).toISOString().slice(0, 10);
+  const hasGloss = /<ruby class="sv-gloss">/.test(renderedHtml);
+  const exportedLabel = formatDateTimeWithYear(bundle.exportedAt);
+  const checkedLabel = formatDateTime(bundle.report.checkedAt);
+  const tzLabel = utcOffsetLabel(bundle.exportedAt);
+  const headerHtml = `<div class="sv-export-header"><p class="sv-export-meta">Suveren Gateway ${escapeHtml(bundle.gatewayVersion)} \u2014 exported ${escapeHtml(exportedLabel)} &middot; checked ${escapeHtml(checkedLabel)} (times in ${escapeHtml(tzLabel)})</p><p class="sv-export-howto">How to check this report: each ticket below links to its public record on suveren.ai ("Check on suveren.ai \u2197"). To verify this entire file offline (every signature, and every value the boxes show), run <code>suveren-gateway verify-report ${escapeHtml(suggestedFilename(bundle))}</code> from a terminal with the Suveren gateway CLI installed.</p><div class="sv-export-legend">${reportLegend(hasGloss)}</div>` + (hasGloss ? `<div class="sv-translate"><label for="sv-gloss-toggle" class="sv-toggle-switch" aria-hidden="true"><span class="sv-toggle-track"><span class="sv-toggle-thumb"></span></span></label><label for="sv-gloss-toggle" class="sv-toggle-text">\xDCbersetzung anzeigen / show translation</label></div>` : "") + `</div>`;
+  const proofScriptJson = JSON.stringify(bundle).replace(/<\//g, "<\\/");
+  const proofScript = `<script type="application/json" id="suveren-proof">${proofScriptJson}</script>`;
+  const csp = `<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'; img-src data:">`;
+  const head = `<meta charset="utf-8">${csp}<title>Suveren report export \u2014 ${escapeHtml(exportedDate)}</title><style>${DRAWN_ELEMENT_STYLES}${EXPORT_PAGE_STYLES}</style>`;
+  const toggleInput = hasGloss ? `<input type="checkbox" id="sv-gloss-toggle" class="sv-toggle-input">` : "";
+  return `<!doctype html><html lang="en"><head>${head}</head><body>` + toggleInput + headerHtml + `<div class="sv-export-layout"><div class="sv-export-main">${renderedHtml}</div>${renderProofCoveragePanels(bundle.proof, bundle.coverage)}</div>${proofScript}</body></html>`;
+}
+function suggestedFilename(bundle) {
+  const date = new Date(bundle.exportedAt * 1e3).toISOString().slice(0, 10);
+  return `suveren-report-${date}.html`;
+}
+
+// src/lib/report/export-types.ts
+function isExportBundle(v) {
+  if (!v || typeof v !== "object") return false;
+  const o = v;
+  if (o.format !== "suveren-report-export" || o.version !== 2) return false;
+  if (!Array.isArray(o.elements) || typeof o.timeZone !== "string" || !Array.isArray(o.identityAttestations)) return false;
+  if (!o.report || typeof o.report !== "object") return false;
+  if (!Array.isArray(o.tickets)) return false;
+  if (!o.authorizations || typeof o.authorizations !== "object") return false;
+  if (!o.authorityServer || typeof o.authorityServer !== "object") return false;
+  const as = o.authorityServer;
+  return typeof as.url === "string" && typeof as.publicKeyHex === "string";
+}
+
+// src/lib/report/verify-export.ts
+import { Parser as Parser2 } from "htmlparser2";
+import { verifyReceiptSignature as verifyReceiptSignature2, verifyAttestationSignature as verifyAttestationSignature4, decodeAttestationBlob as decodeAttestationBlob5, computeBoundsHash } from "@hap/core";
+
+// src/lib/report/verify-drawn.ts
+import { computeIntentHash, decodeAttestationBlob as decodeAttestationBlob4, verifyAttestationSignature as verifyAttestationSignature3 } from "@hap/core";
+
+// src/lib/report/metric-resolvers.ts
+var METRIC_KINDS = [
+  "completed",
+  "median-time",
+  "average-time",
+  "without-approval",
+  "approvals",
+  "median-approval-wait",
+  "tickets",
+  "refusals"
+];
+var UnknownMetricKindError = class extends Error {
+  constructor(kind) {
+    super(`Unknown sv-metric kind "${kind}" \u2014 expected one of: ${METRIC_KINDS.join(", ")}.`);
+    this.name = "UnknownMetricKindError";
+  }
+};
+var START_TIME_METRICS = /* @__PURE__ */ new Set(["median-time", "average-time", "refusals"]);
+function median(values) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+function average(values) {
+  if (values.length === 0) return 0;
+  return values.reduce((a, b) => a + b, 0) / values.length;
+}
+function computeMetric(kind, cases, refusalTimes = []) {
+  if (START_TIME_METRICS.has(kind) && cases.some((c) => c.totalDurationSeconds === null)) {
+    throw new Error("Case start times are not verifiable.");
+  }
+  switch (kind) {
+    case "completed":
+      return cases.length;
+    case "median-time":
+      return median(cases.map((c) => c.totalDurationSeconds));
+    case "average-time":
+      return average(cases.map((c) => c.totalDurationSeconds));
+    case "without-approval": {
+      if (cases.length === 0) return 0;
+      const withoutApproval = cases.filter((c) => c.approvals.length === 0).length;
+      return withoutApproval / cases.length;
+    }
+    case "approvals":
+      return cases.reduce((sum, c) => sum + c.approvals.length, 0);
+    case "median-approval-wait":
+      return median(cases.flatMap((c) => c.approvals.map((a) => a.waitSeconds).filter((w) => typeof w === "number")));
+    case "tickets": {
+      const ids = new Set(cases.flatMap((c) => c.ticketIds));
+      return ids.size;
+    }
+    case "refusals":
+      return cases.reduce(
+        (sum, c) => sum + refusalTimes.filter((t) => t >= c.startTime && t <= c.goalTime).length,
+        0
+      );
+    default:
+      throw new UnknownMetricKindError(kind);
+  }
+}
+
+// src/lib/report/ticket-resolvers.ts
+import { verifyReceiptSignature, verifyAttestationSignature as verifyAttestationSignature2, decodeAttestationBlob as decodeAttestationBlob3 } from "@hap/core";
+
+// src/lib/report/identity.ts
+import { decodeAttestationBlob as decodeAttestationBlob2, verifyAttestationSignature } from "@hap/core";
+var cache = /* @__PURE__ */ new WeakMap();
+function cacheKey(archive) {
+  const auths = archive.getAuthorizations();
+  return `${auths.length}:${auths.map((a) => `${a.authorizationId}/${a.attestations.length}`).join(",")}:${archive.getReceipts().length}`;
+}
+async function build(archive) {
+  const names = /* @__PURE__ */ new Map();
+  const domainDids = /* @__PURE__ */ new Map();
+  const receipts = archive.getReceipts();
+  for (const auth of archive.getAuthorizations()) {
+    const key2 = receipts.find((r) => r.authorizationId === auth.authorizationId && r.asPublicKey)?.asPublicKey;
+    if (!key2) continue;
+    for (const att of auth.attestations) {
+      try {
+        const attestation = decodeAttestationBlob2(att.blob);
+        await verifyAttestationSignature(attestation, key2);
+        for (const s of attestation.payload.subjects ?? []) {
+          if (s.assurance === "high" && s.disclose?.name && !names.has(s.did)) names.set(s.did, s.disclose.name);
+        }
+        for (const rd of attestation.payload.resolved_domains ?? []) {
+          if (rd?.domain && rd?.did && !domainDids.has(rd.domain)) domainDids.set(rd.domain, rd.did);
+        }
+      } catch {
+      }
+    }
+  }
+  return { names, domainDids };
+}
+function getIdentityDirectory(archive) {
+  const key2 = cacheKey(archive);
+  const hit = cache.get(archive);
+  if (hit && hit.key === key2) return hit.dir;
+  const dir = build(archive);
+  cache.set(archive, { key: key2, dir });
+  return dir;
+}
+function ownerLabel(dir, did) {
+  return dir.names.get(did) ?? formatOwnerLabel(did);
+}
+var UNDISCLOSED_APPROVER_LABEL = "a person (name not disclosed)";
+function approverLabel(dir, domainKey, userId) {
+  const did = dir.domainDids.get(domainKey) ?? dir.domainDids.get(userId);
+  const name = did ? dir.names.get(did) : void 0;
+  if (name) return name;
+  return UNDISCLOSED_APPROVER_LABEL;
+}
+
+// src/lib/report/agent-view.ts
+var FORBIDDEN_AGENT_KEYS = [
+  "userId",
+  "groupId",
+  "authorizationId",
+  "signature",
+  "approvalSignature",
+  "blob",
+  "attestations",
+  "ownersRaw",
+  "who",
+  "subjects",
+  "asPublicKey",
+  "credentials",
+  "proposalId",
+  "boundsHash",
+  "contextHash"
+];
+var FORBIDDEN = new Set(FORBIDDEN_AGENT_KEYS);
+function scrubForbidden(value) {
+  if (Array.isArray(value)) return value.map(scrubForbidden);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (FORBIDDEN.has(k)) continue;
+      out[k] = scrubForbidden(v);
+    }
+    return out;
+  }
+  return value;
+}
+function agentTicketRow(receipt, hasApproval, profileLabel) {
+  return {
+    id: typeof receipt.id === "string" ? receipt.id : String(receipt.id ?? ""),
+    time: typeof receipt.timestamp === "number" ? receipt.timestamp : void 0,
+    action: receipt.action,
+    actionType: receipt.actionType ?? null,
+    profile: receipt.profileId,
+    profileLabel,
+    limitsUsed: scrubForbidden(receipt.limits ?? receipt.executionContext ?? {}),
+    hasApproval
+  };
+}
+function agentTicket(d) {
+  return {
+    ticketId: d.ticketId,
+    action: d.action,
+    actionLabel: d.actionLabel,
+    time: d.time,
+    timeLabel: d.timeLabel,
+    profile: d.profile,
+    profileLabel: d.profileLabel,
+    limitsUsed: scrubForbidden(d.limitsUsed ?? {}),
+    checkUrl: d.checkUrl
+  };
+}
+var APPROVED_STATUSES = /* @__PURE__ */ new Set(["committed", "executed"]);
+function agentApproval(d) {
+  const status = typeof d.status === "string" ? d.status : void 0;
+  return {
+    approved: status !== void 0 ? APPROVED_STATUSES.has(status) : d.decidedAt !== void 0,
+    approvedBy: d.whoLabel,
+    askedAt: d.createdAt,
+    askedAtLabel: d.createdAtLabel,
+    decidedAt: d.decidedAt,
+    decidedAtLabel: d.decidedAtLabel,
+    waitSeconds: d.waitSeconds,
+    waitLabel: d.waitLabel
+  };
+}
+function agentMandate(d) {
+  return {
+    profile: d.profile,
+    profileLabel: d.profileLabel,
+    limits: d.limits,
+    rawLimits: scrubForbidden(d.rawLimits ?? {}),
+    mode: d.mode,
+    intent: d.intent,
+    owners: d.owners
+  };
+}
+
+// src/lib/report/ticket-resolvers.ts
+function findReceiptEntry(archive, ticketId2) {
+  return archive.getReceipts().find((r) => r.receipt.id === ticketId2);
+}
+function findAuthorization(archive, authorizationId) {
+  return archive.getAuthorizations().find((a) => a.authorizationId === authorizationId);
+}
+async function checkTicket(archive, ticketId2) {
+  const entry = findReceiptEntry(archive, ticketId2);
+  if (!entry) {
+    const outside = archive.outsideWindowReason?.(ticketId2);
+    if (outside) return { ok: false, reason: `Ticket "${ticketId2}": ${outside}` };
+    return { ok: false, reason: `No ticket "${ticketId2}" in the local archive.` };
+  }
+  if (!entry.asPublicKey) {
+    return { ok: false, reason: `Ticket "${ticketId2}" has no archived Authority Server key to verify it against.`, entry };
+  }
+  try {
+    await verifyReceiptSignature(entry.receipt, entry.asPublicKey);
+  } catch (err) {
+    return {
+      ok: false,
+      reason: `Ticket "${ticketId2}" signature does not verify: ${err instanceof Error ? err.message : String(err)}`,
+      entry
+    };
+  }
+  return { ok: true, entry };
+}
+function checkUrlFor(entry) {
+  const id = String(entry.receipt.id ?? "");
+  return `${entry.asUrl.replace(/\/+$/, "")}/r/${id}`;
+}
+async function resolveTicketElement(archive, ref) {
+  const check = await checkTicket(archive, ref);
+  if (!check.ok) return { status: "unverifiable", reason: check.reason };
+  const r = check.entry.receipt;
+  return {
+    status: "verified",
+    data: {
+      ticketId: ref,
+      action: r.action,
+      actionLabel: formatActionLabel(r.action),
+      actionType: r.actionType,
+      // The signed execution context, minus internal ids (agent-view.ts) —
+      // drawn verbatim by the full ticket variant (two-tag rule, RR6).
+      executionContext: scrubForbidden(r.executionContext ?? {}),
+      time: r.timestamp,
+      timeLabel: formatDateTime(r.timestamp),
+      profile: r.profileId,
+      profileLabel: profileShortLabel(typeof r.profileId === "string" ? r.profileId : void 0),
+      authorizationId: r.authorizationId,
+      limitsUsed: r.limits ?? r.executionContext ?? {},
+      checkUrl: checkUrlFor(check.entry)
+    }
+  };
+}
+async function resolveApprovalElement(archive, ticketRef) {
+  const check = await checkTicket(archive, ticketRef);
+  if (!check.ok) return { status: "unverifiable", reason: check.reason };
+  const proposal = check.entry.proposal;
+  if (!proposal) {
+    return {
+      status: "unverifiable",
+      reason: `Ticket "${ticketRef}" has no archived approval (it ran without review).`
+    };
+  }
+  const committedBy = proposal.committedBy ?? {};
+  const approverEntries = Object.entries(committedBy);
+  const approvers = approverEntries.map(([, a]) => a);
+  const createdAt = typeof proposal.createdAt === "number" ? proposal.createdAt : void 0;
+  const decidedAt = approvers.length > 0 ? Math.max(...approvers.map((a) => a.at)) : void 0;
+  const waitSeconds = createdAt !== void 0 && decidedAt !== void 0 ? decidedAt - createdAt : void 0;
+  const who = approvers.map((a) => a.userId);
+  const dir = await getIdentityDirectory(archive);
+  const whoLabels = approverEntries.map(([domain, a]) => approverLabel(dir, domain, String(a.userId ?? "")));
+  return {
+    status: "verified",
+    data: {
+      ticketId: ticketRef,
+      who,
+      whoLabel: whoLabels.length > 0 ? whoLabels.join(", ") : "unknown",
+      createdAt,
+      createdAtLabel: createdAt !== void 0 ? formatDateTime(createdAt) : "unknown",
+      decidedAt,
+      decidedAtLabel: decidedAt !== void 0 ? formatDateTime(decidedAt) : "unknown",
+      waitSeconds,
+      waitLabel: waitSeconds !== void 0 ? formatDuration(waitSeconds) : "unknown",
+      status: proposal.status
+    }
+  };
+}
+async function resolveMandateElement(archive, ticketRef) {
+  const check = await checkTicket(archive, ticketRef);
+  if (!check.ok) return { status: "unverifiable", reason: check.reason };
+  const r = check.entry.receipt;
+  const authorizationId = typeof r.authorizationId === "string" ? r.authorizationId : void 0;
+  if (!authorizationId) {
+    return { status: "unverifiable", reason: `Ticket "${ticketRef}" carries no authorizationId.` };
+  }
+  const auth = findAuthorization(archive, authorizationId);
+  if (!auth) {
+    return { status: "unverifiable", reason: `No archived mandate "${authorizationId}" for ticket "${ticketRef}".` };
+  }
+  if (auth.boundsHash && typeof r.boundsHash === "string" && auth.boundsHash !== r.boundsHash) {
+    return {
+      status: "unverifiable",
+      reason: `Mandate "${authorizationId}" boundsHash does not match ticket "${ticketRef}".`
+    };
+  }
+  let mode;
+  let owners = [];
+  let ownersRaw = [];
+  const firstBlob = auth.attestations[0]?.blob;
+  if (firstBlob && check.entry.asPublicKey) {
+    try {
+      const attestation = decodeAttestationBlob3(firstBlob);
+      await verifyAttestationSignature2(attestation, check.entry.asPublicKey);
+      mode = attestation.payload.commitment_mode;
+      const dids = attestation.payload.resolved_owners ?? [];
+      const subjects = attestation.payload.subjects ?? [];
+      ownersRaw = dids;
+      const dir = await getIdentityDirectory(archive);
+      owners = dids.map((did) => {
+        const subject = subjects.find((s) => s.did === did);
+        return subject?.assurance === "high" && subject.disclose?.name ? subject.disclose.name : ownerLabel(dir, did);
+      });
+    } catch {
+    }
+  }
+  const fallbackCurrency = typeof auth.context?.currency === "string" ? auth.context.currency : void 0;
+  const rawLimits = auth.bounds ?? {};
+  const limits = Object.entries(rawLimits).map(([key2, value]) => formatBoundLabel(auth.profileId, key2, value, fallbackCurrency));
+  return {
+    status: "verified",
+    data: {
+      authorizationId,
+      profile: auth.profileId,
+      profileLabel: profileShortLabel(auth.profileId),
+      limits,
+      rawLimits,
+      intent: auth.intent,
+      mode,
+      owners,
+      ownersRaw
+    }
+  };
+}
+
+// src/lib/report/time.ts
+function parseTimestampSeconds(value) {
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  const iso = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}/.test(value) && !/[zZ]|[+-]\d{2}:?\d{2}$/.test(value) ? `${value.replace(" ", "T")}Z` : value;
+  const ms = Date.parse(iso);
+  return Number.isFinite(ms) ? Math.floor(ms / 1e3) : void 0;
+}
+
+// src/lib/report/case-resolvers.ts
+function parseRef(value) {
+  if (!value) return { id: "" };
+  const i = value.indexOf(":");
+  if (i === -1) return { id: value.trim() };
+  return { type: value.slice(0, i).trim(), id: value.slice(i + 1).trim() };
+}
+function parseStepRefs(value) {
+  if (!value) return [];
+  return value.split(/\s+/).filter(Boolean).map((s) => parseRef(s).id || s);
+}
+function parseRecipients(toJson, ccJson) {
+  const out = [];
+  for (const raw of [toJson, ccJson]) {
+    if (!raw) continue;
+    try {
+      const arr = JSON.parse(raw);
+      if (Array.isArray(arr)) out.push(...arr.filter((x) => typeof x === "string"));
+    } catch {
+    }
+  }
+  return out.map((s) => s.toLowerCase());
+}
+function parseCaseAttrs(attrs) {
+  return {
+    startId: parseRef(attrs.start).id,
+    goalId: parseRef(attrs.goal).id,
+    stepIds: parseStepRefs(attrs.steps)
+  };
+}
+var CASE_TIME_UNKNOWN_REASON = "Not verifiable: the time the test data was loaded is unknown, and the email's own date may be set by the test package.";
+async function resolveCaseElement(archive, emailExport, attrs) {
+  const start = parseRef(attrs.start);
+  const startMessage = emailExport.inbox.find((m) => m.id === start.id);
+  if (!startMessage || !startMessage.case_id) {
+    return { status: "unverifiable", reason: `start "${attrs.start ?? ""}" is not a loaded case email with a case_id.` };
+  }
+  const startCaseId = startMessage.case_id;
+  const emailTime = parseTimestampSeconds(startMessage.received_at);
+  if (emailTime === void 0) {
+    return { status: "unverifiable", reason: `start message "${start.id}" has an unparseable received_at.`, startCaseId };
+  }
+  const loadedAt = parseTimestampSeconds(emailExport.simulation_load?.loaded_at);
+  const startTime = loadedAt !== void 0 ? Math.max(emailTime, loadedAt) : emailTime;
+  const basis = loadedAt === void 0 ? "load-unknown" : emailTime >= loadedAt ? "email" : "loaded";
+  const goal = parseRef(attrs.goal);
+  const goalCheck = await checkTicket(archive, goal.id);
+  if (!goalCheck.ok) {
+    return { status: "unverifiable", reason: `goal: ${goalCheck.reason}`, startCaseId };
+  }
+  const goalReceipt = goalCheck.entry.receipt;
+  const goalTime = typeof goalReceipt.timestamp === "number" ? goalReceipt.timestamp : void 0;
+  if (goalTime === void 0) {
+    return { status: "unverifiable", reason: `goal ticket "${goal.id}" has no numeric timestamp.`, startCaseId };
+  }
+  if (goalTime < startTime) {
+    return { status: "unverifiable", reason: `goal ticket "${goal.id}" is timestamped before start "${start.id}".`, startCaseId };
+  }
+  const stepIds = parseStepRefs(attrs.steps);
+  const steps = [];
+  for (const stepId of stepIds) {
+    const stepCheck = await checkTicket(archive, stepId);
+    if (!stepCheck.ok) {
+      return { status: "unverifiable", reason: `step: ${stepCheck.reason}`, startCaseId };
+    }
+    const stepReceipt = stepCheck.entry.receipt;
+    const stepTime = typeof stepReceipt.timestamp === "number" ? stepReceipt.timestamp : void 0;
+    if (stepTime === void 0 || stepTime < startTime || stepTime > goalTime) {
+      return { status: "unverifiable", reason: `step ticket "${stepId}" is outside the case window [${startTime}, ${goalTime}].`, startCaseId };
+    }
+    steps.push({ ticketId: stepId, time: stepTime, action: stepReceipt.action, actionLabel: formatActionLabel(stepReceipt.action) });
+  }
+  let warningReason;
+  const sentForGoal = emailExport.sent.find((m) => m.receipt_id === goal.id);
+  if (sentForGoal) {
+    const isReply = sentForGoal.in_reply_to === start.id;
+    const recipients = parseRecipients(sentForGoal.to_json, sentForGoal.cc_json);
+    const addressedToSender = recipients.includes(startMessage.from_email.toLowerCase());
+    if (!isReply && !addressedToSender) {
+      warningReason = "goal link not confirmed";
+    }
+  }
+  const approvals = [];
+  for (const ticketId2 of [goal.id, ...stepIds]) {
+    const approval = await resolveApprovalElement(archive, ticketId2);
+    if (approval.status === "verified") {
+      approvals.push({ ticketId: ticketId2, ...approval.data });
+    }
+  }
+  const timeline = [
+    { type: "start", time: startTime, label: start.id },
+    ...steps.map((s) => ({ type: "step", time: s.time, label: s.ticketId })),
+    ...approvals.map((a) => ({ type: "approval", time: a.decidedAt ?? a.createdAt ?? 0, label: a.ticketId })),
+    { type: "goal", time: goalTime, label: goal.id }
+  ].sort((a, b) => a.time - b.time);
+  return {
+    status: warningReason ? "warning" : "verified",
+    reason: warningReason,
+    startCaseId,
+    data: {
+      caseId: startCaseId,
+      start: {
+        id: start.id,
+        time: startTime,
+        sender: startMessage.from_email,
+        emailTime,
+        basis,
+        subject: startMessage.subject,
+        receivedAt: startMessage.received_at,
+        ...emailExport.simulation_load?.loaded_at ? { loadedAt: emailExport.simulation_load.loaded_at } : {}
+      },
+      goal: { ticketId: goal.id, time: goalTime, action: goalReceipt.action, actionLabel: formatActionLabel(goalReceipt.action) },
+      steps,
+      approvals,
+      timeline,
+      totalDurationSeconds: basis === "load-unknown" ? null : goalTime - startTime,
+      ...basis === "load-unknown" ? { timeUnverifiableReason: CASE_TIME_UNKNOWN_REASON } : {}
+    }
+  };
+}
+
+// src/lib/report/verify-drawn.ts
+function validTimeZone(tz) {
+  try {
+    new Intl.DateTimeFormat("en-GB", { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function visibleText(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+}
+function normalizeNewlines(html) {
+  return html.replace(/\r\n?/g, "\n");
+}
+function checkDocumentReproduces(bundle, documentHtml) {
+  if (documentHtml === void 0) return { state: "not-given" };
+  if (!validTimeZone(bundle.timeZone)) {
+    return { state: "mismatch", error: `The file names an unknown drawing time zone "${bundle.timeZone}".` };
+  }
+  let expected;
+  try {
+    expected = normalizeNewlines(buildExportDocument({ bundle }));
+  } catch (err) {
+    return { state: "mismatch", error: `The page could not be re-drawn from the bundle: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const actual = normalizeNewlines(documentHtml);
+  if (actual === expected) return { state: "match" };
+  let i = 0;
+  while (i < actual.length && i < expected.length && actual[i] === expected[i]) i++;
+  const around = (s) => {
+    const from = Math.max(0, s.lastIndexOf("<div", i));
+    const close = s.indexOf("</div>", i);
+    return visibleText(s.slice(from, close === -1 ? i + 200 : close + 6)).slice(0, 160);
+  };
+  return {
+    state: "mismatch",
+    error: `The visible page differs from what the signed bundle draws (first difference at byte ${i}). File shows: "${around(actual)}" \u2014 the bundle draws: "${around(expected)}". Either the page was edited, or it was drawn by a different gateway version than this checker (the file says ${bundle.gatewayVersion}).`
+  };
+}
+async function verifiedPayload(blob, publicKeyHex) {
+  try {
+    const att = decodeAttestationBlob4(blob);
+    await verifyAttestationSignature3(att, publicKeyHex);
+    return att.payload;
+  } catch {
+    return null;
+  }
+}
+async function collectAttestations(bundle) {
+  const key2 = bundle.authorityServer.publicKeyHex;
+  const first = /* @__PURE__ */ new Map();
+  const names = /* @__PURE__ */ new Map();
+  const addNames = (p) => {
+    for (const s of p?.subjects ?? []) {
+      if (s.assurance === "high" && s.disclose?.name) {
+        if (!names.has(s.did)) names.set(s.did, /* @__PURE__ */ new Set());
+        names.get(s.did).add(s.disclose.name);
+      }
+    }
+  };
+  for (const [id, auth] of Object.entries(bundle.authorizations)) {
+    let i = 0;
+    for (const att of auth.attestations) {
+      const p = await verifiedPayload(att.blob, key2);
+      if (i++ === 0) first.set(id, p);
+      addNames(p);
+    }
+    if (auth.attestations.length === 0) first.set(id, null);
+  }
+  for (const blob of bundle.identityAttestations ?? []) addNames(await verifiedPayload(blob, key2));
+  return { first, names };
+}
+function same(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function sameMap(a, b) {
+  const ka = Object.keys(a ?? {}).sort();
+  const kb = Object.keys(b ?? {}).sort();
+  return same(ka, kb) && ka.every((k) => same((a ?? {})[k], (b ?? {})[k]));
+}
+async function checkDrawnElements(ctx, reportElements2) {
+  const { bundle } = ctx;
+  const errors = [];
+  const att = await collectAttestations(bundle);
+  const parsedById = new Map(reportElements2.map((e) => [e.id, e]));
+  const seen = /* @__PURE__ */ new Set();
+  for (const el of bundle.elements) {
+    if (seen.has(el.id)) errors.push(`Element ${el.id} appears twice in the bundle.`);
+    seen.add(el.id);
+    const p = parsedById.get(el.id);
+    if (!p || p.kind !== el.kind || !sameMap(p.attrs, el.attrs)) {
+      errors.push(`Element ${el.id} in the bundle is not the report's own element (id, kind or attributes differ).`);
+    }
+  }
+  errors.push(...checkProofSummary(bundle));
+  const boxes = [];
+  for (const el of bundle.elements) {
+    if (el.status === "unverifiable" || !el.data) continue;
+    const box = { elementId: el.id, kind: el.kind, signed: [], recomputed: [], notCheckable: [], mismatches: [] };
+    try {
+      switch (el.kind) {
+        case "sv-ticket":
+          checkTicketBox(ctx, att, el, box);
+          break;
+        case "sv-mandate":
+          checkMandateBox(ctx, att, el, box);
+          break;
+        case "sv-approval":
+          checkApprovalBox(el, box);
+          break;
+        case "sv-record":
+          for (const k of Object.keys(el.data)) box.notCheckable.push({ field: k, source: "database" });
+          break;
+        case "sv-case":
+          checkCaseBox(ctx, el, box);
+          break;
+        case "sv-metric":
+          checkMetricBox(bundle, el, box);
+          break;
+        default:
+          box.mismatches.push(`Unknown element kind "${el.kind}" drawn as verified.`);
+      }
+    } catch (err) {
+      box.mismatches.push(`Could not check: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    boxes.push(box);
+  }
+  return { boxes, errors };
+}
+function proofOf(elements) {
+  const ticketsReferenced = /* @__PURE__ */ new Set();
+  const signaturesValid = /* @__PURE__ */ new Set();
+  let recordsChecked = 0;
+  let unverifiableCount = 0;
+  const verifiedValues = [];
+  for (const el of elements) {
+    if (el.status === "unverifiable") unverifiableCount++;
+    else verifiedValues.push({ elementId: el.id, kind: el.kind, summary: checkedValueLine(el) });
+    const ids = [];
+    if (el.kind === "sv-ticket" && el.attrs.ref) ids.push(el.attrs.ref);
+    if ((el.kind === "sv-approval" || el.kind === "sv-mandate") && el.attrs.ticket) ids.push(el.attrs.ticket);
+    if (el.kind === "sv-case") {
+      const { goalId, stepIds } = parseCaseAttrs(el.attrs);
+      ids.push(...[goalId, ...stepIds].filter(Boolean));
+    }
+    for (const id of ids) {
+      ticketsReferenced.add(id);
+      if (el.status !== "unverifiable") signaturesValid.add(id);
+    }
+    if (el.kind === "sv-record" && el.status === "verified") recordsChecked++;
+  }
+  return { ticketsReferenced, signaturesValid: signaturesValid.size, recordsChecked, unverifiableCount, verifiedValues };
+}
+function checkProofSummary(bundle) {
+  const p = validTimeZone(bundle.timeZone) ? withDrawingZone(bundle.timeZone, () => proofOf(bundle.elements)) : proofOf(bundle.elements);
+  const errors = [];
+  const b = bundle.proof;
+  if (!same(b.verifiedValues, p.verifiedValues)) errors.push('The "Checked values" panel does not match the boxes.');
+  if (!same([...new Set(b.ticketsReferenced)].sort(), [...p.ticketsReferenced].sort())) errors.push(`The Proof panel's "Tickets referenced" does not match the report.`);
+  if (b.signaturesValid !== p.signaturesValid) errors.push(`The Proof panel's "Signatures valid" does not match the boxes.`);
+  if (b.recordsChecked !== p.recordsChecked) errors.push(`The Proof panel's "Records checked" does not match the boxes.`);
+  if (b.unverifiableCount !== p.unverifiableCount) errors.push(`The Proof panel's "Not verifiable" count does not match the boxes.`);
+  return errors;
+}
+function receiptFor(ctx, id, box) {
+  const r = id ? ctx.validTickets.get(id) : void 0;
+  if (!r) box.mismatches.push(`Ticket ${id ?? "(none)"} is not in the file with a valid signature.`);
+  return r;
+}
+function signedField(box, field, drawn, signed) {
+  if (same(drawn, signed)) box.signed.push(field);
+  else box.mismatches.push(`${field}: the box shows ${JSON.stringify(drawn)}, the signed source says ${JSON.stringify(signed)}.`);
+}
+function checkTicketBox(ctx, att, el, box) {
+  const d = el.data;
+  const r = receiptFor(ctx, el.attrs.ref, box);
+  if (!r) return;
+  signedField(box, "action", d.action, r.action);
+  signedField(box, "timestamp", d.time, r.timestamp);
+  const full = (el.attrs.variant ?? "").trim().toLowerCase() === "full";
+  if (!full) return;
+  if (d.actionType !== void 0 || r.actionType !== void 0) signedField(box, "actionType", d.actionType, r.actionType);
+  signedField(box, "profileId", d.profile, r.profileId);
+  signedField(box, "ticket", d.ticketId, r.id);
+  if (sameMap(d.executionContext, scrubForbidden(r.executionContext ?? {}))) {
+    for (const k of Object.keys(d.executionContext ?? {})) box.signed.push(k);
+  } else {
+    box.mismatches.push("The execution context the box shows differs from the signed ticket.");
+  }
+  const expectedUrl = `${ctx.bundle.authorityServer.url.replace(/\/+$/, "")}/r/${String(r.id ?? "")}`;
+  if (d.checkUrl !== void 0 && d.checkUrl !== expectedUrl) {
+    box.mismatches.push(`The "Check on suveren.ai" link points to ${JSON.stringify(d.checkUrl)}, not ${expectedUrl}.`);
+  }
+  if (d.mandate) checkMandateFields(ctx, att, d.mandate, r, box, "mandate.");
+  if (d.approval) {
+    const a = d.approval;
+    for (const [k, f] of [["createdAt", "approval.createdAt"], ["decidedAt", "approval.decidedAt"], ["whoLabel", "approval.committedBy"]]) {
+      if (a[k] !== void 0) box.notCheckable.push({ field: f, source: "archive" });
+    }
+  }
+}
+function checkMandateBox(ctx, att, el, box) {
+  const r = receiptFor(ctx, el.attrs.ticket, box);
+  if (!r) return;
+  checkMandateFields(ctx, att, el.data, r, box, "");
+}
+function checkMandateFields(ctx, att, m, r, box, prefix) {
+  const authorizationId = typeof r.authorizationId === "string" ? r.authorizationId : "";
+  const auth = ctx.bundle.authorizations[authorizationId];
+  if (!auth) {
+    box.mismatches.push(`${prefix || "mandate "}drawn, but the mandate ${authorizationId || "(none)"} is not in the file.`);
+    return;
+  }
+  const payload = att.first.get(authorizationId) ?? null;
+  const rawLimits = m.rawLimits ?? {};
+  if (Object.keys(rawLimits).length > 0) {
+    if (!sameMap(rawLimits, auth.bounds)) {
+      box.mismatches.push(`${prefix}limits: the box shows ${JSON.stringify(rawLimits)}, the mandate in the file says ${JSON.stringify(auth.bounds ?? {})}.`);
+    } else if (!ctx.boundsProven.has(authorizationId)) {
+      box.mismatches.push(`${prefix}limits: the bounds values are not proven by a signed bounds_hash.`);
+    } else {
+      for (const k of Object.keys(rawLimits)) box.signed.push(prefix + k);
+    }
+  }
+  if (m.profile !== void 0) {
+    if (!payload) box.mismatches.push("profileId: no verified mandate attestation in the file backs it.");
+    else signedField(box, "profileId", m.profile, payload.profile_id);
+  }
+  if (m.mode !== void 0 || Array.isArray(m.owners) && m.owners.length > 0) {
+    if (!payload) {
+      box.mismatches.push(`${prefix}commitment_mode/owner: no verified mandate attestation in the file backs them.`);
+    } else {
+      if (m.mode !== void 0) signedField(box, `${prefix}commitment_mode`, m.mode, payload.commitment_mode);
+      checkOwners(att, payload, Array.isArray(m.owners) ? m.owners : [], box, prefix);
+    }
+  }
+  if (typeof m.intent === "string" && m.intent) {
+    if (auth.intent !== void 0 && auth.intent !== m.intent) {
+      box.mismatches.push("intent: the box shows a different text than the mandate in the file.");
+    }
+    const committed = payload?.gate_content_hashes?.intent;
+    if (committed) {
+      if (computeIntentHash(m.intent) === committed) box.signed.push("intent");
+      else box.mismatches.push("intent: the text does not match the signed intent hash.");
+    } else {
+      box.notCheckable.push({ field: "intent", source: "archive" });
+    }
+  }
+}
+function checkOwners(att, payload, labels, box, prefix) {
+  const dids = payload.resolved_owners ?? [];
+  if (labels.length !== dids.length) {
+    box.mismatches.push(`${prefix}owner: the box shows ${labels.length} owner(s), the signed mandate names ${dids.length}.`);
+    return;
+  }
+  dids.forEach((did, i) => {
+    const label = labels[i];
+    const own = (payload.subjects ?? []).find((s) => s.did === did);
+    const ownName = own?.assurance === "high" && own.disclose?.name ? own.disclose.name : void 0;
+    const ok = ownName !== void 0 ? label === ownName : label === formatOwnerLabel(did) || label === UNDISCLOSED_OWNER_LABEL || typeof label === "string" && !!att.names.get(did)?.has(label);
+    if (ok) box.signed.push(`${prefix}owner`);
+    else box.mismatches.push(`${prefix}owner: "${String(label)}" is not a name this owner disclosed in a signed attestation in the file.`);
+  });
+}
+function checkApprovalBox(el, box) {
+  const d = el.data;
+  for (const [k, f] of [["createdAt", "createdAt"], ["decidedAt", "decidedAt"], ["whoLabel", "committedBy"], ["status", "status"]]) {
+    if (d[k] !== void 0) box.notCheckable.push({ field: f, source: "archive" });
+  }
+  if (typeof d.waitSeconds === "number") {
+    if (typeof d.createdAt === "number" && typeof d.decidedAt === "number" && d.decidedAt - d.createdAt === d.waitSeconds) {
+      box.recomputed.push({ field: "wait_s", inputs: ["archive"] });
+    } else {
+      box.mismatches.push(`wait_s: ${d.waitSeconds} is not decidedAt \u2212 createdAt.`);
+    }
+  }
+}
+function checkCaseBox(ctx, el, box) {
+  const d = el.data;
+  const { goalId, stepIds } = parseCaseAttrs(el.attrs);
+  const goal = d.goal ?? {};
+  const steps = Array.isArray(d.steps) ? d.steps : [];
+  const start = d.start ?? {};
+  if (goal.ticketId !== goalId) box.mismatches.push(`goal: the box shows ticket ${String(goal.ticketId)}, the report names ${goalId}.`);
+  const gr = receiptFor(ctx, goalId, box);
+  if (gr) {
+    signedField(box, "goal.action", goal.action, gr.action);
+    signedField(box, "goal.timestamp", goal.time, gr.timestamp);
+  }
+  if (!same(steps.map((s) => s.ticketId), stepIds)) box.mismatches.push("steps: the box does not show exactly the step tickets the report names.");
+  steps.forEach((s, i) => {
+    const sr = receiptFor(ctx, String(s.ticketId ?? ""), box);
+    if (!sr) return;
+    signedField(box, `step[${i}].action`, s.action, sr.action);
+    signedField(box, `step[${i}].timestamp`, s.time, sr.timestamp);
+  });
+  box.notCheckable.push({ field: "case_id", source: "database" });
+  if (start.receivedAt !== void 0 || start.emailTime !== void 0) box.notCheckable.push({ field: "received_at", source: "database" });
+  if (start.subject !== void 0) box.notCheckable.push({ field: "subject", source: "database" });
+  if (start.sender !== void 0) box.notCheckable.push({ field: "from_email", source: "database" });
+  if (start.loadedAt !== void 0) box.notCheckable.push({ field: "simulation_load.loaded_at", source: "database" });
+  for (const a of Array.isArray(d.approvals) ? d.approvals : []) {
+    if (a.ticketId !== goalId && !stepIds.includes(String(a.ticketId))) box.mismatches.push(`An approval step names ticket ${String(a.ticketId)}, which is not in this case.`);
+    box.notCheckable.push({ field: `approval(${String(a.ticketId)})`, source: "archive" });
+  }
+  const emailTime = start.receivedAt !== void 0 ? parseTimestampSeconds(start.receivedAt) : start.emailTime;
+  const loadedAt = start.loadedAt !== void 0 ? parseTimestampSeconds(start.loadedAt) : void 0;
+  if (typeof emailTime !== "number" || emailTime !== start.emailTime) {
+    box.mismatches.push("received_at: the drawn date is not the start time the case uses.");
+    return;
+  }
+  const startTime = loadedAt !== void 0 ? Math.max(emailTime, loadedAt) : emailTime;
+  const basis = loadedAt === void 0 ? "load-unknown" : emailTime >= loadedAt ? "email" : "loaded";
+  if (start.time !== startTime || start.basis !== basis) box.mismatches.push("The case start is not max(received_at, simulation_load.loaded_at).");
+  const goalTime = gr?.timestamp;
+  if (typeof goalTime === "number") {
+    if (goalTime < startTime) box.mismatches.push("The goal ticket is timestamped before the case start.");
+    for (const s of steps) {
+      if (typeof s.time !== "number" || s.time < startTime || s.time > goalTime) box.mismatches.push(`Step ${String(s.ticketId)} lies outside the case window.`);
+    }
+    const expected = basis === "load-unknown" ? null : goalTime - startTime;
+    if ((d.totalDurationSeconds ?? null) !== expected) {
+      box.mismatches.push(`duration_s: the box shows ${JSON.stringify(d.totalDurationSeconds ?? null)}, recomputed ${JSON.stringify(expected)}.`);
+    } else if (expected !== null) {
+      box.recomputed.push({ field: "duration_s", inputs: ["signed", "database"] });
+    }
+  }
+}
+var METRIC_INPUTS = {
+  completed: ["signed", "database"],
+  "median-time": ["signed", "database"],
+  "average-time": ["signed", "database"],
+  "without-approval": ["archive"],
+  approvals: ["archive"],
+  "median-approval-wait": ["archive"],
+  tickets: ["signed"]
+};
+function checkMetricBox(bundle, el, box) {
+  const d = el.data;
+  const kind = el.attrs.kind ?? "";
+  if (d.kind !== kind) box.mismatches.push(`kind: the box shows ${JSON.stringify(d.kind)}, the report asks for ${JSON.stringify(kind)}.`);
+  const allCases = bundle.elements.filter((e) => e.kind === "sv-case");
+  const casesAttr = (el.attrs.cases ?? "all").trim();
+  const requested = casesAttr === "all" ? allCases.length : new Set(casesAttr.split(/\s+/).filter(Boolean)).size;
+  let selected = allCases.filter((c) => c.status !== "unverifiable" && c.data);
+  if (casesAttr !== "all") {
+    const wanted = new Set(casesAttr.split(/\s+/).filter(Boolean));
+    selected = selected.filter((c) => wanted.has(String(c.data.caseId)));
+  }
+  const caseIds = selected.map((c) => String(c.data.caseId));
+  if (!same(d.caseIds ?? [], caseIds)) box.mismatches.push("cases: the box does not list the report's own verified cases.");
+  const expectedStatus = selected.length < requested ? "warning" : "verified";
+  if (el.status !== expectedStatus) box.mismatches.push(`The box is drawn as ${el.status}, but it covers ${selected.length} of ${requested} requested cases.`);
+  if (kind === "refusals") {
+    box.notCheckable.push({ field: "refusals", source: "database" });
+    return;
+  }
+  const inputs = selected.map((c) => {
+    const cd = c.data;
+    const goal = cd.goal ?? {};
+    const start = cd.start ?? {};
+    return {
+      caseId: String(cd.caseId),
+      startTime: Number(start.time),
+      goalTime: Number(goal.time),
+      totalDurationSeconds: cd.totalDurationSeconds ?? null,
+      ticketIds: [String(goal.ticketId), ...(Array.isArray(cd.steps) ? cd.steps : []).map((s) => String(s.ticketId))],
+      approvals: (Array.isArray(cd.approvals) ? cd.approvals : []).map((a) => ({
+        waitSeconds: typeof a.createdAt === "number" && typeof a.decidedAt === "number" ? a.decidedAt - a.createdAt : void 0
+      }))
+    };
+  });
+  let value;
+  try {
+    value = computeMetric(kind, inputs);
+  } catch (err) {
+    box.mismatches.push(`The figure cannot be recomputed: ${err instanceof Error ? err.message : String(err)}`);
+    return;
+  }
+  if (value === d.value) box.recomputed.push({ field: "value", inputs: METRIC_INPUTS[kind] ?? ["signed"] });
+  else box.mismatches.push(`value: the box shows ${JSON.stringify(d.value)}, recomputed from the case boxes ${JSON.stringify(value)}.`);
+}
+
+// src/lib/report/parse-elements.ts
+import { Parser } from "htmlparser2";
+function parseElements(html) {
+  const found = [];
+  const seenCount = /* @__PURE__ */ new Map();
+  let opaqueDepth = 0;
+  const parser = new Parser(
+    {
+      onopentag(name, attribs) {
+        if (name === "sv-ai" || name === "sv-glossary") {
+          opaqueDepth++;
+          return;
+        }
+        if (opaqueDepth > 0) return;
+        if (!name.startsWith("sv-") || STRUCTURE_TAGS.has(name)) return;
+        const n = seenCount.get(name) ?? 0;
+        seenCount.set(name, n + 1);
+        found.push({ id: `${name}-${n}`, kind: name, attrs: { ...attribs } });
+      },
+      onclosetag(name) {
+        if ((name === "sv-ai" || name === "sv-glossary") && opaqueDepth > 0) opaqueDepth--;
+      }
+    },
+    { decodeEntities: true, recognizeSelfClosing: true }
+  );
+  parser.write(html);
+  parser.end();
+  return found;
+}
+
+// src/lib/report/verify-export.ts
+function collectReferencedTicketIds(html) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const el of reportElements(html)) {
+    if (el.kind === "sv-ticket" && el.attrs.ref) ids.add(el.attrs.ref);
+    if ((el.kind === "sv-approval" || el.kind === "sv-mandate") && el.attrs.ticket) ids.add(el.attrs.ticket);
+    if (el.kind === "sv-case") {
+      const { goalId, stepIds } = parseCaseAttrs(el.attrs);
+      if (goalId) ids.add(goalId);
+      for (const s of stepIds) ids.add(s);
+    }
+  }
+  return ids;
+}
+function reportElements(html) {
+  return parseElements(sanitizeReportHtml(html));
+}
+function ticketIdsOf(el) {
+  if (el.kind === "sv-ticket") return el.attrs.ref ? [el.attrs.ref] : [];
+  if (el.kind === "sv-approval" || el.kind === "sv-mandate") return el.attrs.ticket ? [el.attrs.ticket] : [];
+  if (el.kind === "sv-case") {
+    const { goalId, stepIds } = parseCaseAttrs(el.attrs);
+    return [...goalId ? [goalId] : [], ...stepIds];
+  }
+  return [];
+}
+var TICKET_BACKED_KINDS = /* @__PURE__ */ new Set(["sv-ticket", "sv-approval", "sv-mandate", "sv-case"]);
+var PROOF_SCRIPT_BLOCK_RE = /<script[^>]*id="suveren-proof"[^>]*>[\s\S]*?<\/script>/gi;
+function collectPresentedStates(documentHtml) {
+  const html = documentHtml.replace(PROOF_SCRIPT_BLOCK_RE, "");
+  const open = [];
+  const flaggedById = /* @__PURE__ */ new Map();
+  let depth = 0;
+  const classesOf = (attribs) => new Set((attribs.class ?? "").split(/\s+/).filter(Boolean));
+  const settle = (f) => {
+    const flagged = f.classes.has("sv-el-unverifiable") && !f.classes.has("sv-el-verified") && !f.classes.has("sv-el-warning") && f.badges.length > 0 && f.badges.every((b) => b.classes.has("sv-badge-bad") && !b.classes.has("sv-badge-ok") && !b.classes.has("sv-badge-warn") && !b.classes.has("sv-seal") && !b.hasSource);
+    flaggedById.set(f.id, (flaggedById.get(f.id) ?? true) && flagged);
+  };
+  const parser = new Parser2(
+    {
+      onopentag(_name, attribs) {
+        depth++;
+        const classes = classesOf(attribs);
+        const hasSource = typeof attribs["data-sv-source"] === "string";
+        if (hasSource || [...classes].some((c) => c.startsWith("sv-badge") || c === "sv-seal")) {
+          for (const f of open) f.badges.push({ classes, hasSource });
+        }
+        const id = attribs["data-sv-id"];
+        if (typeof id === "string" && id) open.push({ id, depth, classes, badges: [] });
+      },
+      onclosetag() {
+        while (open.length > 0 && open[open.length - 1].depth >= depth) settle(open.pop());
+        depth--;
+      }
+    },
+    { decodeEntities: true }
+  );
+  parser.write(html);
+  parser.end();
+  while (open.length > 0) settle(open.pop());
+  const states = /* @__PURE__ */ new Map();
+  for (const [id, flagged] of flaggedById) states.set(id, flagged ? "not-verifiable" : "verified");
+  return states;
+}
+function recomputeBoundsHash(bounds) {
+  const keyOrder = Object.keys(bounds);
+  const profile = {
+    id: "export-check",
+    boundsSchema: {
+      keyOrder,
+      fields: Object.fromEntries(keyOrder.map((k) => [k, { type: typeof bounds[k] === "number" ? "number" : "string" }]))
+    }
+  };
+  return computeBoundsHash(bounds, profile);
+}
+function ticketId(receipt) {
+  return typeof receipt.id === "string" ? receipt.id : "";
+}
+async function checkAttestations(auth, publicKeyHex) {
+  if (auth.attestations.length === 0) {
+    return { valid: false, error: "No archived mandate attestation for this authorization." };
+  }
+  for (const att of auth.attestations) {
+    try {
+      const attestation = decodeAttestationBlob5(att.blob);
+      await verifyAttestationSignature4(attestation, publicKeyHex);
+    } catch (err) {
+      return { valid: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  return { valid: true };
+}
+async function verifyExportBundle(bundle, opts = {}) {
+  const byId = new Map(bundle.tickets.map((t) => [ticketId(t), t]));
+  const referencedIds = collectReferencedTicketIds(bundle.report.html);
+  const allIds = /* @__PURE__ */ new Set([...referencedIds, ...byId.keys()]);
+  const tickets = [];
+  for (const id of allIds) {
+    const receipt = byId.get(id);
+    if (!receipt) {
+      tickets.push({ ticketId: id, referenced: referencedIds.has(id), present: false, signatureValid: false, error: "Not present in the bundle." });
+      continue;
+    }
+    try {
+      await verifyReceiptSignature2(receipt, bundle.authorityServer.publicKeyHex);
+      tickets.push({ ticketId: id, referenced: referencedIds.has(id), present: true, signatureValid: true });
+    } catch (err) {
+      tickets.push({
+        ticketId: id,
+        referenced: referencedIds.has(id),
+        present: true,
+        signatureValid: false,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const authorizations = [];
+  const boundsProven = /* @__PURE__ */ new Set();
+  for (const [authorizationId, auth] of Object.entries(bundle.authorizations)) {
+    const { valid: attestationValid, error: attestationError } = await checkAttestations(auth, bundle.authorityServer.publicKeyHex);
+    const hashes = [];
+    if (auth.boundsHash) hashes.push({ from: "the mandate record", value: auth.boundsHash, signed: false });
+    for (const att of auth.attestations) {
+      try {
+        const bh = decodeAttestationBlob5(att.blob).payload.bounds_hash;
+        if (bh) hashes.push({ from: "the signed attestation", value: bh, signed: attestationValid });
+      } catch {
+      }
+    }
+    for (const r of byId.values()) {
+      if (r.authorizationId === authorizationId && typeof r.boundsHash === "string") {
+        const t = tickets.find((x) => x.ticketId === ticketId(r));
+        hashes.push({ from: `signed ticket ${String(r.id ?? "")}`, value: r.boundsHash, signed: !!t?.signatureValid });
+      }
+    }
+    let recomputed;
+    let recomputeError;
+    if (auth.bounds && Object.keys(auth.bounds).length > 0) {
+      try {
+        recomputed = recomputeBoundsHash(auth.bounds);
+      } catch (err) {
+        recomputeError = `The bounds values cannot be hashed: ${err instanceof Error ? err.message : String(err)}`;
+      }
+    }
+    const all = [...hashes.map((h) => h.value), ...recomputed ? [recomputed] : []];
+    const boundsHashMatches = all.length < 2 ? "n/a" : all.every((v) => v === all[0]);
+    let boundsValuesProven = "n/a";
+    if (auth.bounds && Object.keys(auth.bounds).length > 0) {
+      boundsValuesProven = !!recomputed && boundsHashMatches !== false && hashes.some((h) => h.signed && h.value === recomputed);
+      if (boundsValuesProven === true) boundsProven.add(authorizationId);
+    }
+    const mismatch = hashes.find((h) => h.value !== (recomputed ?? all[0]));
+    const boundsError = recomputeError ?? (boundsHashMatches === false ? `Bounds hash mismatch: ${recomputed ? "the hash of the bounds values in the file" : "the mandate record"} does not match ${mismatch?.from ?? "another hash"}.` : boundsValuesProven === false ? "The bounds values in the file are not committed by any signed bounds_hash." : void 0);
+    authorizations.push({
+      authorizationId,
+      attestationValid,
+      boundsHashMatches,
+      boundsValuesProven,
+      ...attestationError ? { error: attestationError } : boundsError ? { error: boundsError } : {}
+    });
+  }
+  const ticketById = new Map(tickets.map((t) => [t.ticketId, t]));
+  const authById = new Map(authorizations.map((a) => [a.authorizationId, a]));
+  const presentedStates = opts.documentHtml !== void 0 ? collectPresentedStates(opts.documentHtml) : /* @__PURE__ */ new Map();
+  const elements = [];
+  for (const el of reportElements(bundle.report.html)) {
+    if (!TICKET_BACKED_KINDS.has(el.kind)) continue;
+    const ticketIds = ticketIdsOf(el);
+    const presented = presentedStates.get(el.id) ?? "verified";
+    let error;
+    if (ticketIds.length === 0) error = "Names no ticket.";
+    for (const id of ticketIds) {
+      if (error) break;
+      const t = ticketById.get(id);
+      if (!t || !t.present) error = `Ticket ${id} is not in the bundle.`;
+      else if (!t.signatureValid) error = `Ticket ${id} has an invalid signature.`;
+    }
+    if (!error && el.kind === "sv-mandate") {
+      const receipt = byId.get(ticketIds[0]);
+      const authorizationId = typeof receipt.authorizationId === "string" ? receipt.authorizationId : void 0;
+      const auth = authorizationId ? bundle.authorizations[authorizationId] : void 0;
+      const authCheck = authorizationId ? authById.get(authorizationId) : void 0;
+      if (!auth || !authCheck) error = `The mandate for ticket ${ticketIds[0]} is not in the bundle.`;
+      else if (!authCheck.attestationValid) error = `The mandate for ticket ${ticketIds[0]} has an invalid attestation.`;
+      else if (auth.boundsHash && typeof receipt.boundsHash === "string" && auth.boundsHash !== receipt.boundsHash) {
+        error = `The mandate's boundsHash does not match ticket ${ticketIds[0]}.`;
+      } else if (authCheck.boundsHashMatches === false || authCheck.boundsValuesProven === false) {
+        error = `The mandate for ticket ${ticketIds[0]}: ${authCheck.error ?? "bounds not proven"}`;
+      }
+    }
+    elements.push({ elementId: el.id, kind: el.kind, ticketIds, presented, backed: !error, ...error ? { error } : {} });
+  }
+  const keyFingerprint = fingerprintOf(bundle.authorityServer.publicKeyHex);
+  const keyConfirmation = resolveKeyConfirmation(bundle.authorityServer.publicKeyHex, opts);
+  const document = checkDocumentReproduces(bundle, opts.documentHtml);
+  const validTickets = /* @__PURE__ */ new Map();
+  for (const t of tickets) if (t.signatureValid) validTickets.set(t.ticketId, byId.get(t.ticketId));
+  const drawn = await checkDrawnElements(
+    { bundle, validTickets, boundsProven },
+    reportElements(bundle.report.html).map((e) => ({ id: e.id, kind: e.kind, attrs: e.attrs }))
+  );
+  const allValid = tickets.filter((t) => t.present).every((t) => t.signatureValid) && authorizations.every((a) => a.attestationValid && a.boundsHashMatches !== false && a.boundsValuesProven !== false) && elements.every((e) => e.presented === "not-verifiable" || e.backed) && document.state !== "mismatch" && drawn.errors.length === 0 && drawn.boxes.every((b) => b.mismatches.length === 0);
+  return { document, boxes: drawn.boxes, drawnErrors: drawn.errors, tickets, elements, authorizations, keyFingerprint, keyConfirmation, allValid };
+}
+function resolveKeyConfirmation(actualKeyHex, opts) {
+  const normalize = (h) => h.trim().toLowerCase();
+  if (opts.expectedKeyHex !== void 0) {
+    if (normalize(opts.expectedKeyHex) === normalize(actualKeyHex)) return { state: "confirmed", source: "provided" };
+    return { state: "mismatch", source: "provided", expectedFingerprint: fingerprintOf(opts.expectedKeyHex) };
+  }
+  if (opts.onlineKeyHex !== void 0) {
+    if (normalize(opts.onlineKeyHex) === normalize(actualKeyHex)) return { state: "confirmed", source: "online" };
+    return { state: "mismatch", source: "online", expectedFingerprint: fingerprintOf(opts.onlineKeyHex) };
+  }
+  return { state: "unconfirmed" };
+}
+
+export {
+  readPairing,
+  fingerprintOf,
+  REPORT_ELEMENTS,
+  REPORT_BRIEF,
+  sanitizeReport,
+  parseElements,
+  formatDateTime,
+  profileShortLabel,
+  agentTicketRow,
+  agentTicket,
+  agentApproval,
+  agentMandate,
+  resolveTicketElement,
+  resolveApprovalElement,
+  resolveMandateElement,
+  parseTimestampSeconds,
+  parseCaseAttrs,
+  CASE_TIME_UNKNOWN_REASON,
+  resolveCaseElement,
+  START_TIME_METRICS,
+  computeMetric,
+  ticketFields,
+  approvalFields,
+  mandateFields,
+  checkedValueLine,
+  glossaryUsage,
+  renderReportHtml,
+  buildExportBundle,
+  buildExportDocument,
+  suggestedFilename,
+  isExportBundle,
+  verifyExportBundle
+};