@tangle-network/charts 0.1.0

package/dist/index.js

@@ -0,0 +1,1771 @@
+// src/text.ts
+function esc(value) {
+  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+var REGULAR = [
+  281,
+  288,
+  466,
+  633,
+  642,
+  982,
+  644,
+  300,
+  365,
+  365,
+  501,
+  662,
+  288,
+  460,
+  288,
+  360,
+  631,
+  407,
+  610,
+  618,
+  646,
+  608,
+  620,
+  566,
+  619,
+  620,
+  288,
+  302,
+  662,
+  662,
+  662,
+  511,
+  966,
+  690,
+  654,
+  730,
+  722,
+  601,
+  590,
+  746,
+  743,
+  269,
+  571,
+  672,
+  565,
+  903,
+  753,
+  765,
+  639,
+  765,
+  644,
+  642,
+  646,
+  744,
+  690,
+  985,
+  682,
+  679,
+  629,
+  365,
+  360,
+  365,
+  471,
+  456,
+  323,
+  562,
+  612,
+  571,
+  612,
+  583,
+  370,
+  613,
+  591,
+  242,
+  242,
+  549,
+  242,
+  876,
+  591,
+  600,
+  612,
+  612,
+  376,
+  528,
+  327,
+  591,
+  562,
+  818,
+  546,
+  562,
+  552,
+  426,
+  333,
+  426,
+  662
+];
+var SEMIBOLD = [
+  252,
+  321,
+  523,
+  644,
+  650,
+  1004,
+  663,
+  326,
+  373,
+  373,
+  540,
+  673,
+  319,
+  465,
+  319,
+  379,
+  660,
+  423,
+  623,
+  636,
+  666,
+  629,
+  640,
+  576,
+  640,
+  640,
+  319,
+  329,
+  673,
+  673,
+  673,
+  543,
+  999,
+  728,
+  659,
+  737,
+  722,
+  605,
+  588,
+  749,
+  746,
+  277,
+  580,
+  703,
+  565,
+  922,
+  759,
+  769,
+  645,
+  773,
+  652,
+  650,
+  660,
+  736,
+  728,
+  1020,
+  720,
+  713,
+  652,
+  373,
+  379,
+  373,
+  481,
+  469,
+  351,
+  574,
+  624,
+  583,
+  624,
+  591,
+  389,
+  625,
+  612,
+  262,
+  262,
+  569,
+  262,
+  900,
+  612,
+  609,
+  624,
+  624,
+  397,
+  549,
+  353,
+  612,
+  587,
+  839,
+  569,
+  588,
+  566,
+  455,
+  359,
+  455,
+  673
+];
+var EXTRA = {
+  "\xB7": 300,
+  "\xD7": 670,
+  "\u2014": 1e3,
+  "\u2013": 500,
+  "\u2026": 900,
+  "\u2265": 670,
+  "\u2264": 670,
+  "\xB1": 670,
+  "\u2192": 954,
+  "\u2212": 662
+};
+var MARGIN = 1.04;
+function textWidth(text2, size, face = "sans") {
+  if (face === "mono") return text2.length * 0.6 * size * MARGIN;
+  const table2 = face === "sans-semibold" ? SEMIBOLD : REGULAR;
+  let units = 0;
+  for (const ch of text2) {
+    const code = ch.codePointAt(0) ?? 0;
+    units += code >= 32 && code <= 126 ? table2[code - 32] : EXTRA[ch] ?? 620;
+  }
+  return units / 1e3 * size * MARGIN;
+}
+function wrap(text2, width, size, face = "sans", maxLines = 2) {
+  const fits = (s) => textWidth(s, size, face) <= width;
+  const lines = [];
+  const glue = [];
+  let line2 = "";
+  const breakLine = (next, joiner) => {
+    lines.push(line2);
+    glue.push(joiner);
+    line2 = next;
+  };
+  for (const word of text2.split(/\s+/).filter(Boolean)) {
+    const joined = line2 ? `${line2} ${word}` : word;
+    if (fits(joined)) {
+      line2 = joined;
+    } else if (fits(word)) {
+      if (line2) breakLine(word, " ");
+      else line2 = word;
+    } else {
+      const pieces = word.match(/[^\-/_·]+[\-/_·]?|[\-/_·]/g) ?? [word];
+      for (const [index, piece] of pieces.entries()) {
+        const joiner = index === 0 ? " " : "";
+        const candidate = line2 ? `${line2}${joiner}${piece}` : piece;
+        if (fits(candidate) || !line2) line2 = candidate;
+        else breakLine(piece, joiner);
+      }
+    }
+  }
+  if (line2) lines.push(line2);
+  if (lines.length <= maxLines && lines.every(fits)) {
+    return { lines, truncated: false };
+  }
+  const kept = lines.slice(0, maxLines);
+  let last = lines.slice(maxLines - 1).reduce((acc, l, i) => i === 0 ? l : `${acc}${glue[maxLines - 2 + i]}${l}`, "");
+  while (last.length > 1 && !fits(`${last}\u2026`)) last = last.slice(0, -1);
+  kept[maxLines - 1] = `${last.trimEnd()}\u2026`;
+  return { lines: kept, truncated: true };
+}
+function textBlock(lines, x, y, lineHeight, attrs) {
+  if (lines.length === 1) return `<text x="${x}" y="${y}" ${attrs}>${esc(lines[0])}</text>`;
+  const spans = lines.map((line2, i) => `<tspan x="${x}" dy="${i === 0 ? 0 : lineHeight}">${esc(line2)}</tspan>`).join("");
+  return `<text x="${x}" y="${y}" ${attrs}>${spans}</text>`;
+}
+function fitLines(parts, width, size, face = "sans") {
+  const lines = [];
+  for (const part of parts) {
+    const last = lines[lines.length - 1];
+    if (last !== void 0 && textWidth(`${last} \xB7 ${part}`, size, face) <= width) lines[lines.length - 1] = `${last} \xB7 ${part}`;
+    else lines.push(part);
+  }
+  return lines;
+}
+function plural(count, one, many = `${one}s`) {
+  return count === 1 ? one : many;
+}
+function listJoin(items) {
+  if (items.length <= 1) return items.join("");
+  return `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
+}
+function capitalize(text2) {
+  return text2.charAt(0).toUpperCase() + text2.slice(1);
+}
+
+// src/block.ts
+var slug = (id) => id.replace(/[^a-z0-9-]+/gi, "-").toLowerCase();
+function renderFigure(f, noteNumber) {
+  const id = slug(f.id);
+  const plotLabel = `${f.finding} ${f.lede}`;
+  const narrow2 = f.svg.narrow ? `<div class="tgc-narrow">${f.svg.narrow}</div>` : `<div class="tgc-narrow tgc-narrow-table">${f.table}</div>`;
+  return [
+    `<figure class="tgc-figure" id="fig-${id}" aria-labelledby="fig-${id}-finding">`,
+    `<h3 class="tgc-finding" id="fig-${id}-finding">${esc(f.finding)}<sup><a class="tgc-noteref" href="#note-${noteNumber}" id="ref-${noteNumber}" role="doc-noteref" aria-label="Note ${noteNumber}">${noteNumber}</a></sup></h3>`,
+    `<p class="tgc-lede">${esc(f.lede)}</p>`,
+    `<div class="tgc-plot" role="img" aria-label="${esc(plotLabel)}">`,
+    `<div class="tgc-wide">${f.svg.wide}</div>`,
+    narrow2,
+    `</div>`,
+    `<p class="tgc-read">${esc(f.read)}</p>`,
+    `<details class="tgc-data"><summary>Data</summary><div class="tgc-scroll" role="region" aria-label="${esc(f.finding)} data" tabindex="0">${f.table}</div></details>`,
+    `</figure>`
+  ].join("");
+}
+function renderNotes(figures) {
+  const items = figures.map((f, i) => {
+    const n = i + 1;
+    if (!f.note.method.trim() || !f.note.n.trim()) {
+      throw new Error(`renderNotes: figure ${f.id} has no method or no n; a note needs both.`);
+    }
+    const text2 = [f.note.method, f.note.n, ...f.note.exclusions].map(esc).join(" ");
+    return `<li id="note-${n}">${text2} <a class="tgc-backlink" href="#ref-${n}" role="doc-backlink" aria-label="Back to figure ${n}">\u21A9</a></li>`;
+  });
+  return `<ol class="tgc-notes">${items.join("")}</ol>`;
+}
+function renderRefusals(refusals) {
+  if (refusals.length === 0) return "";
+  return `<ul class="tgc-refusals">${refusals.map((r) => `<li>${esc(r.refused)}</li>`).join("")}</ul>`;
+}
+
+// src/svg.ts
+var WIDE = 720;
+var NARROW = 358;
+var r2 = (n) => Math.round(n * 100) / 100;
+function svgRoot(width, height, inner) {
+  const h = Math.ceil(height);
+  return `<svg class="tgc-svg" xmlns="http://www.w3.org/2000/svg" width="${width}" height="${h}" viewBox="0 0 ${width} ${h}" aria-hidden="true" focusable="false">${inner}</svg>`;
+}
+function hbar(x, y, w, h, cls) {
+  if (w <= 0) return "";
+  const r = Math.min(4, h / 2, w);
+  return `<path class="${cls}" d="M${r2(x)} ${r2(y)}h${r2(w - r)}a${r} ${r} 0 0 1 ${r} ${r}v${r2(h - 2 * r)}a${r} ${r} 0 0 1 -${r} ${r}h-${r2(w - r)}z"/>`;
+}
+function rect(x, y, w, h, cls, extra = "") {
+  if (w <= 0 || h <= 0) return "";
+  return `<rect class="${cls}" x="${r2(x)}" y="${r2(y)}" width="${r2(w)}" height="${r2(h)}"${extra ? ` ${extra}` : ""}/>`;
+}
+function line(x1, y1, x2, y2, cls) {
+  return `<line class="${cls}" x1="${r2(x1)}" y1="${r2(y1)}" x2="${r2(x2)}" y2="${r2(y2)}"/>`;
+}
+function circle(cx, cy, r, cls) {
+  return `<circle class="${cls}" cx="${r2(cx)}" cy="${r2(cy)}" r="${r}"/>`;
+}
+function polyline(points, cls) {
+  return `<polyline class="${cls}" points="${points.map(([x, y]) => `${r2(x)},${r2(y)}`).join(" ")}"/>`;
+}
+function text(x, y, value, o = {}) {
+  const anchor = o.anchor && o.anchor !== "start" ? ` text-anchor="${o.anchor}"` : "";
+  const weight = o.weight === 600 ? ` font-weight="600"` : "";
+  return `<text class="${o.cls ?? "tgc-ink"}" x="${r2(x)}" y="${r2(y)}" font-size="${o.size ?? 12}"${anchor}${weight}>${esc(value)}</text>`;
+}
+function titled(title, inner) {
+  return `<g><title>${esc(title)}</title>${inner}</g>`;
+}
+
+// src/table.ts
+function table(caption, columns, rows) {
+  const head = columns.map((c) => `<th scope="col"${c.numeric ? ' class="tgc-n"' : ""}>${esc(c.label)}</th>`).join("");
+  const body = rows.map(
+    (row) => `<tr>${row.map(
+      (cell, i) => i === 0 ? `<th scope="row">${esc(cell)}</th>` : `<td${columns[i]?.numeric ? ' class="tgc-n"' : ""}>${esc(cell)}</td>`
+    ).join("")}</tr>`
+  ).join("");
+  return `<table class="tgc-table"><caption>${esc(caption)}</caption><thead><tr>${head}</tr></thead><tbody>${body}</tbody></table>`;
+}
+
+// src/breakdown.ts
+function breakdown(input, o) {
+  const id = o.id ?? "breakdown";
+  const { reasons, setups } = input;
+  if (reasons.length === 0 || setups.length === 0) return { id, refused: `No ${o.measure} to break down.` };
+  const count = /* @__PURE__ */ new Map();
+  for (const c of input.counts) {
+    if (!reasons.includes(c.reason) || !setups.some((s) => s.id === c.setup)) {
+      return { id, refused: `A count names ${c.reason} \xD7 ${c.setup}, which is not in the reason and setup lists.` };
+    }
+    const n = setups.find((s) => s.id === c.setup).n;
+    if (c.count !== null && n !== null && c.count > n) {
+      return { id, refused: `${c.reason} \xD7 ${c.setup}: ${c.count} exceeds the column's ${n} attempts.` };
+    }
+    count.set(`${c.reason}\0${c.setup}`, c.count);
+  }
+  const get = (reason, setup) => count.get(`${reason}\0${setup}`) ?? null;
+  const withN = setups.filter((s) => s.n !== null);
+  const total = withN.reduce((s, x) => s + x.n, 0);
+  const sums = reasons.map((r) => ({ r, k: withN.reduce((s, x) => s + (get(r, x.id) ?? 0), 0) }));
+  const top = Math.max(...sums.map((x) => x.k));
+  const leaders = sums.filter((x) => x.k === top).map((x) => x.r);
+  const finding = total === 0 || top === 0 ? `No ${o.measure} recorded.` : leaders.length === 1 ? `${capitalize(leaders[0])} stops the most attempts: ${top} of ${total}.` : `${capitalize(listJoin(leaders))} each stop ${top} of ${total} attempts.`;
+  const lede = `${total} ${plural(total, "attempt")} across ${setups.length} ${plural(setups.length, "setup")}, ${reasons.length} ${plural(reasons.length, "reason")}.`;
+  const read = "Each cell counts attempts stopped by that reason out of the column's n; the tint deepens with the share." + (input.overlapping ? " One attempt can count under more than one reason." : "");
+  const noN = setups.filter((s) => s.n === null);
+  const exclusions = [
+    ...input.excluded ? [`${input.excluded.count} ${plural(input.excluded.count, "attempt")} excluded: ${input.excluded.why}.`] : [],
+    ...noN.length ? [`No share for ${listJoin(noN.map((s) => s.label))}: the column has no n.`] : []
+  ];
+  const tableHtml = table(
+    `${capitalize(o.measure)} by setup`,
+    [{ label: "Reason" }, ...setups.map((s) => ({ label: `${s.label} (n=${s.n ?? "unknown"})`, numeric: true }))],
+    reasons.map((r) => [r, ...setups.map((s) => {
+      const k = get(r, s.id);
+      return k === null ? "not recorded" : String(k);
+    })])
+  );
+  return {
+    id,
+    finding,
+    lede,
+    read,
+    svg: { wide: wide(input, get), narrow: null },
+    table: tableHtml,
+    note: {
+      method: `Counts of ${o.measure} per setup${input.overlapping ? "; reasons overlap" : ""}. Tint is count over n, capped at half strength.`,
+      n: `${total} ${plural(total, "attempt")} over ${setups.length} ${plural(setups.length, "setup")}.`,
+      exclusions
+    }
+  };
+}
+function wide(input, get) {
+  const x0 = 208;
+  const colW = (WIDE - x0) / input.setups.length;
+  let head = "";
+  let headH = 0;
+  for (const [j, s] of input.setups.entries()) {
+    const label = wrap(s.label, colW - 8, 12, "sans", 3);
+    head += titled(s.label, textBlock(label.lines, x0 + j * colW, 14, 16, `class="tgc-ink" font-size="12"`));
+    head += text(x0 + j * colW, 14 + label.lines.length * 16, `n=${s.n ?? "?"}`, { cls: "tgc-ink-muted tgc-num" });
+    headH = Math.max(headH, label.lines.length * 16 + 16);
+  }
+  let y = headH + 8;
+  let body = "";
+  for (const reason of input.reasons) {
+    const label = wrap(reason, 196, 14, "sans", 2);
+    const h = Math.max(32, label.lines.length * 18 + 12);
+    body += textBlock(label.lines, 0, y + 20, 18, `class="tgc-ink" font-size="14"`);
+    for (const [j, s] of input.setups.entries()) {
+      const k = get(reason, s.id);
+      const x = x0 + j * colW;
+      const share = k !== null && s.n ? k / s.n : null;
+      let marks = share !== null ? rect(x, y + 2, colW - 8, h - 4, "tgc-tint", `rx="2" style="--s:${share.toFixed(3)}"`) : "";
+      marks += text(x + 8, y + 20, k === null ? "\xB7" : String(k), { cls: k === null ? "tgc-ink-muted tgc-num" : "tgc-ink tgc-num" });
+      body += titled(`${reason} \xB7 ${s.label}: ${k === null ? "not recorded" : `${k} of ${s.n ?? "?"}`}`, marks);
+    }
+    y += h;
+  }
+  return svgRoot(WIDE, y + 4, head + body);
+}
+
+// src/format.ts
+var TIERS_BEST_FIRST = ["S", "A", "B", "C", "F"];
+var LADDER = ["F", "C", "B", "A", "S"];
+function tierAtLeast(tier, floor) {
+  return LADDER.indexOf(tier) >= LADDER.indexOf(floor);
+}
+function pct(value) {
+  return `${Math.round(value * 100)}%`;
+}
+function pts(value) {
+  const n = Math.round(value * 100);
+  return `${n > 0 ? "+" : n < 0 ? "\u2212" : ""}${Math.abs(n)} pts`;
+}
+function usd(value) {
+  if (value >= 100) return `$${Math.round(value).toLocaleString("en-US")}`;
+  if (value >= 1) return `$${value.toFixed(2)}`;
+  if (value >= 0.01) return `$${value.toFixed(3)}`;
+  return `$${value.toFixed(4)}`;
+}
+function usdTick(value) {
+  return `$${Number(value.toPrecision(2)).toLocaleString("en-US", { maximumFractionDigits: 4 })}`;
+}
+function duration(ms) {
+  const s = ms / 1e3;
+  if (s < 60) return `${Math.round(s)} s`;
+  if (s < 3600) return `${(s / 60).toFixed(1)} min`;
+  return `${(s / 3600).toFixed(1)} h`;
+}
+function kn(k, n) {
+  return `${k}/${n}`;
+}
+var METHOD_NAME = {
+  "task-cluster-bootstrap": "task-clustered bootstrap",
+  "mcnemar-exact": "exact McNemar",
+  wilson: "Wilson score"
+};
+function intervalName(interval) {
+  return `${Math.round((interval.level ?? 0) * 100)}% ${interval.method ? METHOD_NAME[interval.method] : ""}`.trim();
+}
+function intervalGap(interval) {
+  if (!interval) return "no interval";
+  const missing = [interval.level === null ? "level" : "", interval.method === null ? "method" : ""].filter(Boolean);
+  if (missing.length) return `the interval names no ${missing.join(" or ")}`;
+  if (!(interval.lower <= interval.upper)) return "the interval bounds are out of order";
+  return null;
+}
+function drawable(estimate) {
+  return estimate === "descriptive" || estimate === "bootstrap";
+}
+function estimateNote(estimate, units) {
+  if (estimate === "none") return units === 1 ? "1 unit" : `${units} units`;
+  if (estimate === "insufficient") return "too few units";
+  return "";
+}
+function costText(cost, solved) {
+  if (cost.perSolvedUsd === null) return solved === 0 ? "no pass" : "unknown";
+  return cost.basis === "receipts" ? usd(cost.perSolvedUsd) : `${usd(cost.perSolvedUsd)} est.`;
+}
+function tierSummary(tiers, unmeasured = 0, flagged = 0) {
+  const parts = tiers ? TIERS_BEST_FIRST.filter((t) => tiers[t] > 0).map((t) => `${tiers[t]}${t}`) : [];
+  if (flagged) parts.push(`${flagged} flagged`);
+  if (unmeasured) parts.push(`${unmeasured}U`);
+  return parts.join(" ");
+}
+function tierTotal(tiers) {
+  return tiers ? LADDER.reduce((sum, t) => sum + tiers[t], 0) : 0;
+}
+
+// src/scale.ts
+function linear(domain, range) {
+  const [d0, d1] = domain;
+  const [r0, r1] = range;
+  const slope = (r1 - r0) / (d1 - d0 || 1);
+  const scale = ((value) => r0 + (value - d0) * slope);
+  scale.domain = domain;
+  scale.range = range;
+  return scale;
+}
+function log(domain, range) {
+  const inner = linear([Math.log10(domain[0]), Math.log10(domain[1])], range);
+  const scale = ((value) => inner(Math.log10(value)));
+  scale.domain = domain;
+  scale.range = range;
+  return scale;
+}
+function linearTicks(min, max, count) {
+  const span = max - min;
+  if (span <= 0) return [min];
+  const rough = span / count;
+  const exp = 10 ** Math.floor(Math.log10(rough));
+  const fraction = rough / exp;
+  const step = (fraction < 1.5 ? 1 : fraction < 3 ? 2 : fraction < 7 ? 5 : 10) * exp;
+  const out = [];
+  for (let v = Math.ceil(min / step) * step; v <= max + step * 1e-9; v += step) {
+    out.push(Number(v.toFixed(10)));
+  }
+  return out;
+}
+function logTicks(min, max) {
+  const sets = [[1], [1, 2, 5], [1, 2, 3, 5], [1, 1.5, 2, 2.5, 3, 4, 5, 6, 8]];
+  let best = [];
+  for (const mantissas of sets) {
+    const out = [];
+    for (let e = Math.floor(Math.log10(min)) - 1; e <= Math.ceil(Math.log10(max)); e++) {
+      for (const m of mantissas) {
+        const v = Number((m * 10 ** e).toPrecision(6));
+        if (v >= min && v <= max) out.push(v);
+      }
+    }
+    best = out;
+    if (out.length >= 3) break;
+  }
+  return best;
+}
+function logDomain(lo, hi, minFactor = 3, pad = 1.25) {
+  let a = lo;
+  let b = hi;
+  if (b / a < minFactor) {
+    const centre = Math.sqrt(a * b);
+    const half = Math.sqrt(minFactor);
+    a = centre / half;
+    b = centre * half;
+  }
+  return [a / pad, b * pad];
+}
+
+// src/comparison-intervals.ts
+function gaps(row) {
+  const out = [];
+  const gap = intervalGap(row.interval);
+  if (gap) out.push(gap);
+  if (row.pairs === null) out.push("no pair count");
+  if (row.minimumEffect === null) out.push("no registered minimum effect");
+  return out;
+}
+function comparisonIntervals(rows, setups, o) {
+  const id = o.id ?? "comparison-intervals";
+  const name = (setupId) => setups.find((s) => s.id === setupId)?.label ?? setupId;
+  const title = (row) => `${name(row.favored)} over ${name(row.other)}`;
+  if (rows.length === 0) return { id, refused: "No comparison was registered." };
+  const drawn = [];
+  const refused = [];
+  for (const row of rows) {
+    const missing = gaps(row);
+    if (missing.length) refused.push(`${title(row)}: ${listJoin(missing)}`);
+    else drawn.push({ row, title: title(row) });
+  }
+  if (drawn.length === 0) {
+    return {
+      id,
+      refused: rows.every((r) => r.interval === null) ? "No comparison carries an interval." : `No comparison can be drawn. ${refused.join("; ")}.`
+    };
+  }
+  const clears = drawn.filter(
+    ({ row }) => row.interval.lower > row.minimumEffect && (intervalGap(row.exactInterval) !== null || row.exactInterval.lower > row.minimumEffect)
+  );
+  const finding = clears.length === drawn.length ? drawn.length === 1 ? "The step clears its registered minimum effect." : `Each of the ${drawn.length} steps clears its registered minimum effect.` : clears.length === 0 ? `No step clears its registered minimum effect.` : `${clears.length} of ${drawn.length} steps clear their registered minimum effect.`;
+  const pairs = drawn.reduce((s, d) => s + d.row.pairs, 0);
+  const lede = `${drawn.length} ${plural(drawn.length, "comparison")} over ${pairs} paired ${plural(pairs, "attempt")}${refused.length ? `; ${refused.length} not drawn` : ""}.`;
+  const names = [...new Set(drawn.map((d) => intervalName(d.row.interval)))];
+  const exactNames = [
+    ...new Set(drawn.filter((d) => intervalGap(d.row.exactInterval) === null).map((d) => intervalName(d.row.exactInterval)))
+  ];
+  const read = `Each bar is the ${names.join(" or ")} interval on the difference in ${o.measure}` + (exactNames.length ? `; the thin bar under it is the ${exactNames.join(" or ")} interval` : "") + ". A step is backed when every bar lies wholly right of the dashed minimum effect.";
+  const columns = [
+    { label: "Comparison" },
+    { label: "Pairs", numeric: true },
+    { label: "Minimum effect", numeric: true },
+    { label: "Interval", numeric: true },
+    { label: "Exact interval", numeric: true }
+  ];
+  const fmt = (i) => i && intervalGap(i) === null ? `${pts(i.lower)} to ${pts(i.upper)} (${intervalName(i)})` : i ? `${pts(i.lower)} to ${pts(i.upper)} (${intervalGap(i)})` : "none";
+  const tableRows = rows.map((row) => [
+    title(row),
+    row.pairs === null ? "not recorded" : String(row.pairs),
+    row.minimumEffect === null ? "none registered" : pts(row.minimumEffect),
+    fmt(row.interval),
+    fmt(row.exactInterval)
+  ]);
+  const values = drawn.flatMap(({ row }) => [
+    row.interval.lower,
+    row.interval.upper,
+    row.minimumEffect,
+    0,
+    ...row.exactInterval ? [row.exactInterval.lower, row.exactInterval.upper] : []
+  ]);
+  const span = Math.max(...values) - Math.min(...values) || 0.1;
+  const domain = [Math.min(...values) - span * 0.08, Math.max(...values) + span * 0.08];
+  return {
+    id,
+    finding,
+    lede,
+    read,
+    svg: { wide: draw(drawn, domain, WIDE, 272, 264), narrow: draw(drawn, domain, NARROW, 0, 0) },
+    table: table(`Comparisons on ${o.measure}`, columns, tableRows),
+    note: {
+      method: `${capitalize(o.measure)} difference, favored minus other, in points. Intervals: ${[...names, ...exactNames].join(", ")}.`,
+      n: `${pairs} paired ${plural(pairs, "attempt")} over ${drawn.length} ${plural(drawn.length, "comparison")}.`,
+      exclusions: refused.map((r) => `Not drawn: ${r}.`)
+    }
+  };
+}
+function draw(drawn, domain, width, plotX, labelW) {
+  const x = linear(domain, [plotX, width - 8]);
+  let body = "";
+  let y = 8;
+  const rowsTop = y;
+  for (const { row, title } of drawn) {
+    let marks = "";
+    let barY;
+    if (labelW > 0) {
+      const label = wrap(title, labelW, 14);
+      marks += textBlock(label.lines, 0, y + 14, 18, `class="tgc-ink" font-size="14"`);
+      marks += text(0, y + 14 + label.lines.length * 18, `${row.pairs} pairs`, { cls: "tgc-ink-muted tgc-num" });
+      barY = y + 8;
+      y += Math.max(label.lines.length * 18 + 22, 36);
+    } else {
+      const label = wrap(title, width, 14);
+      marks += textBlock(label.lines, 0, y + 14, 18, `class="tgc-ink" font-size="14"`);
+      marks += text(width, y + 14, `${row.pairs} pairs`, { cls: "tgc-ink-muted tgc-num", anchor: "end" });
+      barY = y + label.lines.length * 18 + 4;
+      y = barY + 24;
+    }
+    const lo = x(row.interval.lower);
+    const hi = x(row.interval.upper);
+    marks += rect(lo, barY, Math.max(hi - lo, 2), 6, "tgc-ci");
+    if (row.exactInterval && intervalGap(row.exactInterval) === null) {
+      const elo = x(row.exactInterval.lower);
+      const ehi = x(row.exactInterval.upper);
+      marks += rect(elo, barY + 9, Math.max(ehi - elo, 2), 2, "tgc-ci-exact");
+    }
+    const me = x(row.minimumEffect);
+    marks += line(me, barY - 8, me, barY + 20, "tgc-threshold");
+    body += titled(
+      `${title} \xB7 ${row.pairs} pairs \xB7 ${pts(row.interval.lower)} to ${pts(row.interval.upper)} \xB7 minimum effect ${pts(row.minimumEffect)}`,
+      marks
+    );
+  }
+  const zero = x(0);
+  let axis = line(zero, rowsTop, zero, y, "tgc-zero");
+  for (const t of linearTicks(domain[0], domain[1], width > 400 ? 6 : 3)) {
+    axis += text(x(t), y + 16, pts(t), { cls: "tgc-ink-muted tgc-num", anchor: "middle" });
+  }
+  return svgRoot(width, y + 24, axis + body);
+}
+
+// src/cost-frontier.ts
+var overlaps = (a, b) => a.x0 < b.x1 && b.x0 < a.x1 && a.y0 < b.y1 && b.y0 < a.y1;
+function costFrontier(rows, o) {
+  const id = o.id ?? "cost-frontier";
+  const costed = rows.filter((row) => row.cost.perSolvedUsd !== null && row.cost.perSolvedUsd > 0);
+  const unplaced = rows.filter((row) => !costed.includes(row));
+  if (costed.length === 0) return { id, refused: `No setup has a cost per pass, so cost is not drawn.` };
+  if (costed.length < 2) {
+    return {
+      id,
+      refused: `Fewer than two setups have a cost per pass (${costed.length} of ${rows.length}); ${unplacedText(unplaced)}.`
+    };
+  }
+  const front = costed.filter((row) => row.onFront === true);
+  const drawLine = front.length >= 2;
+  const cheapestFront = [...front].sort((a, b) => a.cost.perSolvedUsd - b.cost.perSolvedUsd)[0];
+  const top = rows.every((r) => r.rank !== null) ? [...rows].sort((a, b) => a.rank - b.rank)[0] : [...rows].sort((a, b) => b.rate - a.rate)[0];
+  const est = (row) => row.cost.basis === "receipts" ? "" : " (estimated)";
+  let finding;
+  if (cheapestFront && top.cost.perSolvedUsd !== null && cheapestFront.id !== top.id) {
+    const saving = 1 - cheapestFront.cost.perSolvedUsd / top.cost.perSolvedUsd;
+    finding = `${cheapestFront.label} costs ${usd(cheapestFront.cost.perSolvedUsd)} per pass${est(cheapestFront)}, ${pct(saving)} less than ${top.label}.`;
+  } else if (cheapestFront && cheapestFront.id === top.id) {
+    finding = `${top.label} leads on both ${o.measure} and cost per pass.`;
+  } else {
+    const cheapest = [...costed].sort((a, b) => a.cost.perSolvedUsd - b.cost.perSolvedUsd)[0];
+    finding = `${cheapest.label} has the lowest cost per pass, ${usd(cheapest.cost.perSolvedUsd)}${est(cheapest)}.`;
+  }
+  const lede = `${costed.length} of ${rows.length} setups have a cost per pass; ` + (drawLine ? `${front.length} sit on the producer's frontier.` : front.length === 1 ? "1 sits on the producer's frontier." : "the producer computed no frontier.");
+  const read = `Up is a higher ${o.measure}; right is cheaper per pass.` + (drawLine ? " Filled points sit on the frontier; the line joins them." : "") + (costed.some((r) => r.cost.basis !== "receipts") ? " A hollow accent ring is a frontier point with an estimated cost." : "");
+  const intervals = [...new Set(costed.filter((r) => intervalGap(r.interval) === null).map((r) => intervalName(r.interval)))];
+  const bases = [...new Set(costed.map((r) => r.cost.basis))];
+  const method = [
+    `Cost per pass is model spend over passed attempts, ${bases.map((b) => b === "receipts" ? "from router receipts" : b === "estimated" ? "estimated, not billed" : "from an unrecorded source").join(" or ")}.`,
+    "The frontier is the producer's: no setup off it is both cheaper and higher.",
+    intervals.length ? `Vertical lines: ${intervals.join(", ")} on the ${o.measure}.` : ""
+  ].filter(Boolean).join(" ");
+  const columns = [
+    { label: "Setup" },
+    { label: capitalize(o.measure), numeric: true },
+    { label: "Passed", numeric: true },
+    { label: "Cost per pass", numeric: true },
+    { label: "Cost basis" },
+    { label: "On frontier" }
+  ];
+  const sorted = [...rows].sort((a, b) => b.rate - a.rate);
+  const tableRows = sorted.map((row) => [
+    row.label,
+    pct(row.rate),
+    kn(row.solved, row.attempts),
+    costText(row.cost, row.solved),
+    row.cost.basis,
+    row.onFront === null ? "not computed" : row.onFront ? "yes" : "no"
+  ]);
+  const { svg, numbered } = plot(costed, unplaced, drawLine, o);
+  const tableHtml = table(
+    `${capitalize(o.measure)} and cost per pass`,
+    numbered.size ? [{ label: "Setup" }, { label: "Mark", numeric: true }, ...columns.slice(1)] : columns,
+    numbered.size ? sorted.map((row, i) => [tableRows[i][0], numbered.get(row.id) ?? "", ...tableRows[i].slice(1)]) : tableRows
+  );
+  return {
+    id,
+    finding,
+    lede,
+    read,
+    svg: { wide: svg, narrow: narrowList(sorted) },
+    table: tableHtml,
+    note: {
+      method,
+      n: `${rows.reduce((s, r) => s + r.attempts, 0)} attempts over ${rows.length} setups.`,
+      exclusions: unplaced.length ? [`Not placed: ${unplacedText(unplaced)}.`] : []
+    }
+  };
+}
+function narrowList(rows) {
+  const x1 = 300;
+  let out = "";
+  let y = 4;
+  for (const [i, row] of rows.entries()) {
+    const placed = row.cost.perSolvedUsd !== null && row.cost.perSolvedUsd > 0;
+    const label = wrap(row.label, NARROW - 16, 14);
+    let marks = placed ? circle(4, y + 10, 4, row.onFront ? row.cost.basis === "receipts" ? "tgc-pt-front" : "tgc-pt-est" : "tgc-pt") : "";
+    marks += textBlock(label.lines, 16, y + 14, 18, `class="tgc-ink" font-size="14"`);
+    let cy = y + label.lines.length * 18 + 6;
+    if (drawable(row.estimate)) {
+      let end = row.rate * x1;
+      marks += hbar(0, cy, end, 10, "tgc-bar");
+      if (intervalGap(row.interval) === null) {
+        const lo = row.interval.lower * x1;
+        const hi = row.interval.upper * x1;
+        marks += line(lo, cy + 5, hi, cy + 5, "tgc-whisker") + line(lo, cy + 1, lo, cy + 9, "tgc-whisker") + line(hi, cy + 1, hi, cy + 9, "tgc-whisker");
+        end = Math.max(end, hi);
+      }
+      marks += text(end + 6, cy + 9.5, pct(row.rate), { cls: "tgc-ink tgc-num" });
+      cy += 16;
+    }
+    const count = `${kn(row.solved, row.attempts)} passed${drawable(row.estimate) ? "" : `, ${estimateNote(row.estimate, row.attempts)}`}`;
+    const fact = placed ? `${count} \xB7 ${costText(row.cost, row.solved)} per pass${row.onFront ? " \xB7 on the frontier" : ""}` : `${count} \xB7 not placed`;
+    const facts = fitLines(fact.split(" \xB7 "), NARROW, 12, "mono");
+    marks += textBlock(facts, 0, cy + 12, 16, `class="tgc-ink-muted tgc-num" font-size="12"`);
+    out += titled(`${row.label} \xB7 ${fact}`, marks);
+    y = cy + 4 + facts.length * 16;
+    if (i < rows.length - 1) out += line(0, y + 2, NARROW, y + 2, "tgc-rule");
+    y += 10;
+  }
+  if (rows.some((r) => drawable(r.estimate))) {
+    for (const t of [0, 0.5, 1]) {
+      out += text(t * x1, y + 6, pct(t), { cls: "tgc-ink-muted tgc-num", anchor: t === 0 ? "start" : t === 1 ? "end" : "middle" });
+    }
+    y += 12;
+  }
+  return svgRoot(NARROW, y, out);
+}
+function unplacedText(rows) {
+  return listJoin(rows.map((r) => `${r.label}, ${r.solved === 0 ? "0 passed" : "cost unknown"}`));
+}
+function plot(costed, unplaced, drawLine, o) {
+  const left = 48;
+  const right = WIDE - 24;
+  const top = 32;
+  const bottom = 272;
+  const costs = costed.map((r) => r.cost.perSolvedUsd);
+  const [lo, hi] = logDomain(Math.min(...costs), Math.max(...costs));
+  const x = log([lo, hi], [left, right].reverse());
+  const y = (v) => bottom - v * (bottom - top);
+  let out = text(0, 14, capitalize(o.measure), { cls: "tgc-ink-muted" });
+  for (const v of [0, 0.25, 0.5, 0.75, 1]) {
+    out += line(left, y(v), right, y(v), v === 0 ? "tgc-axis" : "tgc-gridline");
+    out += text(left - 8, y(v) + 4, pct(v), { cls: "tgc-ink-muted tgc-num", anchor: "end" });
+  }
+  for (const t of logTicks(lo, hi)) {
+    out += line(x(t), bottom, x(t), bottom + 4, "tgc-axis");
+    out += text(x(t), bottom + 18, usdTick(t), { cls: "tgc-ink-muted tgc-num", anchor: "middle" });
+  }
+  out += text((left + right) / 2, bottom + 40, "Cost per pass, log scale, cheaper to the right", {
+    cls: "tgc-ink-muted",
+    anchor: "middle"
+  });
+  const placed = costed.map((row) => ({
+    row,
+    x: x(row.cost.perSolvedUsd),
+    y: y(row.rate),
+    estimated: row.cost.basis !== "receipts"
+  }));
+  if (drawLine) {
+    const pts2 = placed.filter((p) => p.row.onFront).sort((a, b) => a.x - b.x);
+    out += polyline(pts2.map((p) => [p.x, p.y]), "tgc-front-line");
+  }
+  for (const p of placed) {
+    if (intervalGap(p.row.interval) === null) {
+      out += line(p.x, y(p.row.interval.lower), p.x, y(p.row.interval.upper), "tgc-pt-ci");
+    }
+  }
+  const obstacles = placed.map((p) => ({ x0: p.x - 6, y0: p.y - 6, x1: p.x + 6, y1: p.y + 6 }));
+  for (const p of placed) {
+    if (intervalGap(p.row.interval) === null) {
+      obstacles.push({ x0: p.x - 2, y0: y(p.row.interval.upper), x1: p.x + 2, y1: y(p.row.interval.lower) });
+    }
+  }
+  const bounds = { x0: 0, y0: top - 8, x1: WIDE, y1: bottom - 2 };
+  const labels = [];
+  const numbered = /* @__PURE__ */ new Map();
+  for (const p of placed) {
+    const w = textWidth(p.row.label, 12);
+    const near = [
+      [p.x + 9, p.y + 4, "start", false],
+      [p.x - 9, p.y + 4, "end", false],
+      [p.x, p.y - 10, "middle", false],
+      [p.x, p.y + 18, "middle", false],
+      [p.x + 26, p.y - 20, "start", true],
+      [p.x - 26, p.y - 20, "end", true],
+      [p.x + 26, p.y + 26, "start", true],
+      [p.x - 26, p.y + 26, "end", true]
+    ];
+    let done = false;
+    for (const [lx, ly, anchor, leader] of near) {
+      const x0 = anchor === "start" ? lx : anchor === "end" ? lx - w : lx - w / 2;
+      const box = { x0, y0: ly - 11, x1: x0 + w, y1: ly + 3 };
+      const inside = box.x0 >= bounds.x0 && box.x1 <= bounds.x1 && box.y0 >= bounds.y0 && box.y1 <= bounds.y1;
+      if (!inside || obstacles.some((b) => overlaps(b, box))) continue;
+      obstacles.push(box);
+      if (leader) labels.push(line(p.x, p.y, anchor === "start" ? lx - 3 : lx + 3, ly - 4, "tgc-leader"));
+      labels.push(text(lx, ly, p.row.label, { cls: "tgc-ink", anchor }));
+      done = true;
+      break;
+    }
+    if (!done) {
+      const mark = String(numbered.size + 1);
+      numbered.set(p.row.id, mark);
+      labels.push(text(p.x + 8, p.y - 6, mark, { cls: "tgc-ink tgc-num" }));
+    }
+  }
+  for (const p of placed) {
+    const cls = p.row.onFront ? p.estimated ? "tgc-pt-est" : "tgc-pt-front" : "tgc-pt";
+    out += titled(
+      `${p.row.label} \xB7 ${pct(p.row.rate)} ${o.measure} \xB7 ${costText(p.row.cost, p.row.solved)} per pass${p.row.onFront ? " \xB7 on the frontier" : ""}`,
+      circle(p.x, p.y, 4, cls)
+    );
+  }
+  out += labels.join("");
+  let h = bottom + 48;
+  if (unplaced.length) {
+    const strip = wrap(`Not placed: ${unplacedText(unplaced)}.`, WIDE, 12, "sans", 4);
+    for (const [i, lineText] of strip.lines.entries()) {
+      out += text(0, h + 12 + i * 16, lineText, { cls: "tgc-ink-muted" });
+    }
+    h += strip.lines.length * 16 + 8;
+  }
+  return { svg: svgRoot(WIDE, h, out), numbered };
+}
+
+// src/css.generated.ts
+var figureCss = `/* @tangle-network/charts \u2014 figure block and mark styles.
+ *
+ * Every colour is a --chart-* token from @tangle-network/brand tokens.css, so a
+ * figure follows the page theme. A standalone document without brand tokens
+ * embeds \`chartTokensCss\` first. Fonts fall back to Inter and JetBrains Mono.
+ *
+ * Each figure carries a 720 px and a 358 px render. The swap follows the
+ * figure's own width (a container query), so a narrow column shows the phone
+ * render even on a wide screen. */
+
+.tgc-figure {
+  margin: 32px 0 0;
+  padding: 0;
+  max-width: 720px;
+  color: var(--chart-ink);
+  font-family: var(--font-sans, Inter, ui-sans-serif, system-ui, sans-serif);
+}
+
+.tgc-finding {
+  margin: 0 0 8px;
+  font-size: 16px;
+  line-height: 24px;
+  font-weight: 600;
+  color: var(--chart-ink);
+}
+
+.tgc-noteref {
+  margin-left: 2px;
+  font-size: 12px;
+  font-weight: 400;
+  color: var(--chart-ink-muted);
+  text-decoration: none;
+  font-family: var(--font-mono, "JetBrains Mono", ui-monospace, monospace);
+}
+.tgc-noteref:hover,
+.tgc-noteref:focus-visible {
+  color: var(--chart-accent);
+  text-decoration: underline;
+}
+
+.tgc-lede {
+  margin: 0 0 16px;
+  font-size: 14px;
+  line-height: 22px;
+  color: var(--text-secondary, var(--chart-ink));
+}
+
+.tgc-plot {
+  container-type: inline-size;
+}
+.tgc-wide svg,
+.tgc-narrow svg {
+  display: block;
+  overflow: visible;
+}
+.tgc-narrow {
+  display: none;
+}
+.tgc-narrow svg {
+  max-width: 100%;
+  height: auto;
+}
+@container (max-width: 719.98px) {
+  .tgc-wide {
+    display: none;
+  }
+  .tgc-narrow {
+    display: block;
+  }
+}
+
+.tgc-read {
+  margin: 8px 0 0;
+  font-size: 12px;
+  line-height: 16px;
+  color: var(--chart-ink-muted);
+}
+
+.tgc-data {
+  margin: 8px 0 0;
+  font-size: 12px;
+  line-height: 16px;
+}
+.tgc-data > summary {
+  cursor: pointer;
+  color: var(--chart-ink-muted);
+  width: fit-content;
+}
+.tgc-data > summary:hover {
+  color: var(--chart-ink);
+}
+.tgc-data[open] > summary {
+  margin-bottom: 8px;
+}
+
+.tgc-scroll {
+  overflow-x: auto;
+}
+.tgc-scroll:focus-visible {
+  outline: 2px solid var(--chart-accent);
+  outline-offset: 2px;
+}
+
+.tgc-table {
+  border-collapse: collapse;
+  min-width: 100%;
+  font-size: 12px;
+  line-height: 16px;
+  color: var(--chart-ink);
+  /* A host page's table rules must not restyle the figure's table. */
+  border: 0;
+  border-radius: 0;
+  background: none;
+}
+.tgc-table caption {
+  text-align: left;
+  padding: 0 0 8px;
+  color: var(--chart-ink-muted);
+}
+.tgc-table th,
+.tgc-table td {
+  padding: 6px 12px 6px 0;
+  border-bottom: 1px solid var(--chart-rule);
+  text-align: left;
+  vertical-align: top;
+  font-weight: 400;
+  font-size: inherit;
+  color: inherit;
+  background: none;
+  text-transform: none;
+  letter-spacing: normal;
+}
+.tgc-table thead th {
+  color: var(--chart-ink-muted);
+  white-space: nowrap;
+}
+.tgc-table tbody th {
+  position: sticky;
+  left: 0;
+  background: var(--chart-canvas, var(--depth-1, transparent));
+}
+.tgc-table .tgc-n {
+  font-family: var(--font-mono, "JetBrains Mono", ui-monospace, monospace);
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+}
+.tgc-table thead .tgc-n {
+  font-family: inherit;
+}
+.tgc-table tbody tr:hover {
+  background: var(--chart-shade);
+}
+.tgc-narrow-table .tgc-table {
+  display: block;
+  overflow-x: auto;
+}
+
+.tgc-notes {
+  margin: 16px 0 0;
+  padding-left: 20px;
+  font-size: 12px;
+  line-height: 16px;
+  color: var(--chart-ink-muted);
+}
+.tgc-notes li {
+  margin: 0 0 8px;
+  padding-left: 4px;
+}
+.tgc-notes li:target {
+  color: var(--chart-ink);
+}
+.tgc-backlink {
+  color: var(--chart-ink-muted);
+  text-decoration: none;
+}
+
+.tgc-refusals {
+  margin: 8px 0 0;
+  padding-left: 20px;
+  font-size: 14px;
+  line-height: 22px;
+  color: var(--chart-ink-muted);
+}
+
+/* Marks */
+.tgc-svg {
+  font-family: var(--font-sans, Inter, ui-sans-serif, system-ui, sans-serif);
+}
+.tgc-svg .tgc-num {
+  font-family: var(--font-mono, "JetBrains Mono", ui-monospace, monospace);
+  font-variant-numeric: tabular-nums;
+}
+.tgc-ink {
+  fill: var(--chart-ink);
+}
+.tgc-ink-muted {
+  fill: var(--chart-ink-muted);
+}
+.tgc-bar,
+.tgc-ci,
+.tgc-pt-front {
+  fill: var(--chart-accent);
+}
+.tgc-gridline {
+  stroke: var(--chart-grid);
+  stroke-width: 1;
+}
+.tgc-rule {
+  stroke: var(--chart-rule);
+  stroke-width: 1;
+}
+.tgc-axis,
+.tgc-zero {
+  stroke: var(--chart-muted);
+  stroke-width: 1;
+}
+.tgc-whisker,
+.tgc-tick {
+  stroke: var(--chart-ink);
+  stroke-width: 1.5;
+  stroke-linecap: round;
+}
+.tgc-threshold {
+  stroke: var(--chart-ink);
+  stroke-width: 1.5;
+  stroke-dasharray: 3 3;
+}
+.tgc-front-line {
+  fill: none;
+  stroke: var(--chart-ink);
+  stroke-width: 1.5;
+  stroke-linejoin: round;
+}
+.tgc-pt,
+.tgc-open {
+  fill: none;
+  stroke: var(--chart-muted);
+  stroke-width: 1.5;
+}
+.tgc-pt-est {
+  fill: none;
+  stroke: var(--chart-accent);
+  stroke-width: 2;
+}
+.tgc-pt-ci,
+.tgc-strike {
+  stroke: var(--chart-muted);
+  stroke-width: 1.5;
+}
+.tgc-leader {
+  stroke: var(--chart-muted);
+  stroke-width: 1;
+}
+.tgc-ci-exact,
+.tgc-dot {
+  fill: var(--chart-muted);
+}
+.tgc-dashed {
+  stroke-dasharray: 2 2;
+}
+.tgc-tier-c {
+  fill: var(--chart-tier-c);
+}
+.tgc-tier-b {
+  fill: var(--chart-tier-b);
+}
+.tgc-tier-a {
+  fill: var(--chart-tier-a);
+}
+.tgc-tier-s {
+  fill: var(--chart-tier-s);
+}
+/* Neutral tint for counts: never the accent, capped at half strength so ink keeps 6:1. */
+.tgc-tint {
+  fill: color-mix(in srgb, var(--chart-muted) calc(var(--s, 0) * 50%), transparent);
+}
+
+@media print {
+  .tgc-plot {
+    container-type: normal;
+  }
+  .tgc-wide {
+    display: block;
+  }
+  .tgc-narrow {
+    display: none;
+  }
+  .tgc-wide svg {
+    width: 100%;
+    height: auto;
+  }
+  .tgc-figure {
+    break-inside: avoid;
+  }
+}
+`;
+var chartTokensCss = ':root{--chart-ink:#2b2c3e;--chart-ink-muted:#65677b;--chart-muted:#737696;--chart-grid:#f2f2f7;--chart-rule:#cecfde;--chart-shade:rgba(76, 63, 198, 0.06);--chart-accent:hsl(246 54% 51%);--chart-tier-c:#9b9ef0;--chart-tier-b:#7c7fe3;--chart-tier-a:#5b5bd6;--chart-tier-s:#272962;--chart-canvas:#ffffff;color-scheme:light}\n@media (prefers-color-scheme: dark){:root:not([data-theme="light"]){--chart-ink:#e3e6ed;--chart-ink-muted:#9ea5b9;--chart-muted:#898da9;--chart-grid:#32324e;--chart-rule:#474a6b;--chart-shade:rgba(165, 180, 252, 0.07);--chart-accent:#818CF8;--chart-tier-c:#4a4a95;--chart-tier-b:#5b5bd6;--chart-tier-a:#8b87f0;--chart-tier-s:#b1a9ff;--chart-canvas:#151523;color-scheme:dark}}\n:root[data-theme="dark"]{--chart-ink:#e3e6ed;--chart-ink-muted:#9ea5b9;--chart-muted:#898da9;--chart-grid:#32324e;--chart-rule:#474a6b;--chart-shade:rgba(165, 180, 252, 0.07);--chart-accent:#818CF8;--chart-tier-c:#4a4a95;--chart-tier-b:#5b5bd6;--chart-tier-a:#8b87f0;--chart-tier-s:#b1a9ff;--chart-canvas:#151523;color-scheme:dark}\n@media print{:root,:root:not([data-theme="light"]),:root[data-theme="dark"]{--chart-ink:#2b2c3e;--chart-ink-muted:#65677b;--chart-muted:#737696;--chart-grid:#f2f2f7;--chart-rule:#cecfde;--chart-shade:rgba(76, 63, 198, 0.06);--chart-accent:hsl(246 54% 51%);--chart-tier-c:#9b9ef0;--chart-tier-b:#7c7fe3;--chart-tier-a:#5b5bd6;--chart-tier-s:#272962;--chart-canvas:#ffffff;color-scheme:light}}';
+
+// src/ranked-rates.ts
+var TICKS = [0, 0.25, 0.5, 0.75, 1];
+function rankedRates(input, o) {
+  const id = o.id ?? "ranked-rates";
+  const noun = o.nouns ?? { attempt: "attempt", setup: "setup" };
+  if (input.length === 0) return { id, refused: `No ${noun.setup} has an ${noun.attempt}.` };
+  for (const row of input) {
+    const expected = row.attempts > 0 ? row.solved / row.attempts : 0;
+    if (row.solved > row.attempts || Math.abs(row.rate - expected) > 1e-6) {
+      return { id, refused: `${row.label}: rate ${row.rate} disagrees with ${kn(row.solved, row.attempts)} passed.` };
+    }
+  }
+  const ranked = input.every((row) => row.rank !== null);
+  const rows = ranked ? [...input].sort((a, b) => a.rank - b.rank) : [...input].sort((a, b) => b.rate - a.rate);
+  const layout = {
+    ranked,
+    cost: rows.some((r) => r.cost.perSolvedUsd !== null || r.cost.basis !== "unknown" || r.cost.receipts !== null),
+    median: rows.some((r) => r.medianWallMs !== null)
+  };
+  const bars = rows.filter((row) => drawable(row.estimate));
+  const noBar = rows.filter((row) => !drawable(row.estimate));
+  const whiskers = bars.filter((row) => intervalGap(row.interval) === null);
+  const noWhisker = bars.filter((row) => intervalGap(row.interval) !== null);
+  const tiered = rows.some((row) => row.tiers !== null);
+  const passed = rows.reduce((sum, row) => sum + row.solved, 0);
+  const attempts = rows.reduce((sum, row) => sum + row.attempts, 0);
+  const setupsN = `${rows.length} ${plural(rows.length, noun.setup)}`;
+  const top = rows[0];
+  const uniqueTop = rows.length === 1 || rows[1].rate < top.rate;
+  const finding = ranked ? `${top.label} ranks first, passing ${pct(top.rate)} of ${plural(2, noun.attempt)}.` : rows.length === 1 && drawable(top.estimate) ? `${top.label} passes ${pct(top.rate)} of ${top.attempts} ${plural(top.attempts, noun.attempt)}.` : drawable(top.estimate) && uniqueTop ? `${top.label} has the highest ${o.measure}, ${pct(top.rate)} of ${top.attempts} ${plural(top.attempts, noun.attempt)}; no comparison backs the order.` : `Sorted by ${o.measure}; no comparison backs the order.`;
+  const lede = `${passed} of ${attempts} ${plural(attempts, noun.attempt)} passed across ${setupsN}.` + (noBar.length === rows.length ? ` No ${noun.setup} has enough units to draw a rate.` : noBar.length ? ` ${noBar.length} of ${setupsN} have too few units to draw a rate.` : "");
+  const intervalNames = [...new Set(whiskers.map((row) => intervalName(row.interval)))];
+  const read = bars.length ? [
+    `Bars show the share of ${plural(2, noun.attempt)} that passed${whiskers.length ? `; whiskers show the ${intervalNames.join(" or ")} interval` : ""}.`,
+    tiered ? `The strip under a bar splits ${plural(2, noun.attempt)} by App Grade tier${o.passTier ? `, and the tick marks ${o.passTier} or better` : ""}.` : ""
+  ].filter(Boolean).join(" ") : `Counts show ${plural(2, noun.attempt)} passed; no ${noun.setup} has enough units to draw a rate.`;
+  const bases = [...new Set(rows.filter((r) => r.cost.perSolvedUsd !== null).map((r) => r.cost.basis))];
+  const method = [
+    `${capitalize(o.measure)} is the share of ${plural(2, noun.attempt)} that passed${o.passTier ? `; a pass is App Grade ${o.passTier} or better` : ""}.`,
+    intervalNames.length ? `Intervals: ${intervalNames.join(", ")}, per ${noun.setup}.` : "",
+    bases.length ? `Cost per pass is model spend over passes, ${bases.map(basisPhrase).join(" or ")}.` : "",
+    layout.median ? `Median run is the median wall time of one ${noun.attempt}.` : ""
+  ].filter(Boolean).join(" ");
+  const exclusions = [
+    ...(o.excluded ?? []).map((e) => `${e.count} ${plural(e.count, noun.attempt)} excluded: ${e.why}.`),
+    ...noBar.length ? [`No bar for ${noBar.map((r) => `${r.label} (${estimateNote(r.estimate, r.attempts)})`).join(", ")}.`] : [],
+    ...noWhisker.length ? [`No whisker for ${noWhisker.map((r) => `${r.label} (${intervalGap(r.interval)})`).join(", ")}.`] : []
+  ];
+  const columns = [
+    { label: capitalize(noun.setup) },
+    ...ranked ? [{ label: "Rank", numeric: true }] : [],
+    { label: "Passed", numeric: true },
+    { label: capitalize(plural(2, noun.attempt)), numeric: true },
+    { label: capitalize(o.measure), numeric: true },
+    { label: "Interval", numeric: true },
+    ...tiered ? [{ label: "Tiers" }] : [],
+    ...layout.cost ? [{ label: "Cost per pass", numeric: true }, { label: "Cost basis" }] : [],
+    ...layout.median ? [{ label: "Median run", numeric: true }] : []
+  ];
+  const tableRows = rows.map((row) => {
+    const offLadder = row.tiers ? row.attempts - tierTotal(row.tiers) : 0;
+    return [
+      row.label,
+      ...ranked ? [String(row.rank)] : [],
+      String(row.solved),
+      String(row.attempts),
+      drawable(row.estimate) ? pct(row.rate) : estimateNote(row.estimate, row.attempts),
+      row.interval ? `${pct(row.interval.lower)}\u2013${pct(row.interval.upper)} (${intervalGap(row.interval) ?? intervalName(row.interval)})` : "none recorded",
+      ...tiered ? [row.tiers ? [tierSummary(row.tiers), offLadder ? `${offLadder} off the ladder` : ""].filter(Boolean).join(" \xB7 ") || "none" : "not graded"] : [],
+      ...layout.cost ? [costText(row.cost, row.solved), row.cost.basis + (row.cost.receipts !== null ? `, ${row.cost.receipts} receipts` : "")] : [],
+      ...layout.median ? [row.medianWallMs === null ? "unknown" : duration(row.medianWallMs)] : []
+    ];
+  });
+  return {
+    id,
+    finding,
+    lede,
+    read,
+    svg: { wide: wide2(rows, layout, noun, o), narrow: narrow(rows, layout, o) },
+    table: table(`${capitalize(o.measure)} by ${noun.setup}`, columns, tableRows),
+    note: {
+      method,
+      n: `${attempts} ${plural(attempts, noun.attempt)} over ${setupsN}.`,
+      exclusions
+    }
+  };
+}
+function basisPhrase(basis) {
+  if (basis === "receipts") return "from router receipts";
+  if (basis === "estimated") return "estimated, not billed (marked est.)";
+  return "from an unrecorded source";
+}
+function barMarks(row, x0, x1, y, o) {
+  const w = x1 - x0;
+  const at = (v) => x0 + Math.max(0, Math.min(1, v)) * w;
+  let out = hbar(x0, y, at(row.rate) - x0, 12, "tgc-bar");
+  let end = at(row.rate);
+  if (row.interval && intervalGap(row.interval) === null) {
+    const lo = at(row.interval.lower);
+    const hi = at(row.interval.upper);
+    out += line(lo, y + 6, hi, y + 6, "tgc-whisker");
+    out += line(lo, y + 2, lo, y + 10, "tgc-whisker") + line(hi, y + 2, hi, y + 10, "tgc-whisker");
+    end = Math.max(end, hi);
+  }
+  out += text(end + 6, y + 10.5, pct(row.rate), { cls: "tgc-ink tgc-num" });
+  if (row.tiers && row.attempts > 0) {
+    const sy = y + 16;
+    let cursor = x0;
+    for (const tier of TIERS_BEST_FIRST) {
+      const count = row.tiers[tier];
+      if (!count) continue;
+      const segment = count / row.attempts * w;
+      out += tier === "F" ? rect(cursor + 0.75, sy + 0.75, Math.max(0, segment - 3.5), 4.5, "tgc-open") : rect(cursor, sy, Math.max(0, segment - 2), 6, `tgc-tier-${tier.toLowerCase()}`);
+      cursor += segment;
+    }
+    if (o.passTier) {
+      const passing = TIERS_BEST_FIRST.filter((t) => tierAtLeast(t, o.passTier)).reduce((s, t) => s + row.tiers[t], 0);
+      const tx = x0 + passing / row.attempts * w;
+      out += line(tx, sy - 3, tx, sy + 9, "tgc-tick");
+    }
+  }
+  return out;
+}
+function hoverText(row) {
+  const parts = [
+    row.label,
+    `${kn(row.solved, row.attempts)} passed`,
+    drawable(row.estimate) ? pct(row.rate) : estimateNote(row.estimate, row.attempts)
+  ];
+  if (row.interval && intervalGap(row.interval) === null) {
+    parts.push(`${intervalName(row.interval)} ${pct(row.interval.lower)}\u2013${pct(row.interval.upper)}`);
+  }
+  if (row.tiers) parts.push(tierSummary(row.tiers));
+  if (row.cost.perSolvedUsd !== null) parts.push(`${costText(row.cost, row.solved)} per pass`);
+  return parts.join(" \xB7 ");
+}
+function wide2(rows, layout, noun, o) {
+  const labelX = layout.ranked ? 32 : 0;
+  const labelW = layout.ranked ? 200 : 232;
+  const x0 = 248;
+  const extra = (layout.cost ? 104 : 0) + (layout.median ? 80 : 0);
+  const knRight = WIDE - extra;
+  const x1 = knRight - 96;
+  const costRight = knRight + 104;
+  const top = 34;
+  let body = "";
+  let y = top;
+  for (const [i, row] of rows.entries()) {
+    const label = wrap(row.label, labelW, 14);
+    const h = Math.max(label.lines.length * 18 + 14, row.tiers && drawable(row.estimate) ? 40 : 32);
+    let marks = "";
+    if (layout.ranked) marks += text(20, y + 18, String(row.rank), { cls: "tgc-ink-muted tgc-num", anchor: "end" });
+    marks += textBlock(label.lines, labelX, y + 18, 18, `class="tgc-ink" font-size="14"`);
+    marks += drawable(row.estimate) ? barMarks(row, x0, x1, y + 7, o) : text(x0, y + 18, estimateNote(row.estimate, row.attempts), { cls: "tgc-ink-muted" });
+    marks += text(knRight, y + 18, kn(row.solved, row.attempts), { cls: "tgc-ink tgc-num", anchor: "end" });
+    if (layout.cost) {
+      const billed = row.cost.perSolvedUsd !== null && row.cost.basis === "receipts";
+      marks += text(costRight, y + 18, costText(row.cost, row.solved), {
+        cls: billed ? "tgc-ink tgc-num" : "tgc-ink-muted tgc-num",
+        anchor: "end"
+      });
+    }
+    if (layout.median) {
+      marks += text(WIDE, y + 18, row.medianWallMs === null ? "unknown" : duration(row.medianWallMs), {
+        cls: row.medianWallMs === null ? "tgc-ink-muted tgc-num" : "tgc-ink tgc-num",
+        anchor: "end"
+      });
+    }
+    body += titled(hoverText(row), marks);
+    if (i < rows.length - 1) body += line(0, y + h, WIDE, y + h, "tgc-rule");
+    y += h;
+  }
+  const bottom = y;
+  let grid = "";
+  if (rows.some((r) => drawable(r.estimate))) {
+    for (const t of TICKS) grid += line(x0 + t * (x1 - x0), top - 4, x0 + t * (x1 - x0), bottom, "tgc-gridline");
+  }
+  let head = text(labelX, 16, capitalize(noun.setup), { cls: "tgc-ink-muted" });
+  head += text(x0, 16, capitalize(o.measure), { cls: "tgc-ink-muted" });
+  head += text(knRight, 16, "Passed", { cls: "tgc-ink-muted", anchor: "end" });
+  if (layout.cost) head += text(costRight, 16, "Per pass", { cls: "tgc-ink-muted", anchor: "end" });
+  if (layout.median) head += text(WIDE, 16, "Median run", { cls: "tgc-ink-muted", anchor: "end" });
+  head += line(0, 26, WIDE, 26, "tgc-rule");
+  let axis = "";
+  if (rows.some((r) => drawable(r.estimate))) {
+    for (const t of TICKS) {
+      axis += text(x0 + t * (x1 - x0), bottom + 16, pct(t), {
+        cls: "tgc-ink-muted tgc-num",
+        anchor: t === 0 ? "start" : t === 1 ? "end" : "middle"
+      });
+    }
+  }
+  return svgRoot(WIDE, bottom + 24, grid + head + body + axis);
+}
+function narrow(rows, layout, o) {
+  const x0 = 0;
+  const x1 = 300;
+  let body = "";
+  let y = 8;
+  for (const [i, row] of rows.entries()) {
+    const labelX = layout.ranked ? 24 : 0;
+    const label = wrap(row.label, NARROW - labelX, 14);
+    let marks = "";
+    if (layout.ranked) marks += text(0, y + 14, String(row.rank), { cls: "tgc-ink-muted tgc-num" });
+    marks += textBlock(label.lines, labelX, y + 14, 18, `class="tgc-ink" font-size="14"`);
+    let cy = y + (label.lines.length - 1) * 18 + 22;
+    if (drawable(row.estimate)) {
+      marks += barMarks(row, x0, x1, cy, o);
+      cy += row.tiers ? 30 : 20;
+    }
+    const facts = [
+      `${kn(row.solved, row.attempts)} passed`,
+      ...drawable(row.estimate) ? [] : [estimateNote(row.estimate, row.attempts)],
+      ...layout.cost && !(row.solved === 0 && row.cost.perSolvedUsd === null) ? [row.cost.perSolvedUsd === null ? "cost unknown" : `${costText(row.cost, row.solved)} per pass`] : [],
+      ...layout.median ? [row.medianWallMs === null ? "run time unknown" : `${duration(row.medianWallMs)} run`] : []
+    ];
+    const factLines = fitLines(facts, NARROW, 12, "mono");
+    marks += textBlock(factLines, 0, cy + 12, 16, `class="tgc-ink-muted tgc-num" font-size="12"`);
+    body += titled(hoverText(row), marks);
+    y = cy + factLines.length * 16 + 4;
+    if (i < rows.length - 1) body += line(0, y + 4, NARROW, y + 4, "tgc-rule");
+    y += 12;
+  }
+  let axis = "";
+  if (rows.some((row) => drawable(row.estimate))) {
+    for (const t of [0, 0.5, 1]) {
+      axis += text(x0 + t * (x1 - x0), y + 4, pct(t), {
+        cls: "tgc-ink-muted tgc-num",
+        anchor: t === 0 ? "start" : t === 1 ? "end" : "middle"
+      });
+    }
+    y += 12;
+  }
+  return svgRoot(NARROW, y, body + axis);
+}
+
+// src/task-matrix.ts
+var TILE = 12;
+var STEP = 14;
+var KIND_LABEL = {
+  S: "S",
+  A: "A",
+  B: "B",
+  C: "C",
+  F: "F",
+  flagged: "flagged",
+  unmeasured: "U, not measured",
+  ungraded: "not graded",
+  solved: "passed",
+  open: "did not pass"
+};
+function tilesOf(cell) {
+  const attempts = cell.attempts ?? 0;
+  if (cell.tiers) {
+    const out = [];
+    for (const tier of TIERS_BEST_FIRST) for (let i = 0; i < cell.tiers[tier]; i++) out.push(tier);
+    for (let i = 0; i < (cell.flagged ?? 0); i++) out.push("flagged");
+    for (let i = 0; i < (cell.unmeasured ?? 0); i++) out.push("unmeasured");
+    while (out.length < attempts) out.push("ungraded");
+    return out;
+  }
+  if (cell.solved !== null) {
+    return [...Array(cell.solved).fill("solved"), ...Array(attempts - cell.solved).fill("open")];
+  }
+  return Array(attempts).fill("ungraded");
+}
+function tile(kind, x, y) {
+  switch (kind) {
+    case "S":
+    case "A":
+    case "B":
+    case "C":
+      return rect(x, y, TILE, TILE, `tgc-tier-${kind.toLowerCase()}`, 'rx="2"');
+    case "solved":
+      return rect(x, y, TILE, TILE, "tgc-bar", 'rx="2"');
+    case "F":
+    case "open":
+      return rect(x + 0.75, y + 0.75, TILE - 1.5, TILE - 1.5, "tgc-open", 'rx="2"');
+    case "flagged":
+      return rect(x + 0.75, y + 0.75, TILE - 1.5, TILE - 1.5, "tgc-open", 'rx="2"') + line(x + 2, y + TILE - 2, x + TILE - 2, y + 2, "tgc-strike");
+    case "unmeasured":
+      return rect(x + 0.75, y + 0.75, TILE - 1.5, TILE - 1.5, "tgc-open tgc-dashed", 'rx="2"');
+    case "ungraded":
+      return rect(x + 0.75, y + 0.75, TILE - 1.5, TILE - 1.5, "tgc-open", 'rx="2"') + circle(x + TILE / 2, y + TILE / 2, 1.5, "tgc-dot");
+  }
+}
+function cellText(cell, means) {
+  if (!cell || (means ? cell.mean === null : cell.attempts === null)) return "\xB7";
+  if (means) return cell.mean.toFixed(2);
+  if (cell.attempts === 0) return "none counted";
+  if (cell.solved !== null) return kn(cell.solved, cell.attempts);
+  if (cell.tiers) return tierSummary(cell.tiers, cell.unmeasured, cell.flagged);
+  return `${cell.attempts}`;
+}
+function describe(task, setup, cell, means) {
+  if (!cell || (means ? cell.mean === null : cell.attempts === null)) return `${task} \xB7 ${setup.label}: not run`;
+  if (means) return `${task} \xB7 ${setup.label}: mean ${cell.mean.toFixed(2)}`;
+  const parts = [`${task} \xB7 ${setup.label}`];
+  if (cell.attempts === 0) parts.push("no attempt counts");
+  else if (cell.solved !== null) parts.push(`${cell.solved} of ${cell.attempts} passed`);
+  else parts.push(`${cell.attempts} ${plural(cell.attempts, "attempt")}`);
+  const tiers = tierSummary(cell.tiers, cell.unmeasured, cell.flagged);
+  if (tiers) parts.push(tiers);
+  if (cell.costUsd !== null) parts.push(usd(cell.costUsd));
+  return parts.join(" \xB7 ").replace(`${setup.label} \xB7 `, `${setup.label}: `);
+}
+function signature(cell) {
+  if (!cell || cell.attempts === null) return "not run";
+  return `${cell.attempts}|${tierSummary(cell.tiers, cell.unmeasured, cell.flagged)}`;
+}
+function taskMatrix(tasks, setupsIn, cells, o = {}) {
+  const id = o.id ?? "task-matrix";
+  const means = o.show === "means";
+  const noun = { task: "task", setup: "setup", attempt: "attempt", ...o.nouns };
+  if (tasks.length === 0 || setupsIn.length === 0) return { id, refused: `No ${noun.task} or no ${noun.setup} to draw.` };
+  const setups = setupsIn.every((s) => s.rank !== null) ? [...setupsIn].sort((a, b) => a.rank - b.rank) : setupsIn;
+  const byKey = /* @__PURE__ */ new Map();
+  for (const cell of cells) {
+    const key = `${cell.task}\0${cell.setup}`;
+    if (!tasks.includes(cell.task) || !setups.some((s) => s.id === cell.setup)) {
+      return { id, refused: `A cell names ${cell.task} \xD7 ${cell.setup}, which is not in the ${noun.task} and ${noun.setup} lists.` };
+    }
+    if (byKey.has(key)) return { id, refused: `Two cells for ${cell.task} \xD7 ${cell.setup}.` };
+    if (!means && cell.attempts !== null) {
+      const graded = tierTotal(cell.tiers) + (cell.flagged ?? 0) + (cell.unmeasured ?? 0);
+      if (graded > cell.attempts || cell.solved !== null && cell.solved > cell.attempts) {
+        return { id, refused: `${cell.task} \xD7 ${cell.setup}: grades or passes exceed its ${cell.attempts} attempts.` };
+      }
+    }
+    byKey.set(key, cell);
+  }
+  const at = (task, setup) => byKey.get(`${task}\0${setup.id}`);
+  const tasksN = `${tasks.length} ${plural(tasks.length, noun.task)}`;
+  let finding;
+  const passRule = cells.some((c) => c.solved !== null);
+  if (means) {
+    const leads = /* @__PURE__ */ new Map();
+    for (const task of tasks) {
+      const scored = setups.map((s) => ({ s, m: at(task, s)?.mean ?? null })).filter((x) => x.m !== null);
+      if (scored.length < 2) continue;
+      const top = Math.max(...scored.map((x) => x.m));
+      const leaders = scored.filter((x) => x.m === top);
+      if (leaders.length === 1) leads.set(leaders[0].s.id, (leads.get(leaders[0].s.id) ?? 0) + 1);
+    }
+    const [leaderId, count] = [...leads.entries()].sort((a, b) => b[1] - a[1])[0] ?? [null, 0];
+    finding = leaderId ? `${setups.find((s) => s.id === leaderId).label} has the highest mean on ${count} of ${tasksN}.` : `No ${noun.setup} has the highest mean on any ${noun.task}.`;
+  } else if (o.agreement && setups.length > 1) {
+    const k = tasks.filter((task) => new Set(setups.map((s) => signature(at(task, s)))).size === 1).length;
+    finding = k === tasks.length ? `Every ${noun.setup} gave the same grades on all ${tasksN}.` : `Every ${noun.setup} gave the same grades on ${k} of ${tasksN}.`;
+  } else if (passRule) {
+    const everywhere = tasks.filter((task) => setups.every((s) => (at(task, s)?.solved ?? 0) > 0)).length;
+    const perSetup = setups.map((s) => ({ s, k: tasks.filter((task) => (at(task, s)?.solved ?? 0) > 0).length }));
+    const most = Math.max(...perSetup.map((x) => x.k));
+    const leaders = perSetup.filter((x) => x.k === most).map((x) => x.s.label);
+    const rest = perSetup.filter((x) => x.k !== most);
+    if (setups.length > 1 && everywhere > 0) {
+      finding = `${everywhere} of ${tasksN} passed at least once for every ${noun.setup}.`;
+    } else if (most === 0) {
+      finding = `No ${noun.task} passed for any ${noun.setup}.`;
+    } else {
+      const tail = rest.length && rest.every((x) => x.k === 0) ? `; ${rest.length === 1 ? rest[0].s.label : `every other ${noun.setup}`} on none` : "";
+      finding = `${listJoin(leaders)} passed at least once on ${most} of ${tasksN}${tail}.`;
+    }
+  } else {
+    const all = cells.reduce(
+      (acc, c) => {
+        for (const t of TIERS_BEST_FIRST) acc.tiers[t] += c.tiers?.[t] ?? 0;
+        acc.u += c.unmeasured ?? 0;
+        acc.f += c.flagged ?? 0;
+        return acc;
+      },
+      { tiers: { S: 0, A: 0, B: 0, C: 0, F: 0 }, u: 0, f: 0 }
+    );
+    const graded = tierTotal(all.tiers) + all.u + all.f;
+    finding = graded ? `${graded} graded ${plural(graded, noun.attempt)}: ${tierSummary(all.tiers, all.u, all.f)}.` : `No ${noun.attempt} in this matrix is graded.`;
+  }
+  const attempts = cells.reduce((s, c) => s + (c.attempts ?? 0), 0);
+  const ran = cells.filter((c) => means ? c.mean !== null : c.attempts !== null).length;
+  const excluded = (o.excluded ?? []).reduce((s, e) => s + e.count, 0);
+  const lede = means ? `${ran} of ${tasks.length * setups.length} cells scored, over ${tasksN} and ${setups.length} ${plural(setups.length, noun.setup)}.` : `${attempts} ${plural(attempts, noun.attempt)} over ${tasksN} and ${setups.length} ${plural(setups.length, noun.setup)}${excluded ? `; ${excluded} more excluded` : ""}.`;
+  const kinds = /* @__PURE__ */ new Set();
+  if (!means) for (const cell of cells) for (const k of tilesOf(cell)) kinds.add(k);
+  const tiered = cells.some((c) => c.tiers !== null);
+  const read = means ? `Each cell is one ${noun.setup}'s mean on one ${noun.task}, printed and drawn as a bar on a shared scale; \xB7 marks a pair never scored.` : tiered ? `One tile per ${noun.attempt}, best first: tiles fill by App Grade tier and an outline is F${o.passTier ? `; ${o.passTier} or better passes` : ""}. Tile order is not run order.` : `One tile per ${noun.attempt}: a filled tile passed and an outline did not. Tile order is not run order.`;
+  const method = means ? `Each cell is the producer's mean score for one ${noun.setup} on one ${noun.task}.` : [
+    tiered ? `Tiles show the App Grade tier of each ${noun.attempt}${o.passTier ? `, and ${o.passTier} or better counts as a pass` : ""}.` : `Filled tiles are the ${plural(2, noun.attempt)} the producer marks solved.`,
+    kinds.has("unmeasured") ? `U marks ${noun.attempt === "attempt" ? "an attempt" : `a ${noun.attempt}`} the grader could not measure.` : "",
+    kinds.has("flagged") ? "A struck tile is a grade that failed an integrity check and awaits human review; it never counts as a pass." : "",
+    kinds.has("ungraded") ? `A dotted outline is ${noun.attempt === "attempt" ? "an attempt" : `a ${noun.attempt}`} with no grade.` : ""
+  ].filter(Boolean).join(" ");
+  const tableHtml = table(
+    `${capitalize(noun.task)} by ${noun.setup}`,
+    [{ label: capitalize(noun.task) }, ...setups.map((s) => ({ label: s.label, numeric: true }))],
+    tasks.map((task) => [
+      task,
+      ...setups.map((s) => {
+        const cell = at(task, s);
+        const main = cellText(cell, means);
+        const extra = !means && cell && cell.solved !== null && cell.tiers ? ` \xB7 ${tierSummary(cell.tiers, cell.unmeasured, cell.flagged)}` : "";
+        const cost = cell && cell.costUsd !== null ? ` \xB7 ${usd(cell.costUsd)}` : "";
+        return main === "\xB7" ? "not run" : `${main}${extra}${cost}`;
+      })
+    ])
+  );
+  const scaleMax = Math.max(1, ...cells.map((c) => c.mean ?? 0));
+  const legendKinds = [...kinds].sort(
+    (a, b) => ["S", "A", "B", "C", "solved", "F", "open", "flagged", "unmeasured", "ungraded"].indexOf(a) - ["S", "A", "B", "C", "solved", "F", "open", "flagged", "unmeasured", "ungraded"].indexOf(b)
+  );
+  return {
+    id,
+    finding,
+    lede,
+    read,
+    svg: {
+      wide: wideMatrix(tasks, setups, at, means, legendKinds, o, scaleMax),
+      narrow: narrowMatrix(tasks, setups, at, means, legendKinds, o, scaleMax)
+    },
+    table: tableHtml,
+    note: {
+      method,
+      n: means ? `${ran} scored cells.` : `${attempts} ${plural(attempts, noun.attempt)} in ${ran} cells.`,
+      exclusions: (o.excluded ?? []).map((e) => `${e.count} ${plural(e.count, noun.attempt)} excluded: ${e.why}.`)
+    }
+  };
+}
+function cellMarks(cell, x, y, width, means, scaleMax = 1) {
+  const label = cellText(cell, means);
+  if (means) {
+    if (!cell || cell.mean === null) return { svg: text(x, y + 16, "\xB7", { cls: "tgc-ink-muted tgc-num" }), h: 24 };
+    const barX = x + 44;
+    const barW = Math.max(0, Math.max(0, cell.mean) / scaleMax * (width - 52));
+    return {
+      svg: text(x, y + 16, label, { cls: "tgc-ink tgc-num" }) + hbar(barX, y + 8, barW, 10, "tgc-bar"),
+      h: 24
+    };
+  }
+  if (!cell || cell.attempts === null || cell.attempts === 0) {
+    return { svg: text(x, y + 16, label, { cls: "tgc-ink-muted tgc-num" }), h: 24 };
+  }
+  const tiles = tilesOf(cell);
+  const labelW = textWidth(label, 12, "mono");
+  const perLine = Math.max(1, Math.floor((width - labelW - 8) / STEP));
+  let svg = "";
+  tiles.forEach((kind, i) => {
+    svg += tile(kind, x + i % perLine * STEP, y + 6 + Math.floor(i / perLine) * STEP);
+  });
+  const lines = Math.ceil(tiles.length / perLine);
+  const labelX = x + Math.min(tiles.length, perLine) * STEP + 4;
+  svg += text(labelX, y + 16, label, { cls: cell.solved === 0 ? "tgc-ink-muted tgc-num" : "tgc-ink tgc-num" });
+  return { svg, h: Math.max(24, lines * STEP + 10) };
+}
+function legend(kinds, width, y, o) {
+  if (kinds.length === 0) return { svg: "", h: 0 };
+  let svg = "";
+  let x = 0;
+  let row = 0;
+  const items = kinds.map((kind) => ({
+    kind,
+    label: KIND_LABEL[kind] + (o.passTier && ["S", "A", "B", "C", "F"].includes(kind) && kind === o.passTier ? " (pass)" : "")
+  }));
+  for (const item of items) {
+    const w = STEP + textWidth(item.label, 12) + 16;
+    if (x > 0 && x + w > width) {
+      x = 0;
+      row += 1;
+    }
+    svg += tile(item.kind, x, y + row * 20 + 2) + text(x + STEP + 2, y + row * 20 + 12, item.label, { cls: "tgc-ink-muted" });
+    x += w;
+  }
+  return { svg, h: (row + 1) * 20 };
+}
+var MIN_COL = 76;
+var GRID_X0 = 208;
+var BLOCK_GAP = 24;
+function wideMatrix(tasks, setups, at, means, kinds, o, scaleMax) {
+  if ((WIDE - GRID_X0) / setups.length < MIN_COL) return blockColumns(tasks, setups, at, means, kinds, o, scaleMax);
+  const labelW = 196;
+  const x0 = GRID_X0;
+  const colW = (WIDE - x0) / setups.length;
+  let head = "";
+  let headH = 0;
+  for (const [j, s] of setups.entries()) {
+    const label = wrap(s.label, colW - 8, 12, "sans", 3);
+    headH = Math.max(headH, label.lines.length * 16);
+    head += titled(s.label, textBlock(label.lines, x0 + j * colW, 14, 16, `class="tgc-ink" font-size="12"`));
+  }
+  let y = headH + 12;
+  head += line(0, y - 4, WIDE, y - 4, "tgc-rule");
+  let body = "";
+  for (const [i, task] of tasks.entries()) {
+    const label = wrap(task, labelW, 12, "sans", 2);
+    let h = label.lines.length * 16 + 8;
+    let marks = "";
+    for (const [j, s] of setups.entries()) {
+      const cell = at(task, s);
+      const m = cellMarks(cell, x0 + j * colW, y, colW - 8, means, scaleMax);
+      h = Math.max(h, m.h);
+      marks += titled(describe(task, s, cell, means), m.svg);
+    }
+    body += titled(task, textBlock(label.lines, 0, y + 16, 16, `class="tgc-ink" font-size="12"`)) + marks;
+    y += h + 4;
+    if (i < tasks.length - 1) body += line(0, y - 2, WIDE, y - 2, "tgc-gridline");
+  }
+  const lg = legend(kinds, WIDE, y + 10, o);
+  return svgRoot(WIDE, y + 10 + lg.h + 4, head + body + lg.svg);
+}
+function setupBlock(tasks, s, at, means, width, scaleMax) {
+  const cellW = 128;
+  const labelW = width - cellW - 8;
+  let y = 0;
+  const head = wrap(s.label, width, 14, "sans-semibold", 2);
+  let svg = textBlock(head.lines, 0, y + 16, 18, `class="tgc-ink" font-size="14" font-weight="600"`);
+  y += head.lines.length * 18 + 8;
+  svg += line(0, y, width, y, "tgc-rule");
+  y += 2;
+  for (const task of tasks) {
+    const label = wrap(task, labelW, 12, "sans", 2);
+    const cell = at(task, s);
+    const m = cellMarks(cell, width - cellW, y, cellW, means, scaleMax);
+    const h = Math.max(label.lines.length * 16 + 8, m.h);
+    svg += titled(describe(task, s, cell, means), textBlock(label.lines, 0, y + 16, 16, `class="tgc-ink" font-size="12"`) + m.svg);
+    y += h + 2;
+  }
+  return { svg, h: y };
+}
+function blockColumns(tasks, setups, at, means, kinds, o, scaleMax) {
+  const width = (WIDE - BLOCK_GAP) / 2;
+  const blocks = setups.map((s) => setupBlock(tasks, s, at, means, width, scaleMax));
+  let body = "";
+  let y = 0;
+  for (let i = 0; i < blocks.length; i += 2) {
+    const pair = blocks.slice(i, i + 2);
+    pair.forEach((b, j) => {
+      body += `<g transform="translate(${j * (width + BLOCK_GAP)} ${y})">${b.svg}</g>`;
+    });
+    y += Math.max(...pair.map((b) => b.h)) + 16;
+  }
+  const lg = legend(kinds, WIDE, y, o);
+  return svgRoot(WIDE, y + lg.h + 4, body + lg.svg);
+}
+function narrowMatrix(tasks, setups, at, means, kinds, o, scaleMax) {
+  let y = 0;
+  let body = "";
+  for (const s of setups) {
+    const b = setupBlock(tasks, s, at, means, NARROW, scaleMax);
+    body += `<g transform="translate(0 ${y})">${b.svg}</g>`;
+    y += b.h + 16;
+  }
+  const lg = legend(kinds, NARROW, y, o);
+  return svgRoot(NARROW, y + lg.h + 4, body + lg.svg);
+}
+
+// src/types.ts
+function isRefusal(value) {
+  return "refused" in value;
+}
+export {
+  breakdown,
+  chartTokensCss,
+  comparisonIntervals,
+  costFrontier,
+  figureCss,
+  isRefusal,
+  rankedRates,
+  renderFigure,
+  renderNotes,
+  renderRefusals,
+  taskMatrix
+};