@tangle-network/charts 0.1.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tangle Network
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -15,6 +15,14 @@ The library draws and never decides.
 Ranks, intervals, frontier membership, estimate labels and pass counts come from the producer: a board record, a VerticalBench report or an agent-eval lens.
 A figure function returns a `Refusal` in place of a figure it cannot draw honestly, for example a bar over too few units, an interval that names no method, or a frontier the producer did not compute.
 
+The producer's `estimate` controls rate marks: `descriptive` draws a rate bar and may show a named Wilson score interval when that estimate meets the producer's unit threshold.
+Task-clustered bootstrap intervals require a `bootstrap` estimate.
+Intervals without support are marked as not drawn in the data table and note.
+A missing, zero, or unproven cost prints `unknown`; zero passes print `no pass`.
+Rank numbers require every row to carry both a rank and a `bootstrap` estimate.
+Malformed rates, intervals, matrix counts, and breakdown counts return a refusal instead of a misleading mark.
+An interval whisker is omitted when its bounds exclude the row's rate.
+
 It has no runtime dependencies and uses no DOM, so it runs in a Worker, a build step or a browser.
 
 ## Use

package/dist/index.d.ts

@@ -194,12 +194,14 @@ declare function comparisonIntervals(rows: ComparisonRow[], setups: Setup[], o:
  * hollow muted circle, and an estimated cost is never a filled disc. An ink
  * line joins frontier points. Every point is labelled directly; a label that
  * collides everywhere becomes a number listed in the table. A setup with no
- * pass or an unknown cost is listed under the axis, never placed at an
- * origin a log axis does not have. On a phone the plot becomes a list sorted
- * by the measure, with the same point marks, a rate bar and the cost as text.
+ * pass, an unknown cost or too few units for a rate is listed under the axis,
+ * never placed: a log axis has no origin, and a point's height is a rate. On a
+ * phone the plot becomes a list in rate order, with the same point marks, a
+ * rate bar and the cost as text.
  *
- * Refuses: the whole figure when fewer than two setups have a cost per pass; the frontier line unless two or more rows carry `onFront: true` (it
- * never computes dominance itself).
+ * Refuses: the whole figure when fewer than two setups have both a cost per
+ * pass and enough units for a rate; the frontier line unless two or more
+ * plotted rows carry `onFront: true` (it never computes dominance itself).
  */
 
 interface CostFrontierOptions {
@@ -214,14 +216,22 @@ declare const figureCss: string;
 /** --chart-* resolved per theme, for documents without brand tokens: light, dark by preference or [data-theme="dark"], light in print. */
 declare const chartTokensCss: string;
 
+/**
+ * The order rows are drawn in. Ranked rows keep their rank. Otherwise rows
+ * with enough units to draw a rate come first, highest rate first; rows with
+ * too few units follow, most units first, so a 1/1 row never heads the list.
+ */
+declare function rateOrder<T extends Pick<RateRow, "rank" | "rate" | "estimate" | "attempts">>(rows: readonly T[]): T[];
+
 /**
  * `rankedRates`: which setup passes most, and how uncertain is each rate.
  *
  * One row per setup: rank (only when every row is ranked), label, an accent
- * bar on a shared 0–1 axis with the interval as an ink whisker, `passed/n`,
+ * bar on a shared 0–1 axis with an eligible interval as an ink whisker, `passed/n`,
  * cost per pass and median run. An App Grade grader adds a tier strip under
- * the bar with a tick at the pass tier. Ranked rows keep their rank order;
- * unranked rows sort by rate, and the finding says no comparison backs it.
+ * the bar with a tick at the pass tier. Bootstrap rows with ranks keep their order;
+ * unranked rows sort by rate, rows with too few units last, and the finding
+ * says no comparison backs the order.
  *
  * Refuses: a bar when the producer labels the estimate `none` or
  * `insufficient` (the row prints its count only); a whisker whose interval
@@ -278,4 +288,4 @@ interface TaskMatrixOptions {
 }
 declare function taskMatrix(tasks: string[], setupsIn: Setup[], cells: MatrixCell[], o?: TaskMatrixOptions): Figure | Refusal;
 
-export { type BreakdownInput, type BreakdownOptions, type ComparisonIntervalsOptions, type ComparisonRow, type CostBasis, type CostFrontierOptions, type Estimate, type Exclusion, type Figure, type Interval, type IntervalMethod, type MatrixCell, type RankedRatesOptions, type RateRow, type Refusal, type Setup, type TaskMatrixOptions, type Tier, type TierCounts, breakdown, chartTokensCss, comparisonIntervals, costFrontier, figureCss, isRefusal, rankedRates, renderFigure, renderNotes, renderRefusals, taskMatrix };
+export { type BreakdownInput, type BreakdownOptions, type ComparisonIntervalsOptions, type ComparisonRow, type CostBasis, type CostFrontierOptions, type Estimate, type Exclusion, type Figure, type Interval, type IntervalMethod, type MatrixCell, type RankedRatesOptions, type RateRow, type Refusal, type Setup, type TaskMatrixOptions, type Tier, type TierCounts, breakdown, chartTokensCss, comparisonIntervals, costFrontier, figureCss, isRefusal, rankedRates, rateOrder, renderFigure, renderNotes, renderRefusals, taskMatrix };

package/dist/index.js

@@ -367,16 +367,22 @@ 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.` };
+  for (const setup of setups) {
+    if (setup.n !== null && (!Number.isInteger(setup.n) || setup.n < 0)) return { id, refused: `${setup.label}: invalid denominator.` };
+  }
   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 key = `${c.reason}\0${c.setup}`;
+    if (count.has(key)) return { id, refused: `Two counts for ${c.reason} \xD7 ${c.setup}.` };
+    if (c.count !== null && (!Number.isInteger(c.count) || c.count < 0)) return { id, refused: `${c.reason} \xD7 ${c.setup}: invalid count.` };
     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);
+    count.set(key, c.count);
   }
   const get = (reason, setup) => count.get(`${reason}\0${setup}`) ?? null;
   const withN = setups.filter((s) => s.n !== null);
@@ -487,6 +493,9 @@ 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.method in METHOD_NAME)) return "the interval method is unknown";
+  if (!Number.isFinite(interval.level) || interval.level <= 0 || interval.level >= 1) return "the interval level is outside 0\u20131";
+  if (!Number.isFinite(interval.lower) || !Number.isFinite(interval.upper)) return "the interval bounds are not finite";
   if (!(interval.lower <= interval.upper)) return "the interval bounds are out of order";
   return null;
 }
@@ -498,9 +507,47 @@ function estimateNote(estimate, units) {
   if (estimate === "insufficient") return "too few units";
   return "";
 }
+function perPass(cost) {
+  return cost.basis !== "unknown" && cost.perSolvedUsd !== null && Number.isFinite(cost.perSolvedUsd) && cost.perSolvedUsd > 0 ? cost.perSolvedUsd : null;
+}
 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.`;
+  if (solved === 0) return "no pass";
+  const value = perPass(cost);
+  if (value === null) return "unknown";
+  return cost.basis === "receipts" ? usd(value) : `${usd(value)} est.`;
+}
+function rateIntervalGap(row) {
+  if (!drawable(row.estimate)) return `${row.estimate} estimate`;
+  if (!Number.isFinite(row.rate) || row.rate < 0 || row.rate > 1) return "rate is outside 0\u20131";
+  const gap = intervalGap(row.interval);
+  if (gap) return gap;
+  if (row.interval.method === "mcnemar-exact") return "exact McNemar applies to paired comparisons, not rates";
+  if (row.estimate === "descriptive" && row.interval.method !== "wilson") {
+    return `descriptive estimate does not support ${intervalName(row.interval)}`;
+  }
+  if (row.interval.lower < 0 || row.interval.upper > 1) return "the rate interval is outside 0\u20131";
+  if (row.rate < row.interval.lower - 1e-6 || row.rate > row.interval.upper + 1e-6) {
+    return "the rate falls outside its interval";
+  }
+  return null;
+}
+function rateDataGap(row) {
+  if (!Number.isInteger(row.attempts) || row.attempts < 0 || !Number.isInteger(row.solved) || row.solved < 0 || row.solved > row.attempts) {
+    return "passed and attempt counts are invalid";
+  }
+  if (!Number.isFinite(row.rate) || row.rate < 0 || row.rate > 1) return "rate is outside 0\u20131";
+  if (row.attempts > 0 && Math.abs(row.rate - row.solved / row.attempts) > 1e-6) return "rate disagrees with passed/attempts";
+  if (row.attempts === 0 && row.rate !== 0) return "rate has no attempts";
+  if (drawable(row.estimate) && row.attempts === 0) return "drawable estimate has no attempts";
+  return null;
+}
+function rateOrder(rows) {
+  if (rows.length > 0 && rows.every((row) => row.rank !== null && row.estimate === "bootstrap")) {
+    return [...rows].sort((a, b) => a.rank - b.rank);
+  }
+  const drawn = rows.filter((row) => drawable(row.estimate)).sort((a, b) => b.rate - a.rate);
+  const counted = rows.filter((row) => !drawable(row.estimate)).sort((a, b) => b.attempts - a.attempts);
+  return [...drawn, ...counted];
 }
 function tierSummary(tiers, unmeasured = 0, flagged = 0) {
   const parts = tiers ? TIERS_BEST_FIRST.filter((t) => tiers[t] > 0).map((t) => `${tiers[t]}${t}`) : [];
@@ -575,8 +622,14 @@ function gaps(row) {
   const out = [];
   const gap = intervalGap(row.interval);
   if (gap) out.push(gap);
+  if (row.exactInterval !== null) {
+    const exactGap = intervalGap(row.exactInterval);
+    if (exactGap) out.push(`exact interval: ${exactGap}`);
+  }
   if (row.pairs === null) out.push("no pair count");
+  else if (!Number.isInteger(row.pairs) || row.pairs <= 0) out.push("invalid pair count");
   if (row.minimumEffect === null) out.push("no registered minimum effect");
+  else if (!Number.isFinite(row.minimumEffect)) out.push("invalid registered minimum effect");
   return out;
 }
 function comparisonIntervals(rows, setups, o) {
@@ -594,7 +647,7 @@ function comparisonIntervals(rows, setups, o) {
   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("; ")}.`
+      refused: rows.every((r) => r.interval === null) ? `${rows.length} ${plural(rows.length, "comparison")} listed; none carries an interval.` : `No comparison can be drawn. ${refused.join("; ")}.`
     };
   }
   const clears = drawn.filter(
@@ -615,20 +668,20 @@ function comparisonIntervals(rows, setups, o) {
     { 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 fmt = (i, n) => i && intervalGap(i) === null ? `${pts(i.lower)} to ${pts(i.upper)} (${intervalName(i)}, n=${n})` : i ? `not drawn (${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)
+    fmt(row.interval, row.pairs),
+    fmt(row.exactInterval, row.pairs)
   ]);
   const values = drawn.flatMap(({ row }) => [
     row.interval.lower,
     row.interval.upper,
     row.minimumEffect,
     0,
-    ...row.exactInterval ? [row.exactInterval.lower, row.exactInterval.upper] : []
+    ...intervalGap(row.exactInterval) === null ? [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];
@@ -678,7 +731,7 @@ function draw(drawn, domain, width, plotX, labelW) {
     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)}`,
+      `${title} \xB7 ${row.pairs} pairs \xB7 ${intervalName(row.interval)} interval ${pts(row.interval.lower)} to ${pts(row.interval.upper)}${rateExactTitle(row)} \xB7 minimum effect ${pts(row.minimumEffect)}`,
       marks
     );
   }
@@ -689,57 +742,94 @@ function draw(drawn, domain, width, plotX, labelW) {
   }
   return svgRoot(width, y + 24, axis + body);
 }
+function rateExactTitle(row) {
+  return intervalGap(row.exactInterval) === null ? ` \xB7 ${intervalName(row.exactInterval)} exact interval ${pts(row.exactInterval.lower)} to ${pts(row.exactInterval.upper)}` : "";
+}
 
 // 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 crosses(box, a, b) {
+  const [dx, dy] = [b[0] - a[0], b[1] - a[1]];
+  let t0 = 0;
+  let t1 = 1;
+  for (const [p, q] of [
+    [-dx, a[0] - box.x0],
+    [dx, box.x1 - a[0]],
+    [-dy, a[1] - box.y0],
+    [dy, box.y1 - a[1]]
+  ]) {
+    if (p === 0) {
+      if (q < 0) return false;
+      continue;
+    }
+    const t = q / p;
+    if (p < 0) t0 = Math.max(t0, t);
+    else t1 = Math.min(t1, t);
+    if (t0 > t1) return false;
+  }
+  return true;
+}
+var plottable = (row) => row.solved > 0 && perPass(row.cost) !== null && drawable(row.estimate);
+function unplacedReason(row) {
+  if (row.solved === 0) return "0 passed";
+  if (!drawable(row.estimate)) return estimateNote(row.estimate, row.attempts);
+  return "cost unknown";
+}
 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.` };
+  for (const row of rows) {
+    const gap = rateDataGap(row);
+    if (gap) return { id, refused: `${row.label}: ${gap}.` };
+  }
+  const costed = rows.filter(plottable);
+  const unplaced = rateOrder(rows.filter((row) => !plottable(row)));
+  if (!rows.some((row) => row.solved > 0 && perPass(row.cost) !== null)) 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)}.`
+      refused: `Fewer than two setups have both a cost per pass and enough units for a rate (${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 cost = (row) => perPass(row.cost);
+  const cheapestFront = [...front].sort((a, b) => cost(a) - cost(b))[0];
+  const top = rateOrder(rows)[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}.`;
+  if (cheapestFront && costed.includes(top) && cheapestFront.id !== top.id) {
+    const saving = 1 - cost(cheapestFront) / cost(top);
+    finding = `${cheapestFront.label} costs ${usd(cost(cheapestFront))} 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 cheapest = [...costed].sort((a, b) => cost(a) - cost(b))[0];
+    finding = `${cheapest.label} has the lowest cost per pass, ${usd(cost(cheapest))}${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 lede = `${costed.length} of ${rows.length} setups are plotted; ` + (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 = `Higher ${o.measure} and lower cost per pass are better; on the wide plot, better is up and right.` + (drawLine ? " Filled points sit on the frontier; the line joins them." : "") + (costed.some((r) => r.onFront && r.cost.basis !== "receipts") ? " A hollow accent ring is a frontier point with an estimated cost." : "");
+  const intervals = [...new Set(costed.filter((r) => rateIntervalGap(r) === 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.",
+    front.length ? "The frontier is the producer's: no setup off it is both cheaper and higher." : "The producer did not compute a frontier.",
     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: "Interval" },
     { label: "Cost per pass", numeric: true },
     { label: "Cost basis" },
     { label: "On frontier" }
   ];
-  const sorted = [...rows].sort((a, b) => b.rate - a.rate);
+  const sorted = rateOrder(rows);
   const tableRows = sorted.map((row) => [
     row.label,
-    pct(row.rate),
+    drawable(row.estimate) ? pct(row.rate) : estimateNote(row.estimate, row.attempts),
     kn(row.solved, row.attempts),
+    rateIntervalGap(row) === null ? `${pct(row.interval.lower)}\u2013${pct(row.interval.upper)} (${intervalName(row.interval)}, n=${row.attempts})` : `not drawn (${rateIntervalGap(row)})`,
     costText(row.cost, row.solved),
     row.cost.basis,
     row.onFront === null ? "not computed" : row.onFront ? "yes" : "no"
@@ -760,7 +850,10 @@ function costFrontier(rows, o) {
     note: {
       method,
       n: `${rows.reduce((s, r) => s + r.attempts, 0)} attempts over ${rows.length} setups.`,
-      exclusions: unplaced.length ? [`Not placed: ${unplacedText(unplaced)}.`] : []
+      exclusions: [
+        ...unplaced.length ? [`Not placed: ${unplacedText(unplaced)}.`] : [],
+        ...costed.filter((r) => rateIntervalGap(r) !== null).map((r) => `No interval for ${r.label}: ${rateIntervalGap(r)}.`)
+      ]
     }
   };
 }
@@ -769,7 +862,7 @@ function narrowList(rows) {
   let out = "";
   let y = 4;
   for (const [i, row] of rows.entries()) {
-    const placed = row.cost.perSolvedUsd !== null && row.cost.perSolvedUsd > 0;
+    const placed = plottable(row);
     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"`);
@@ -777,7 +870,7 @@ function narrowList(rows) {
     if (drawable(row.estimate)) {
       let end = row.rate * x1;
       marks += hbar(0, cy, end, 10, "tgc-bar");
-      if (intervalGap(row.interval) === null) {
+      if (rateIntervalGap(row) === 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");
@@ -787,10 +880,12 @@ function narrowList(rows) {
       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 reason = row.solved > 0 && drawable(row.estimate) ? "cost unknown \xB7 " : "";
+    const fact = placed ? `${count} \xB7 ${costText(row.cost, row.solved)} per pass${row.onFront ? " \xB7 on the frontier" : ""}` : `${count} \xB7 ${reason}not plotted`;
     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);
+    const interval = rateIntervalGap(row) === null ? ` \xB7 ${intervalName(row.interval)} interval ${pct(row.interval.lower)}\u2013${pct(row.interval.upper)}, n=${row.attempts}` : "";
+    out += titled(`${row.label} \xB7 ${fact}${interval}`, marks);
     y = cy + 4 + facts.length * 16;
     if (i < rows.length - 1) out += line(0, y + 2, NARROW, y + 2, "tgc-rule");
     y += 10;
@@ -804,19 +899,25 @@ function narrowList(rows) {
   return svgRoot(NARROW, y, out);
 }
 function unplacedText(rows) {
-  return listJoin(rows.map((r) => `${r.label}, ${r.solved === 0 ? "0 passed" : "cost unknown"}`));
+  return listJoin(rows.map((r) => `${r.label} (${unplacedReason(r)})`));
 }
 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 costs = costed.map((r) => perPass(r.cost));
   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);
+  const highest = Math.max(
+    ...costed.map((r) => Math.max(r.rate, rateIntervalGap(r) === null ? r.interval.upper : 0))
+  );
+  const yMax = Math.min(1, Math.max(0.2, Math.ceil(highest * 5 - 1e-9) / 5));
+  const yStep = yMax <= 0.4 ? 0.1 : 0.2;
+  const y = (v) => bottom - v / yMax * (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]) {
+  for (let i = 0; i <= Math.round(yMax / yStep); i++) {
+    const v = Number((i * yStep).toFixed(10));
     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" });
   }
@@ -830,22 +931,20 @@ function plot(costed, unplaced, drawLine, o) {
   });
   const placed = costed.map((row) => ({
     row,
-    x: x(row.cost.perSolvedUsd),
+    x: x(perPass(row.cost)),
     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");
-  }
+  const frontLine = drawLine ? placed.filter((p) => p.row.onFront).sort((a, b) => a.x - b.x).map((p) => [p.x, p.y]) : [];
+  if (drawLine) out += polyline(frontLine, "tgc-front-line");
   for (const p of placed) {
-    if (intervalGap(p.row.interval) === null) {
+    if (rateIntervalGap(p.row) === 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) {
+    if (rateIntervalGap(p.row) === null) {
       obstacles.push({ x0: p.x - 2, y0: y(p.row.interval.upper), x1: p.x + 2, y1: y(p.row.interval.lower) });
     }
   }
@@ -869,7 +968,8 @@ function plot(costed, unplaced, drawLine, o) {
       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;
+      const onLine = frontLine.some((a, i) => i > 0 && crosses(box, frontLine[i - 1], a));
+      if (!inside || onLine || 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 }));
@@ -885,7 +985,7 @@ function plot(costed, unplaced, drawLine, o) {
   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" : ""}`,
+      `${p.row.label} \xB7 ${pct(p.row.rate)} ${o.measure} \xB7 ${kn(p.row.solved, p.row.attempts)} passed \xB7 ${costText(p.row.cost, p.row.solved)} per pass${rateIntervalGap(p.row) === null ? ` \xB7 ${intervalName(p.row.interval)} interval ${pct(p.row.interval.lower)}\u2013${pct(p.row.interval.upper)}, n=${p.row.attempts}` : ""}${p.row.onFront ? " \xB7 on the frontier" : ""}`,
       circle(p.x, p.y, 4, cls)
     );
   }
@@ -1207,36 +1307,44 @@ function rankedRates(input, o) {
   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 gap = rateDataGap(row);
+    if (gap) return { id, refused: `${row.label}: ${gap}.` };
+    if (row.tiers) {
+      if (TIERS_BEST_FIRST.some((tier) => !Number.isInteger(row.tiers[tier]) || row.tiers[tier] < 0)) {
+        return { id, refused: `${row.label}: tier counts must be nonnegative whole numbers.` };
+      }
+      if (tierTotal(row.tiers) > row.attempts) return { id, refused: `${row.label}: tier counts exceed attempts.` };
+      if (o.passTier) {
+        const passing = TIERS_BEST_FIRST.filter((tier) => tierAtLeast(tier, o.passTier)).reduce((sum, tier) => sum + row.tiers[tier], 0);
+        if (passing !== row.solved) return { id, refused: `${row.label}: ${row.solved} passes disagree with ${passing} grades at ${o.passTier} or better.` };
+      }
     }
   }
-  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 ranked = input.every((row) => row.rank !== null && row.estimate === "bootstrap");
+  const rows = rateOrder(input);
   const layout = {
     ranked,
-    cost: rows.some((r) => r.cost.perSolvedUsd !== null || r.cost.basis !== "unknown" || r.cost.receipts !== null),
+    cost: rows.some((r) => perPass(r.cost) !== 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 whiskers = bars.filter((row) => rateIntervalGap(row) === null);
+  const noWhisker = bars.filter((row) => rateIntervalGap(row) !== 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 uniqueTop = bars.length === 1 || bars.length > 1 && bars[1].rate < top.rate;
+  const finding = ranked ? `${top.label} ranks first, passing ${pct(top.rate)} of ${plural(2, noun.attempt)}.` : bars.length === 0 ? `No ${noun.setup} has enough units to draw a ${o.measure}.` : rows.length === 1 ? `${top.label} passes ${pct(top.rate)} of ${top.attempts} ${plural(top.attempts, noun.attempt)}.` : 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 && bars.length ? ` ${noBar.length} of ${setupsN} have too few units to draw a rate; they come last.` : "");
   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 bases = [...new Set(rows.filter((r) => perPass(r.cost) !== 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}.` : "",
@@ -1246,7 +1354,7 @@ function rankedRates(input, o) {
   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(", ")}.`] : []
+    ...noWhisker.length ? [`No whisker for ${noWhisker.map((r) => `${r.label} (${rateIntervalGap(r)})`).join(", ")}.`] : []
   ];
   const columns = [
     { label: capitalize(noun.setup) },
@@ -1267,7 +1375,7 @@ function rankedRates(input, o) {
       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",
+      rateIntervalGap(row) === null ? `${pct(row.interval.lower)}\u2013${pct(row.interval.upper)} (${intervalName(row.interval)}, n=${row.attempts})` : `not drawn (${rateIntervalGap(row)})`,
       ...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)] : []
@@ -1297,7 +1405,7 @@ function barMarks(row, x0, x1, y, o) {
   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) {
+  if (row.interval && rateIntervalGap(row) === null) {
     const lo = at(row.interval.lower);
     const hi = at(row.interval.upper);
     out += line(lo, y + 6, hi, y + 6, "tgc-whisker");
@@ -1329,11 +1437,11 @@ function hoverText(row) {
     `${kn(row.solved, row.attempts)} passed`,
     drawable(row.estimate) ? pct(row.rate) : estimateNote(row.estimate, row.attempts)
   ];
-  if (row.interval && intervalGap(row.interval) === null) {
+  if (row.interval && rateIntervalGap(row) === 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`);
+  if (perPass(row.cost) !== null) parts.push(`${costText(row.cost, row.solved)} per pass`);
   return parts.join(" \xB7 ");
 }
 function wide2(rows, layout, noun, o) {
@@ -1356,7 +1464,7 @@ function wide2(rows, layout, noun, o) {
     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";
+      const billed = perPass(row.cost) !== 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"
@@ -1413,7 +1521,7 @@ function narrow(rows, layout, o) {
     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.cost && !(row.solved === 0 && perPass(row.cost) === null) ? [perPass(row.cost) === 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");
@@ -1503,7 +1611,7 @@ function describe(task, setup, cell, means) {
   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));
+  if (cell.costUsd !== null) parts.push(cell.costUsd > 0 ? usd(cell.costUsd) : "cost unknown");
   return parts.join(" \xB7 ").replace(`${setup.label} \xB7 `, `${setup.label}: `);
 }
 function signature(cell) {
@@ -1523,11 +1631,26 @@ function taskMatrix(tasks, setupsIn, cells, o = {}) {
       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}.` };
+    const counts = [cell.attempts, cell.solved, cell.unmeasured, cell.flagged];
+    if (counts.some((n) => n !== null && n !== void 0 && (!Number.isInteger(n) || n < 0))) {
+      return { id, refused: `${cell.task} \xD7 ${cell.setup}: counts must be nonnegative whole numbers.` };
+    }
+    if (cell.tiers && TIERS_BEST_FIRST.some((tier) => !Number.isInteger(cell.tiers[tier]) || cell.tiers[tier] < 0)) {
+      return { id, refused: `${cell.task} \xD7 ${cell.setup}: tier counts must be nonnegative whole numbers.` };
+    }
+    if (cell.mean !== null && !Number.isFinite(cell.mean)) return { id, refused: `${cell.task} \xD7 ${cell.setup}: mean is not finite.` };
+    if (cell.costUsd !== null && (!Number.isFinite(cell.costUsd) || cell.costUsd < 0)) {
+      return { id, refused: `${cell.task} \xD7 ${cell.setup}: cost is invalid.` };
+    }
     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.` };
       }
+      if (o.passTier && cell.tiers && cell.solved !== null) {
+        const passing = TIERS_BEST_FIRST.filter((tier) => tierAtLeast(tier, o.passTier)).reduce((sum, tier) => sum + cell.tiers[tier], 0);
+        if (passing !== cell.solved) return { id, refused: `${cell.task} \xD7 ${cell.setup}: ${cell.solved} passes disagree with ${passing} grades at ${o.passTier} or better.` };
+      }
     }
     byKey.set(key, cell);
   }
@@ -1599,7 +1722,7 @@ function taskMatrix(tasks, setupsIn, cells, o = {}) {
         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)}` : "";
+        const cost = cell && cell.costUsd !== null ? ` \xB7 ${cell.costUsd > 0 ? usd(cell.costUsd) : "cost unknown"}` : "";
         return main === "\xB7" ? "not run" : `${main}${extra}${cost}`;
       })
     ])
@@ -1764,6 +1887,7 @@ export {
   figureCss,
   isRefusal,
   rankedRates,
+  rateOrder,
   renderFigure,
   renderNotes,
   renderRefusals,

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@tangle-network/charts",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Benchmark figures as static SVG and HTML tables: ranked rates, cost frontier, comparison intervals, task matrix and breakdown. Draws from producer data and refuses what it cannot draw honestly.",
   "type": "module",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/tangle-network/brand",
+    "url": "git+https://github.com/tangle-network/brand.git",
     "directory": "packages/charts"
   },
   "bugs": {
@@ -28,10 +28,6 @@
     },
     "./figure.css": "./dist/figure.css"
   },
-  "scripts": {
-    "gen:css": "node scripts/gen-css.mjs",
-    "build": "node scripts/gen-css.mjs --check && tsup src/index.ts --format esm --dts --clean && cp src/figure.css dist/figure.css"
-  },
   "devDependencies": {
     "tsup": "^8.3.5",
     "typescript": "^5.6.0"
@@ -41,5 +37,9 @@
     "charts",
     "benchmarks",
     "svg"
-  ]
-}
+  ],
+  "scripts": {
+    "gen:css": "node scripts/gen-css.mjs",
+    "build": "node scripts/gen-css.mjs --check && tsup src/index.ts --format esm --dts --clean && cp src/figure.css dist/figure.css"
+  }
+}