@cspeach/cli 1.1.28 → 1.1.30

package/dist/register/status-file/register-parts.js

@@ -0,0 +1,509 @@
+// @ts-nocheck
+// GENERATED COPY — do not edit here. Edit viewer/src/lib/register-parts.js,
+// then run `npx tsx scripts/sync-status-file.ts` (prebuild runs it too).
+// src/register/__tests__/status-file-pin.test.ts fails when this copy drifts.
+/**
+ * The marks the page and the status file both draw.
+ *
+ * Two surfaces show one folder: the page a manager opens, and the file a lead
+ * mails to people who will never open a folder in a browser. When the same row
+ * is written out twice it drifts, and these two had already drifted — one lane
+ * table carried a `scope` the other did not, and neither showed the number it
+ * was dividing by. So every mark that belongs to both lives here, once.
+ *
+ * Pure strings in, one string out. No DOM, no clock, no listeners: the status
+ * file is a document on somebody's desktop with no script in it, and it wears
+ * these same strings. That is also why this file knows the model and the map
+ * and nothing else — the page component belongs to the browser.
+ *
+ * Two rules hold everywhere below, as they do on the page: every value that
+ * came out of the folder goes through `esc()`, and colour is a class, never a
+ * style attribute.
+ */
+import { esc, blockSvg, legendHtml, levelLegendHtml, stateWord, LEVEL_BUCKETS as LEVELS, LEVEL_WORD as LEVEL_NAME } from './register-map.js';
+import { activeOf, formatWhen, measurementHistory, notMeasuredCount, provenOf, unknownStateCount, FROM_FILE, } from './register-model.js';
+import { DISPOSITION_ORDER, DISPOSITION_WORD, developerTable, dispositionOf, overlapNote, } from '@cspeach/register-core';
+// The map owns it, because the map's cells need it too; it is offered here as
+// well, where every other shared mark lives.
+export { stateWord };
+/** Digits grouped the way a reader expects: 1,500, not 1500. */
+export const n = (value) => Number(value ?? 0).toLocaleString('en-US');
+/**
+ * As much of a piece of folder text as a table cell can hold.
+ *
+ * Everything below prints text a whole team writes into a shared folder — a
+ * check variant, a scope, a person's name, the name of a file somebody
+ * imported. register-core already keeps 300 characters of a variant and a
+ * scope; 300 characters in a column would still push every other column off a
+ * phone. Cut the RAW text, then escape it: cutting after escaping can slice an
+ * entity in half and leave `&am` on the page.
+ */
+const CELL_TEXT = 120;
+/**
+ * Characters that are not text: zero-width joiners and spaces, the bidirectional
+ * embedding and OVERRIDE controls, the invisible-maths set, and a byte-order
+ * mark. `esc()` cannot help here — they are not markup, they are instructions to
+ * the text engine. One U+202E in a person's name reverses every character after
+ * it, so a line that reads "Clean — measured from a file" on one row can be made
+ * to read backwards on the next, and nothing on screen says why.
+ *
+ * Written as `\u` escapes, never as the characters themselves: a guard against
+ * invisible text cannot be made of invisible text. A reviewer must be able to
+ * see what this class covers, and a merge tool must not be able to lose one of
+ * them silently. Same rule as `cspeach-cli/src/register/atc-file.ts`.
+ */
+const INVISIBLE = /[\u200B-\u200F\u202A-\u202E\u2060-\u2064\uFEFF]/g;
+const short = (value) => {
+    const text = String(value ?? '').replace(INVISIBLE, '');
+    return text.length > CELL_TEXT ? `${text.slice(0, CELL_TEXT)}…` : text;
+};
+/** One value out of the folder, stripped of what is not text, cut to size, and escaped. */
+export const cell = (value) => esc(short(value));
+/** A count of objects a person can read: a whole number, none of it negative. */
+const whole = (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0;
+/** The three types, in the words a person says them in. */
+const TYPE_WORDS = { 'clean-core': 'clean core', upgrade: 'upgrade', build: 'build' };
+/**
+ * Whose team project this is, in one line.
+ *
+ * No article. "A build team project" reads as a *build team*, and "An upgrade
+ * team project" is no better — so the type goes in brackets instead, in plain
+ * words. A type this build has never heard of is printed exactly as the folder
+ * wrote it, escaped, rather than bent into a phrase we would be guessing at.
+ *
+ * One sentence for both surfaces, so the page and the file cannot introduce
+ * the same folder two different ways.
+ *
+ * @param {{ type?: string, lead: { name: string } }} project
+ * @param {string} [folderName] omitted → the sentence stops after the lead.
+ *   The status file omits it: its stamp names the folder one line below, and a
+ *   document that says where it came from twice reads like two documents.
+ * @returns {string}
+ */
+export function provenanceLine(project, folderName) {
+    const type = project.type ? (TYPE_WORDS[project.type] ?? esc(project.type)) : '';
+    return `Team project${type ? ` (${type})` : ''}, led by ${esc(project.lead.name)}`
+        + `${folderName ? `, read from the folder ${esc(folderName)}` : ''}.`;
+}
+/**
+ * Who owns something. Raw text — every caller puts it through `esc()`, because
+ * the owner and the lane id both came out of a shared folder.
+ *
+ * An absent owner says itself in words: an empty cell reads as a value somebody
+ * lost rather than as one nobody has set yet.
+ */
+export const ownerLabel = (lane) => (lane ? `${lane.owner} (${lane.id})` : 'nobody yet');
+/**
+ * Who owns what.
+ *
+ * Active sits beside Objects because Proven is counted against active objects,
+ * never against all of them: a retired object is not an unproven one. Without
+ * that column "Proven 2, Objects 4" reads as half done when it is two of three,
+ * and the lead and the manager argue about a number neither of them chose. The
+ * three counts come from register-core, which is also what the terminal uses.
+ *
+ * A lane summary counts states and nothing else, so how much of a lane's proven
+ * work came out of a file has to be counted here, off the objects. `objects` is
+ * optional: a caller that has none gets exactly the table it got before.
+ *
+ * @param {object[]} lanes `register.lanes`
+ * @param {object[]} [objects] `register.objects`
+ * @returns {string}
+ */
+export function lanesTableHtml(lanes, objects) {
+    if (!lanes?.length)
+        return '<p>The lead has not set up lanes yet.</p>';
+    // One pass over the objects, not one per lane: a real estate has 20,000 of
+    // them and ten lanes, and this table is drawn on every render.
+    const fromFile = new Map();
+    for (const o of objects ?? []) {
+        if (o.measuredBasis !== 'file' || (o.state !== 'verified' && o.state !== 'clean'))
+            continue;
+        // Every lane that claims the object, exactly as the lane's own counts are
+        // taken: an object two lanes both claim is proven for both of them, so
+        // "(n from a file)" can never be larger than the Proven it sits beside.
+        for (const id of o.laneOverlap?.length ? o.laneOverlap : [o.lane])
+            fromFile.set(id, (fromFile.get(id) ?? 0) + 1);
+    }
+    const heads = ['Owner', 'Objects', 'Active', 'Proven', 'Open problems', 'Last record']
+        .map((h) => `<th scope="col">${h}</th>`).join('');
+    const provenCell = (l) => {
+        const said = fromFile.get(l.id) ?? 0;
+        return `${n(provenOf(l.byState))}${said ? ` (${n(said)} ${FROM_FILE})` : ''}`;
+    };
+    const row = (l) => `<tr><td>${esc(ownerLabel(l))}</td><td>${n(l.objects)}</td>`
+        + `<td>${n(activeOf(l.objects, l.byState))}</td><td>${provenCell(l)}</td>`
+        + `<td>${n((l.byState?.regressed ?? 0) + (l.byState?.['did-not-hold'] ?? 0))}</td>`
+        + `<td>${esc(formatWhen(l.lastRecordAt))}</td></tr>`;
+    return `<div class="scroller"><table><thead><tr>${heads}</tr></thead>`
+        + `<tbody>${lanes.map(row).join('')}</tbody></table></div>`;
+}
+/**
+ * One thing waiting for a person. The kind becomes a class so the bar beside it
+ * can carry that state's own colour, and nothing else about the kind is used.
+ */
+export const needItemHtml = (item) => `<li class="need k-${esc(item.kind)}"><b>${esc(item.title)}</b><span>${esc(item.detail)}</span></li>`;
+/**
+ * One package as a block of cells.
+ *
+ * `role: 'img'` is for the status file: it carries no script, so nothing there
+ * can open a cell, and a screen reader handed tens of thousands of shapes that
+ * do nothing is worse off than one handed a labelled picture.
+ */
+export const blockFigureHtml = (block, { role, colourBy } = {}) => `<figure data-role="block"><h3>${esc(block.package)}</h3>`
+    + `${blockSvg(block, { ...(role ? { role } : {}), ...(colourBy ? { colourBy } : {}) })}`
+    + `<figcaption>${n(block.objects.length)} object${block.objects.length === 1 ? '' : 's'}</figcaption></figure>`;
+/**
+ * The map itself: the key to the colours, then one block per package.
+ *
+ * A project with nothing in it yet gets a sentence instead. An empty legend
+ * above an empty row of blocks looks like a page that failed to load, and a
+ * lead who has just run `project init` would reasonably think it had.
+ */
+export function mapBodyHtml(register, blocks, { role, colourBy } = {}) {
+    if (!register.totals.objects)
+        return '<p>No objects in scope yet.</p>';
+    // The status file never passes `colourBy`: it prints the state map only.
+    const legend = colourBy === 'level'
+        ? levelLegendHtml(register.totals.byLevel?.now, { retired: register.totals.byState?.retired ?? 0 })
+        : legendHtml(register.totals.byState, { unknown: unknownStateCount(register) });
+    return `${legend}
+      <div class="blocks">${blocks.map((b) => blockFigureHtml(b, { role, colourBy })).join('')}</div>`;
+}
+/**
+ * What was read and what was left out.
+ *
+ * A number a manager cannot see is a number they cannot trust, so nothing here
+ * is rounded away or hidden. The file says it too, and it matters most there:
+ * whoever it was mailed to cannot look in the folder, and an ignored ruling is
+ * a decision somebody made that this picture does not show.
+ *
+ * `tense: 'past'` is for that file. It states a moment that has gone, so it
+ * says what WAS read rather than what is.
+ *
+ * @param {{ files?: number, unreadable?: number, checksum?: string, register?: object }} data
+ * @param {{ tense?: 'present'|'past' }} [opts]
+ * @returns {string}
+ */
+export function readNote({ files = 0, unreadable = 0, checksum, register }, { tense = 'present' } = {}) {
+    const past = tense === 'past';
+    const s = register?.skipped ?? {};
+    const parts = [`${n(files)} files ${past ? 'were read' : 'read'}`];
+    if (unreadable)
+        parts.push(`${n(unreadable)} could not be read${past ? '' : ' yet'}`);
+    if (s.duplicateRecords)
+        parts.push(`${n(s.duplicateRecords)} duplicate${s.duplicateRecords === 1 ? '' : 's'} ignored`);
+    if (s.otherProject)
+        parts.push(`${n(s.otherProject)} from another team project ignored`);
+    if (s.invalidRecords) {
+        parts.push(s.invalidRecords === 1
+            ? `1 file ${past ? 'was' : 'is'} not a status file`
+            : `${n(s.invalidRecords)} files ${past ? 'were' : 'are'} not status files`);
+    }
+    if (s.rulingsNotFromLead)
+        parts.push(`${n(s.rulingsNotFromLead)} ruling${s.rulingsNotFromLead === 1 ? '' : 's'} not from the lead ignored`);
+    if (s.measurementsOtherVariant) {
+        parts.push(`${n(s.measurementsOtherVariant)} measurement${s.measurementsOtherVariant === 1 ? '' : 's'} made with another check variant ignored`);
+    }
+    if (checksum === 'not-checked')
+        parts.push('object list checksum not checked');
+    return parts.join(' · ');
+}
+/* ── What was measured, and what was not ─────────────────────────────────── */
+/**
+ * The one sentence that keeps a file export from reading as a live result.
+ *
+ * Live evidence outranks file evidence, per object: once the system has
+ * measured an object, that object's colour is read from system runs alone. The
+ * file run is still in its history — hiding it would leave a manager looking
+ * for a run they were told about — and this is what it says.
+ */
+const NOT_USED = 'Measured from a file — not used for the state.';
+/**
+ * Nothing looked at this object. The file stayed silent about it and the person
+ * who imported the file said to read silence as clean — so the row says clean
+ * on somebody's judgement, and the page says whose judgement it was.
+ */
+const SILENCE = 'Counted as clean because the file did not mention it.';
+/**
+ * The same silence from a live run: the check finished and never reported the
+ * object. There is no file to have mentioned anything, and saying there was
+ * would send a reader looking for an export nobody made.
+ */
+const SILENCE_RUN = 'Counted as clean because the check run did not report it.';
+const IMPORTER_SAID = 'The person who imported this file told CSPeach that objects the file does not mention are clean.';
+/**
+ * How a run was made, in words. A file is never called plainly "measured".
+ *
+ * A file import carries a check variant only when the person who imported it
+ * vouched for one, and an empty half of this phrase reads as a value somebody
+ * lost rather than as one the file never had. A live run always has a variant.
+ */
+const howMade = (fromFile, variant) => `${fromFile ? FROM_FILE : 'system check'}`
+    + `${variant ? `, ${variant}` : (fromFile ? ', check variant not stated' : '')}`;
+/**
+ * The same, as markup: a file wears a tag, so the eye finds it down a column.
+ * The whole phrase goes inside the tag, variant and all — a pill followed by a
+ * loose comma reads as a comma nobody meant to type.
+ */
+const howMadeHtml = (fromFile, variant) => (fromFile
+    ? `<span class="tag from-file">${esc(howMade(true, short(variant)))}</span>`
+    : esc(howMade(false, short(variant))));
+/**
+ * The id register-core invents when a finding arrives with no readable name of
+ * its own. It is a placeholder, and on screen a placeholder in a Rule column
+ * reads as a rule somebody could go and look up. Say what it is instead.
+ *
+ * The id is written out rather than imported: this module draws marks and knows
+ * the model, and one string is a smaller dependency than a package.
+ */
+const UNNAMED = 'UNNAMED_FINDING';
+export const ruleWord = (rule) => (rule === UNNAMED ? 'a finding with no readable name' : short(rule));
+/**
+ * One cell of the status file's object list.
+ *
+ * The label follows `measuredBasis` — the basis the FIGURE came from — and
+ * never the newest run of any basis. A system run followed by a file export
+ * leaves `openFindings` a live number, and "1 open, from a file" under it would
+ * be the page telling a manager to trust the system less than it should.
+ * `runs` is kept in the signature for callers; nothing here needs it.
+ */
+export function measuredWord(o, runs) {
+    if ((o.lastMeasuredAt ?? null) === null)
+        return 'not measured';
+    return `${n(o.openFindings)} open${o.measuredBasis === 'file' ? ', from a file' : ''}`;
+}
+/** The line under the summary. Empty when every active object has been measured. */
+export function notMeasuredLine(register) {
+    const count = notMeasuredCount(register);
+    if (!count)
+        return '';
+    return `${n(count)} of ${n(register.totals.active)} active object${register.totals.active === 1 ? '' : 's'} `
+        + `${count === 1 ? 'has' : 'have'} never been measured. ${count === 1 ? 'Its' : 'Their'} colour rests on what people said.`;
+}
+/** The evidence panel's measurement block: the two numbers, then every run that covered this object. */
+export function measurementHistoryHtml(o, runs) {
+    const { rows, more } = measurementHistory(o, runs);
+    if (!rows.length) {
+        return '<p class="unmeasured" data-role="not-measured"><b>Not measured.</b> Nobody has run a check on this object yet, so its colour rests on what people said.</p>';
+    }
+    // `counted` comes from the register, which is where that rule lives. Working
+    // it out again here would be a second copy of it, free to drift.
+    const note = (r) => [
+        // Whose silence it was follows the run this row came from, never the shape
+        // of the row: a live run that reported nothing is not a file that said
+        // nothing, and only one of the two has an export to go and look at.
+        r.evidence === 'absent' ? (r.fromFile ? SILENCE : SILENCE_RUN) : '',
+        r.counted ? '' : NOT_USED,
+    ].filter(Boolean).map((text) => ` <span class="quiet-note">${text}</span>`).join('');
+    const row = (r) => `<tr><td>${esc(formatWhen(r.at))}</td><td>${cell(r.by)}</td><td>${n(r.open)}</td>`
+        + `<td>${howMadeHtml(r.fromFile, r.variant)}${note(r)}</td></tr>`;
+    return `<p><b>Measured:</b> ${n(o.openFindings)} open now, ${n(o.baselineFindings)} at the start. Last measured ${esc(formatWhen(o.lastMeasuredAt))}.</p>`
+        + `<div class="scroller" data-role="history"><table aria-label="Every measurement of ${cell(o.name)}">`
+        + '<thead><tr><th scope="col">When</th><th scope="col">By</th><th scope="col">Open</th><th scope="col">How</th></tr></thead>'
+        + `<tbody>${rows.map(row).join('')}</tbody></table></div>`
+        + (more ? `<p class="quiet-note">and ${n(more)} earlier ${more === 1 ? 'measurement' : 'measurements'}</p>` : '');
+}
+/**
+ * What a run was asked for and did not measure, and — only when it adds up —
+ * what became of those objects.
+ *
+ * "Not measured" is one number with four meanings, and a lead chasing the gap
+ * needs to know whether to look at the export, at the run, at an error or at
+ * the object's own type. But a breakdown that does not account for the whole
+ * gap is worse than none: a reader adds the parts, gets a different number, and
+ * stops believing the table. So the parts are printed only when they sum to
+ * exactly `asked − measured` and every one of them is a whole number — a folder
+ * can say `absent: 999`, and then the gap stands on its own.
+ *
+ * The gap itself is printed only when both numbers are whole: "3.5 not
+ * measured" is not a count of objects.
+ */
+function gapOf(c) {
+    if (!c || !whole(c.asked) || !whole(c.measured) || c.asked <= c.measured)
+        return { missed: '', why: '' };
+    const gap = c.asked - c.measured;
+    const named = [
+        ['absent', 'the run never mentioned'],
+        ['notRun', 'the run never reached'],
+        ['failed', 'failed'],
+        ['unsupported', 'of a type this check cannot reach'],
+    ].filter(([key]) => c[key] !== undefined && c[key] !== null);
+    const adds = named.every(([key]) => whole(c[key])) && named.reduce((t, [key]) => t + c[key], 0) === gap;
+    return {
+        missed: `, ${n(gap)} not measured`,
+        why: adds ? named.filter(([key]) => c[key] > 0).map(([key, word]) => `${n(c[key])} ${word}`).join(' · ') : '',
+    };
+}
+/**
+ * Every measurement that counted, newest first. The page and the status file
+ * both print it.
+ *
+ * The findings column counts OBJECTS WITH FINDINGS, never findings added up
+ * across objects. A run that checks one object at a time gives every finding it
+ * produced to that object, so a finding in a shared include is counted once
+ * under each program that uses it — per object the numbers are right, added up
+ * they are a total that grows and shrinks with the chunking and that nobody on
+ * the team could defend in a meeting.
+ *
+ * An estate with nothing recorded yet is a normal first day, not a team that has
+ * done nothing: the sentence says what to run and what an object that no check
+ * run reports will look like.
+ */
+export function runsTableHtml(runs) {
+    if (!runs?.length) {
+        return '<p>No measurement is recorded yet. A lead or developer connected to SAP can run cspeach team refresh. '
+            + 'Objects stay "not measured" until a check run reports them.</p>';
+    }
+    const row = (r) => {
+        const objects = `${n(r.objects)} object${r.objects === 1 ? '' : 's'}`;
+        const { missed, why } = gapOf(r.coverage);
+        // The NAME of the file, which register-core keeps; never a path, which it
+        // does not. One writer's Downloads folder is not the team's business.
+        const from = r.sourceFile ? ` — ${cell(r.sourceFile)}` : '';
+        // The sentence belongs to the RUN that carries the choice, not to the
+        // table: "this file", printed once under a list of three runs, names none
+        // of them. A run with a note keeps no rule under it, so the note and the
+        // row it belongs to read as one thing.
+        const said = r.absentMeansClean ? `<tr><td colspan="6" class="run-note"><span class="quiet-note">${IMPORTER_SAID}</span></td></tr>` : '';
+        return `<tr${said ? ' class="has-note"' : ''}><td>${esc(formatWhen(r.at))}</td><td>${cell(r.by)}</td><td>${cell(r.scope ?? '')}</td>`
+            + `<td>${objects}${missed}${why ? `<br><span class="quiet-note">${why}</span>` : ''}</td><td>${n(r.withFindings)}</td>`
+            + `<td>${howMadeHtml(r.basis === 'file', r.atcVariant)}${from}</td></tr>${said}`;
+    };
+    return '<div class="scroller"><table aria-label="Measurements"><thead><tr><th scope="col">When</th><th scope="col">By</th><th scope="col">Scope</th>'
+        + '<th scope="col">Covered</th><th scope="col">Objects with findings</th><th scope="col">How</th></tr></thead>'
+        + `<tbody>${[...runs].reverse().map(row).join('')}</tbody></table></div>`;
+}
+/**
+ * The runs nobody folded in, because they were taken with another check
+ * variant. The footer already counts them; a count alone cannot be looked into,
+ * so this says which run, when and by whom — as a list, not a table, because it
+ * is an aside beside the table above and should not read as more measurement.
+ */
+export function ignoredRunsHtml(ignoredRuns) {
+    if (!ignoredRuns?.length)
+        return '';
+    const many = ignoredRuns.length !== 1;
+    const item = (r) => `<li>${esc(formatWhen(r.at))} — ${cell(r.by)}, ${cell(r.atcVariant)}`
+        + `${r.basis === 'file' ? ` <span class="tag from-file">${FROM_FILE}</span>` : ''}`
+        + `${r.sourceFile ? ` — ${cell(r.sourceFile)}` : ''}</li>`;
+    return `<div class="aside" data-role="ignored-runs"><p>Set aside: ${n(ignoredRuns.length)} run${many ? 's were' : ' was'} `
+        + `taken with another check variant, so ${many ? 'they cannot' : 'it cannot'} be compared with this team project.</p>`
+        + `<ul>${ignoredRuns.map(item).join('')}</ul></div>`;
+}
+/* ── Clean core: where it stands, levels, dispositions, per developer ───── */
+const CLASSIFICATION_WORD = { keep: 'keep', fix: 'fix', redesign: 'redesign', retire: 'retire' };
+/**
+ * The word for a decision. A clean-core team project speaks in the five
+ * dispositions (spec §4.2); any other type keeps the classification.
+ *
+ * A classification this build has no word for is printed as the folder wrote
+ * it (the caller escapes it), never as "not decided": somebody DID decide, and
+ * calling it undecided would put the object in a bucket nobody chose.
+ */
+export function decisionWord(decision, projectType) {
+    if (!decision)
+        return 'not decided';
+    if (projectType === 'clean-core') {
+        const d = dispositionOf(decision);
+        if (d)
+            return DISPOSITION_WORD[d];
+    }
+    return CLASSIFICATION_WORD[decision.classification] ?? short(decision.classification);
+}
+const tile = (label, value, note, cls = '') => `<li class="tile${cls ? ` ${cls}` : ''}"><span class="tile-n">${n(value)}</span> <span class="tile-label">${esc(label)}</span> <span class="tile-note">${esc(note)}</span></li>`;
+/**
+ * Five tiles, a number and two lines each, then the two level bars. Every
+ * number comes from register-core's totals — the same ones the terminal and
+ * the workbook print — so nothing here is counted twice.
+ */
+export function whereItStandsHtml(register) {
+    const t = register.totals ?? {};
+    const s = t.byState ?? {};
+    const fromFile = (t.fromFile?.verified ?? 0) + (t.fromFile?.clean ?? 0);
+    const didNotHold = s['did-not-hold'] ?? 0;
+    return '<ul class="tiles" data-role="tiles">'
+        + tile('Decided', t.decided ?? 0, `of ${n(t.objects)} objects`)
+        + tile('Claimed', s.claimed ?? 0, 'a developer says fixed')
+        + tile('Proven', provenOf(s), fromFile ? `${n(fromFile)} of them ${FROM_FILE}` : 'a check run says so')
+        + tile('Did not hold', didNotHold, 'claimed, and the check still finds it', didNotHold ? 'bad' : '')
+        + tile('Retired', s.retired ?? 0, 'nothing left to do')
+        + '</ul>'
+        + (!(t.decided > 0) ? '<p class="empty-note" data-role="nothing-decided">Nothing decided yet. Developers record decisions with /abap-clean-core or cspeach team decide.</p>' : '')
+        + levelBarsHtml(register);
+}
+/**
+ * One bar: the five buckets side by side, then the same thing in words — colour
+ * never stands alone. Segments are paths, not rects: a `rect` on these surfaces
+ * is a map cell, and the budget and the keyboard both count cells by that tag.
+ */
+function levelBar(title, counts) {
+    const total = LEVELS.reduce((sum, l) => sum + (counts?.[l] ?? 0), 0);
+    let x = 0;
+    const rects = total
+        ? LEVELS.map((l) => {
+            const c = counts?.[l] ?? 0;
+            if (!c)
+                return '';
+            const w = (c / total) * 100;
+            const r = `<path class="lvl l-${l}" d="M${x.toFixed(3)} 0h${w.toFixed(3)}v10h-${w.toFixed(3)}z"><title>${esc(`${LEVEL_NAME[l]}: ${c}`)}</title></path>`;
+            x += w;
+            return r;
+        }).join('')
+        : '<path class="lvl l-none" d="M0 0h100v10h-100z"></path>';
+    const words = LEVELS.map((l) => `${LEVEL_NAME[l]} ${n(counts?.[l] ?? 0)}`).join(' · ');
+    return `<figure class="levelbar"><figcaption>${esc(title)}</figcaption>`
+        + `<svg viewBox="0 0 100 10" preserveAspectRatio="none" role="img" aria-label="${esc(`${title}: ${words}`)}">${rects}</svg>`
+        + `<p class="levelwords">${esc(words)}</p></figure>`;
+}
+/** Levels at decision and now, in words as well as colour. A folder with no levels says so. */
+export function levelBarsHtml(register) {
+    const b = register.totals?.byLevel;
+    const none = !b || ['A', 'B', 'C', 'D'].every((l) => !(b.decided?.[l]) && !(b.now?.[l]));
+    return `<div class="levels" data-role="levels">${levelBar('Levels at decision', b?.decided)}${levelBar('Levels now', b?.now)}`
+        + `<p class="legend-line">${none ? 'No levels recorded yet. ' : ''}A level moves only when a check proves the fix.</p></div>`;
+}
+/**
+ * One line of chips; the accepted exceptions open a list of object and reason.
+ * An exception is work nobody has to do, so the reason is the whole of it — and
+ * where there is none, the list says so rather than leaving a blank.
+ */
+export function dispositionsHtml(register) {
+    const d = register.totals?.byDisposition ?? {};
+    const chips = DISPOSITION_ORDER.map((k) => `<li class="chip d-${k}">${esc(DISPOSITION_WORD[k])} <b>${n(d[k] ?? 0)}</b></li>`).join('');
+    const ex = register.objects.filter((o) => dispositionOf(o.decision) === 'exception');
+    const list = !ex.length ? '' : `<details class="exceptions" data-role="exceptions"><summary>${ex.length === 1 ? 'The accepted exception and why' : `The ${n(ex.length)} accepted exceptions and why`}</summary><ul>`
+        + ex.map((o) => `<li><span class="ident">${cell(o.name)}</span> — ${o.decision.reason ? cell(o.decision.reason) : '<span class="quiet-note">no reason recorded</span>'}</li>`).join('')
+        + '</ul></details>';
+    return `<ul class="chips" data-role="dispositions">${chips}</ul>${list}`;
+}
+/**
+ * Who owns what, per developer — register-core's sheet model for the numbers
+ * (the workbook prints the same row), the page's own words for the date.
+ */
+export function developersTableHtml(register) {
+    if (!register.lanes?.length)
+        return '<p>The lead has not set up lanes yet.</p>';
+    const t = developerTable(register);
+    // How much of a lane's Proven came out of a file, said beside the number —
+    // as the lane table always has. One pass over the objects, counted for every
+    // lane that claims one, exactly as register-core counts the lane's Proven.
+    const fromFile = new Map();
+    for (const o of register.objects) {
+        if (o.measuredBasis !== 'file' || (o.state !== 'verified' && o.state !== 'clean'))
+            continue;
+        for (const id of o.laneOverlap?.length ? o.laneOverlap : [o.lane])
+            fromFile.set(id, (fromFile.get(id) ?? 0) + 1);
+    }
+    const provenAt = t.header.indexOf('Proven');
+    const num = (v, col, lane) => {
+        const said = col === provenAt ? fromFile.get(lane.id) ?? 0 : 0;
+        return `<td>${n(v)}${said ? ` (${n(said)} ${FROM_FILE})` : ''}</td>`;
+    };
+    const head = t.header.map((h) => `<th scope="col">${esc(h)}</th>`).join('');
+    const body = t.rows.map((r, i) => `<tr><td>${cell(r[0])}</td>${r.slice(1, -1).map((v, j) => num(v, j + 1, register.lanes[i])).join('')}`
+        + `<td>${esc(formatWhen(register.lanes[i].lastRecordAt))}</td></tr>`).join('');
+    const note = overlapNote(register);
+    return `<div class="scroller"><table><thead><tr>${head}</tr></thead><tbody>${body}</tbody></table></div>`
+        + (note ? `<p class="quiet-note">${esc(note)}</p>` : '');
+}