@pipeline-builder/pipeline-data 4.1.23 → 4.1.25

package/lib/api/reporting/stakeholder/report-html.js

@@ -0,0 +1,208 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/** HTML-escape. Applied at every insertion point; see the file header. */
+function esc(value) {
+    return String(value ?? '')
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+/** A date as a plain calendar day, in UTC, or `—` when absent. */
+function day(iso) {
+    if (!iso)
+        return '—';
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime()))
+        return '—';
+    return d.toISOString().slice(0, 10);
+}
+/**
+ * The trend, IN WORDS.
+ *
+ * "down 3 points" rather than a red arrow, because the arrow is the whole fact for a
+ * section whose headline barely moved, and an arrow is invisible to a screen reader and
+ * ambiguous in greyscale. `unknown` renders nothing at all rather than "flat" — a section
+ * with no comparable previous period has not held steady, we just cannot say.
+ */
+export function trendSentence(section) {
+    const { change, headline } = section;
+    if (!change || change.direction === 'unknown')
+        return null;
+    const unit = headline?.unit === '%' ? 'points' : null;
+    const magnitude = Math.abs(change.absolute);
+    if (change.direction === 'flat')
+        return 'unchanged from the previous period';
+    const word = change.direction === 'up' ? 'up' : 'down';
+    const pct = change.percent !== null && change.percent !== undefined
+        ? ` (${change.percent > 0 ? '+' : ''}${change.percent}%)`
+        : '';
+    return `${word} ${magnitude}${unit ? ` ${unit}` : ''}${pct} from the previous period`;
+}
+/**
+ * One section as a table row.
+ *
+ * A TABLE, not a grid of cards, because that is what makes the PDF's structure tree
+ * navigable: a screen reader announces "Build success rate, 91%, down 3 points from the
+ * previous period" from the row's association with its headers. Cards would print the
+ * same ink and carry none of that.
+ */
+function sectionRow(section) {
+    const title = esc(section.title);
+    if (section.state === 'locked') {
+        const feature = section.requiresFeature ? esc(section.requiresFeature) : 'an add-on';
+        return `<tr><th scope="row">${title}</th>`
+            + '<td class="muted">Not included</td>'
+            + `<td class="muted">Not on your plan — needs ${feature}. The rest of this report is unaffected.</td></tr>`;
+    }
+    if (section.state === 'failed') {
+        return `<tr><th scope="row">${title}</th>`
+            + '<td class="muted">Unavailable</td>'
+            + '<td class="muted">Could not be computed for this period.</td></tr>';
+    }
+    const { headline } = section;
+    // A section with no single number is not an error and must not read like one: several
+    // legitimately have none (a breakdown, a list of offenders).
+    const value = headline
+        ? `${esc(headline.value)}${esc(headline.unit ?? '')}`
+        : '—';
+    const label = headline?.label ? esc(headline.label) : 'No single headline for this section';
+    const trend = trendSentence(section);
+    const note = trend ? `${label} · ${esc(trend)}` : label;
+    return `<tr><th scope="row">${title}</th><td class="value">${value}</td><td>${note}</td></tr>`;
+}
+/** The data-quality notes, which are the difference between "0 deploys" and "we cannot see your deploys". */
+function notesList(notes) {
+    if (notes.length === 0)
+        return '';
+    const items = notes.map((n) => `<li>${esc(n.message)}</li>`).join('');
+    return '<section class="block"><h2>What to know about these numbers</h2>'
+        + `<ul class="notes">${items}</ul></section>`;
+}
+/**
+ * Paragraphs from free text.
+ *
+ * Blank-line separated, and NOT a single `<p>` with newlines: a lead who wrote three
+ * paragraphs gets three, and the PDF's structure tree gets three, instead of one wall
+ * that a screen reader reads as a single utterance.
+ */
+function paragraphs(text) {
+    return text
+        .split(/\n{2,}/)
+        .map((p) => p.trim())
+        .filter(Boolean)
+        .map((p) => `<p>${esc(p).replace(/\n/g, '<br />')}</p>`)
+        .join('');
+}
+/**
+ * The print stylesheet.
+ *
+ * Deliberately small and deliberately not the product's design system: this document is
+ * printed once, to paper size, by one engine. Importing the app's CSS would drag in a web
+ * font (a network fetch the renderer forbids) and a dark-mode block that would render a
+ * manager's PDF black.
+ *
+ * `@page` owns the margins so Chromium's own `margin` option does not have to, which keeps
+ * the page geometry in the document rather than split across two places.
+ */
+const STYLE = `
+:root { color-scheme: only light; }
+* { box-sizing: border-box; }
+@page { size: A4; margin: 18mm 16mm 20mm; }
+body {
+  margin: 0; background: #ffffff; color: #111827;
+  font: 11pt/1.45 -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+}
+h1 { font-size: 20pt; margin: 0 0 2mm; }
+h2 { font-size: 12pt; margin: 0 0 2mm; }
+p { margin: 0 0 2.5mm; }
+.sub { color: #4b5563; font-size: 9.5pt; margin: 0 0 6mm; }
+.block { margin: 0 0 7mm; page-break-inside: avoid; }
+table { width: 100%; border-collapse: collapse; font-size: 10pt; }
+caption { text-align: left; font-weight: 600; font-size: 12pt; padding: 0 0 2mm; }
+th, td { text-align: left; vertical-align: top; padding: 2mm 2mm 2mm 0; border-bottom: 1px solid #e5e7eb; }
+thead th { border-bottom: 1.5px solid #9ca3af; font-size: 9pt; text-transform: uppercase; letter-spacing: .04em; }
+tbody th { font-weight: 600; width: 42%; }
+td.value { font-variant-numeric: tabular-nums; font-weight: 600; white-space: nowrap; width: 18%; }
+.muted { color: #4b5563; }
+.notes { margin: 0; padding-left: 5mm; }
+.notes li { margin: 0 0 1.5mm; }
+.footer { margin-top: 8mm; padding-top: 3mm; border-top: 1px solid #e5e7eb; color: #4b5563; font-size: 8.5pt; }
+.footer p { margin: 0 0 1mm; }
+tr { page-break-inside: avoid; }
+`;
+/**
+ * Render one report as a complete HTML document.
+ *
+ * ORDER IS MEANING, and it is the same order the shared web page uses: the lead's words,
+ * then the executive summary, then the numbers. A reader who meets the table first has
+ * already formed a view of the dip by the time they reach the sentence explaining it, so
+ * the context the data cannot supply has to come first. `a11y-stakeholder-reports.test.tsx`
+ * pins that ordering for the page; `report-html.test.ts` pins it here.
+ *
+ * A NULL SNAPSHOT STILL RENDERS. A run can be read before or without a snapshot (a failed
+ * compose, a draft), and answering an empty file would look like a broken download. The
+ * document says there is nothing to show instead.
+ */
+export function renderReportHtml(input) {
+    const snapshot = input.snapshot;
+    const sections = snapshot?.sections ?? [];
+    const lang = 'en';
+    const head = [
+        '<!DOCTYPE html>',
+        `<html lang="${lang}"><head><meta charset="utf-8" />`,
+        // No external anything: the one directive that makes the promise in the file header
+        // enforceable by the engine rather than by review.
+        '<meta http-equiv="Content-Security-Policy" content="default-src \'none\'; style-src \'unsafe-inline\'" />',
+        `<title>${esc(input.title)} — ${esc(input.periodLabel)}</title>`,
+        `<style>${STYLE}</style>`,
+        '</head><body>',
+    ].join('');
+    const version = input.version > 1 ? ` · revision ${esc(input.version)}` : '';
+    const published = input.publishedAt ? ` · published ${esc(day(input.publishedAt))}` : '';
+    const header = `<h1>${esc(input.title)}</h1>`
+        + `<p class="sub">${esc(input.periodLabel)} · ${esc(day(input.periodStart))} to `
+        + `${esc(day(input.periodEnd))}${version}${published}</p>`;
+    const summary = input.executiveSummary
+        ? `<section class="block"><h2>Executive summary</h2>${paragraphs(input.executiveSummary)}</section>`
+        : '';
+    const notes = input.leadNotes
+        ? `<section class="block"><h2>Notes from the team</h2>${paragraphs(input.leadNotes)}</section>`
+        : '';
+    const body = sections.length > 0
+        ? '<section class="block"><table>'
+            + `<caption>Delivery measures for ${esc(input.periodLabel)}</caption>`
+            + '<thead><tr><th scope="col">Measure</th><th scope="col">Value</th><th scope="col">Detail</th></tr></thead>'
+            + `<tbody>${sections.map(sectionRow).join('')}</tbody></table></section>`
+        : '<section class="block"><h2>No measures</h2>'
+            + '<p class="muted">This report has no computed sections. Nothing was measured for this period.</p></section>';
+    const footerLines = [];
+    if (input.namesRedacted) {
+        footerLines.push('Project and pipeline names have been replaced in this copy.');
+    }
+    if (snapshot?.methodology)
+        footerLines.push(snapshot.methodology);
+    if (snapshot?.generatedAt) {
+        footerLines.push(`Figures computed ${day(snapshot.generatedAt)} and frozen for the period shown.`);
+    }
+    if (input.expiresAt) {
+        footerLines.push(`The link this copy came from expires on ${day(input.expiresAt)}.`);
+    }
+    footerLines.push(`This file was created ${day(input.renderedAt)}.`);
+    const footer = `<footer class="footer">${footerLines.map((l) => `<p>${esc(l)}</p>`).join('')}</footer>`;
+    return `${head}${header}${notes}${summary}${body}${notesList(snapshot?.notes ?? [])}${footer}</body></html>`;
+}
+/**
+ * The download's file name.
+ *
+ * Built from the period and the version rather than the run id, because the person saving
+ * it is filing it next to last month's, and `report-2026-W38-v2.pdf` sorts and reads while
+ * a uuid does not. Sanitizing is the ROUTE's job (`attachmentDisposition`) — this only
+ * chooses the words.
+ */
+export function reportFileName(title, periodLabel, version) {
+    const base = `${title} ${periodLabel}${version > 1 ? ` v${version}` : ''}`;
+    return `${base.trim()}.pdf`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-html.js","sourceRoot":"","sources":["../../../../src/api/reporting/stakeholder/report-html.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The snapshot, as one self-contained HTML document — the input the PDF renderer prints.\n *\n * WHY HTML AND NOT A PDF LIBRARY. A layout engine we would have to teach about page\n * breaks, table widths and font metrics is a second renderer to maintain; Chromium\n * already has one. So the pipeline is snapshot -> HTML -> `Page.printToPDF`, and this\n * file owns the first arrow. It is pure: a string in, a string out, no I/O, no clock, no\n * database. That is what makes the PDF's content testable without a browser.\n *\n * SELF-CONTAINED, AND THAT IS A SECURITY PROPERTY, not tidiness. No <script>, no\n * stylesheet link, no web font, no image URL — everything is inline. The renderer loads\n * this through `setContent` with the page offline, so a document that referenced anything\n * external would either hang or quietly render without it. Stated here because the\n * temptation to add a logo by URL will come up, and it would be the one change that gives\n * the renderer a reason to talk to the network.\n *\n * EVERY INTERPOLATION IS ESCAPED. The snapshot carries org-controlled text — pipeline\n * names, a lead's notes, a section title — into markup that a browser then parses. That\n * is the same boundary as any XSS sink, and it does not stop mattering because the output\n * is a PDF: unescaped notes could close a tag and rewrite the rest of the report, which is\n * a document-forgery bug in a document people make decisions from. `esc()` is applied at\n * every single insertion point and there is no \"trusted\" caller.\n *\n * NO COLOUR-ONLY MEANING, and no bare glyph carrying information (WCAG 1.4.1 / 1.1.1). A\n * locked panel says \"Not on your plan\" in words; a trend says \"down 3 points\" in words\n * rather than leaning on an arrow. There are no charts in a snapshot today — every section\n * renders as a number, a word and a table row — so the plan's \"alt text on charts\" has\n * nothing to attach to yet. The rule that replaces it is stricter and survives a chart\n * being added later: if a reader with no colour vision, no images and a screen reader\n * cannot get a fact out of this document, the fact is not in it.\n */\n\nimport type { ComposedSection, DataQualityNote, ReportSnapshot } from './compose.js';\n\n/** What the renderer needs to produce one report document. */\nexport interface ReportHtmlInput {\n  /** The definition's name. Heads the document. */\n  title: string;\n  periodLabel: string;\n  periodStart: string;\n  periodEnd: string;\n  /** Regenerations are normal; a reader must be able to tell which one they hold. */\n  version: number;\n  publishedAt?: string | null;\n  /** The lead's own words. Rendered ABOVE the numbers — see the ordering note below. */\n  leadNotes?: string | null;\n  /**\n   * The AI-drafted executive summary, when the run has one and the caller is allowed to\n   * see it. Never fetched here: a caller that should not disclose it simply omits it.\n   */\n  executiveSummary?: string | null;\n  snapshot: ReportSnapshot | null;\n  /** True when pipeline/project names were replaced — said in the document, not implied. */\n  namesRedacted?: boolean;\n  /** Shown in the footer of a shared copy, so a bookmarked link's death is not a surprise. */\n  expiresAt?: string | null;\n  /**\n   * Stamped in the footer as the moment the FILE was made, distinct from the snapshot's\n   * own `generatedAt`. Two dates because they answer different questions: \"is this report\n   * current?\" and \"is this the copy I was sent?\".\n   */\n  renderedAt: string;\n}\n\n/** HTML-escape. Applied at every insertion point; see the file header. */\nfunction esc(value: unknown): string {\n  return String(value ?? '')\n    .replace(/&/g, '&amp;')\n    .replace(/</g, '&lt;')\n    .replace(/>/g, '&gt;')\n    .replace(/\"/g, '&quot;')\n    .replace(/'/g, '&#39;');\n}\n\n/** A date as a plain calendar day, in UTC, or `—` when absent. */\nfunction day(iso: string | null | undefined): string {\n  if (!iso) return '—';\n  const d = new Date(iso);\n  if (Number.isNaN(d.getTime())) return '—';\n  return d.toISOString().slice(0, 10);\n}\n\n/**\n * The trend, IN WORDS.\n *\n * \"down 3 points\" rather than a red arrow, because the arrow is the whole fact for a\n * section whose headline barely moved, and an arrow is invisible to a screen reader and\n * ambiguous in greyscale. `unknown` renders nothing at all rather than \"flat\" — a section\n * with no comparable previous period has not held steady, we just cannot say.\n */\nexport function trendSentence(section: ComposedSection): string | null {\n  const { change, headline } = section;\n  if (!change || change.direction === 'unknown') return null;\n  const unit = headline?.unit === '%' ? 'points' : null;\n  const magnitude = Math.abs(change.absolute);\n  if (change.direction === 'flat') return 'unchanged from the previous period';\n  const word = change.direction === 'up' ? 'up' : 'down';\n  const pct = change.percent !== null && change.percent !== undefined\n    ? ` (${change.percent > 0 ? '+' : ''}${change.percent}%)`\n    : '';\n  return `${word} ${magnitude}${unit ? ` ${unit}` : ''}${pct} from the previous period`;\n}\n\n/**\n * One section as a table row.\n *\n * A TABLE, not a grid of cards, because that is what makes the PDF's structure tree\n * navigable: a screen reader announces \"Build success rate, 91%, down 3 points from the\n * previous period\" from the row's association with its headers. Cards would print the\n * same ink and carry none of that.\n */\nfunction sectionRow(section: ComposedSection): string {\n  const title = esc(section.title);\n  if (section.state === 'locked') {\n    const feature = section.requiresFeature ? esc(section.requiresFeature) : 'an add-on';\n    return `<tr><th scope=\"row\">${title}</th>`\n      + '<td class=\"muted\">Not included</td>'\n      + `<td class=\"muted\">Not on your plan — needs ${feature}. The rest of this report is unaffected.</td></tr>`;\n  }\n  if (section.state === 'failed') {\n    return `<tr><th scope=\"row\">${title}</th>`\n      + '<td class=\"muted\">Unavailable</td>'\n      + '<td class=\"muted\">Could not be computed for this period.</td></tr>';\n  }\n  const { headline } = section;\n  // A section with no single number is not an error and must not read like one: several\n  // legitimately have none (a breakdown, a list of offenders).\n  const value = headline\n    ? `${esc(headline.value)}${esc(headline.unit ?? '')}`\n    : '—';\n  const label = headline?.label ? esc(headline.label) : 'No single headline for this section';\n  const trend = trendSentence(section);\n  const note = trend ? `${label} · ${esc(trend)}` : label;\n  return `<tr><th scope=\"row\">${title}</th><td class=\"value\">${value}</td><td>${note}</td></tr>`;\n}\n\n/** The data-quality notes, which are the difference between \"0 deploys\" and \"we cannot see your deploys\". */\nfunction notesList(notes: readonly DataQualityNote[]): string {\n  if (notes.length === 0) return '';\n  const items = notes.map((n) => `<li>${esc(n.message)}</li>`).join('');\n  return '<section class=\"block\"><h2>What to know about these numbers</h2>'\n    + `<ul class=\"notes\">${items}</ul></section>`;\n}\n\n/**\n * Paragraphs from free text.\n *\n * Blank-line separated, and NOT a single `<p>` with newlines: a lead who wrote three\n * paragraphs gets three, and the PDF's structure tree gets three, instead of one wall\n * that a screen reader reads as a single utterance.\n */\nfunction paragraphs(text: string): string {\n  return text\n    .split(/\\n{2,}/)\n    .map((p) => p.trim())\n    .filter(Boolean)\n    .map((p) => `<p>${esc(p).replace(/\\n/g, '<br />')}</p>`)\n    .join('');\n}\n\n/**\n * The print stylesheet.\n *\n * Deliberately small and deliberately not the product's design system: this document is\n * printed once, to paper size, by one engine. Importing the app's CSS would drag in a web\n * font (a network fetch the renderer forbids) and a dark-mode block that would render a\n * manager's PDF black.\n *\n * `@page` owns the margins so Chromium's own `margin` option does not have to, which keeps\n * the page geometry in the document rather than split across two places.\n */\nconst STYLE = `\n:root { color-scheme: only light; }\n* { box-sizing: border-box; }\n@page { size: A4; margin: 18mm 16mm 20mm; }\nbody {\n  margin: 0; background: #ffffff; color: #111827;\n  font: 11pt/1.45 -apple-system, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, sans-serif;\n}\nh1 { font-size: 20pt; margin: 0 0 2mm; }\nh2 { font-size: 12pt; margin: 0 0 2mm; }\np { margin: 0 0 2.5mm; }\n.sub { color: #4b5563; font-size: 9.5pt; margin: 0 0 6mm; }\n.block { margin: 0 0 7mm; page-break-inside: avoid; }\ntable { width: 100%; border-collapse: collapse; font-size: 10pt; }\ncaption { text-align: left; font-weight: 600; font-size: 12pt; padding: 0 0 2mm; }\nth, td { text-align: left; vertical-align: top; padding: 2mm 2mm 2mm 0; border-bottom: 1px solid #e5e7eb; }\nthead th { border-bottom: 1.5px solid #9ca3af; font-size: 9pt; text-transform: uppercase; letter-spacing: .04em; }\ntbody th { font-weight: 600; width: 42%; }\ntd.value { font-variant-numeric: tabular-nums; font-weight: 600; white-space: nowrap; width: 18%; }\n.muted { color: #4b5563; }\n.notes { margin: 0; padding-left: 5mm; }\n.notes li { margin: 0 0 1.5mm; }\n.footer { margin-top: 8mm; padding-top: 3mm; border-top: 1px solid #e5e7eb; color: #4b5563; font-size: 8.5pt; }\n.footer p { margin: 0 0 1mm; }\ntr { page-break-inside: avoid; }\n`;\n\n/**\n * Render one report as a complete HTML document.\n *\n * ORDER IS MEANING, and it is the same order the shared web page uses: the lead's words,\n * then the executive summary, then the numbers. A reader who meets the table first has\n * already formed a view of the dip by the time they reach the sentence explaining it, so\n * the context the data cannot supply has to come first. `a11y-stakeholder-reports.test.tsx`\n * pins that ordering for the page; `report-html.test.ts` pins it here.\n *\n * A NULL SNAPSHOT STILL RENDERS. A run can be read before or without a snapshot (a failed\n * compose, a draft), and answering an empty file would look like a broken download. The\n * document says there is nothing to show instead.\n */\nexport function renderReportHtml(input: ReportHtmlInput): string {\n  const snapshot = input.snapshot;\n  const sections = snapshot?.sections ?? [];\n  const lang = 'en';\n\n  const head = [\n    '<!DOCTYPE html>',\n    `<html lang=\"${lang}\"><head><meta charset=\"utf-8\" />`,\n    // No external anything: the one directive that makes the promise in the file header\n    // enforceable by the engine rather than by review.\n    '<meta http-equiv=\"Content-Security-Policy\" content=\"default-src \\'none\\'; style-src \\'unsafe-inline\\'\" />',\n    `<title>${esc(input.title)} — ${esc(input.periodLabel)}</title>`,\n    `<style>${STYLE}</style>`,\n    '</head><body>',\n  ].join('');\n\n  const version = input.version > 1 ? ` · revision ${esc(input.version)}` : '';\n  const published = input.publishedAt ? ` · published ${esc(day(input.publishedAt))}` : '';\n  const header = `<h1>${esc(input.title)}</h1>`\n    + `<p class=\"sub\">${esc(input.periodLabel)} · ${esc(day(input.periodStart))} to `\n    + `${esc(day(input.periodEnd))}${version}${published}</p>`;\n\n  const summary = input.executiveSummary\n    ? `<section class=\"block\"><h2>Executive summary</h2>${paragraphs(input.executiveSummary)}</section>`\n    : '';\n\n  const notes = input.leadNotes\n    ? `<section class=\"block\"><h2>Notes from the team</h2>${paragraphs(input.leadNotes)}</section>`\n    : '';\n\n  const body = sections.length > 0\n    ? '<section class=\"block\"><table>'\n      + `<caption>Delivery measures for ${esc(input.periodLabel)}</caption>`\n      + '<thead><tr><th scope=\"col\">Measure</th><th scope=\"col\">Value</th><th scope=\"col\">Detail</th></tr></thead>'\n      + `<tbody>${sections.map(sectionRow).join('')}</tbody></table></section>`\n    : '<section class=\"block\"><h2>No measures</h2>'\n      + '<p class=\"muted\">This report has no computed sections. Nothing was measured for this period.</p></section>';\n\n  const footerLines: string[] = [];\n  if (input.namesRedacted) {\n    footerLines.push('Project and pipeline names have been replaced in this copy.');\n  }\n  if (snapshot?.methodology) footerLines.push(snapshot.methodology);\n  if (snapshot?.generatedAt) {\n    footerLines.push(`Figures computed ${day(snapshot.generatedAt)} and frozen for the period shown.`);\n  }\n  if (input.expiresAt) {\n    footerLines.push(`The link this copy came from expires on ${day(input.expiresAt)}.`);\n  }\n  footerLines.push(`This file was created ${day(input.renderedAt)}.`);\n  const footer = `<footer class=\"footer\">${footerLines.map((l) => `<p>${esc(l)}</p>`).join('')}</footer>`;\n\n  return `${head}${header}${notes}${summary}${body}${notesList(snapshot?.notes ?? [])}${footer}</body></html>`;\n}\n\n/**\n * The download's file name.\n *\n * Built from the period and the version rather than the run id, because the person saving\n * it is filing it next to last month's, and `report-2026-W38-v2.pdf` sorts and reads while\n * a uuid does not. Sanitizing is the ROUTE's job (`attachmentDisposition`) — this only\n * chooses the words.\n */\nexport function reportFileName(title: string, periodLabel: string, version: number): string {\n  const base = `${title} ${periodLabel}${version > 1 ? ` v${version}` : ''}`;\n  return `${base.trim()}.pdf`;\n}\n"]}

package/lib/api/reporting/stakeholder/sections.d.ts

@@ -0,0 +1,117 @@
+/**
+ * The section registry: the one place that maps a report section id to the
+ * ReportingService method that computes it.
+ *
+ * Why a registry rather than each template calling the service directly:
+ *
+ *  - The numbers in a report MUST match the dashboard. A manager who compares the
+ *    two and finds a difference stops trusting both, so both read the same query —
+ *    there is no separate "report" implementation of success rate.
+ *  - Feature gating belongs with the section, not the route. DORA sections need
+ *    `advanced_reporting`; a report that includes one without the add-on renders a
+ *    LOCKED section and still delivers, rather than failing the whole run. A run
+ *    that dies because of one gated section is a support ticket; a locked panel is
+ *    an upsell.
+ *  - Per-person metrics are refused HERE, at registration. Ranking individual
+ *    developers destroys trust in the whole report, and a guideline in a document
+ *    does not stop someone adding `topCommitters` later — a throwing registry does.
+ */
+import type { FeatureFlag } from '@pipeline-builder/api-core';
+import type { AnalyticsScope } from '../analytics-queries.js';
+/** What a section needs to run one period's query. */
+export interface SectionContext {
+    orgId: string;
+    /** Rollup org ids, when the definition's scope is a team rollup. */
+    orgIds?: string[];
+    /** Period bounds as ISO strings, which is what every service method takes. */
+    from: string;
+    to: string;
+    /** The report's bucketing settings, for the time-series sections. */
+    tz: string;
+    weekStart: 'monday' | 'sunday';
+    /**
+     * The PREVIOUS period's bounds, for the sections that compute their own trend
+     * internally rather than being run twice.
+     *
+     * Most sections are simply re-run over the previous window by the composer and
+     * compared on a single headline. The analytics sections cannot be: their trend is
+     * per category, per stage or per pipeline, and comparing two whole result sets
+     * afterwards would mean re-implementing the join in the composer.
+     */
+    previousFrom?: string;
+    previousTo?: string;
+}
+/** The service surface a section is allowed to call. Structural on purpose: the
+ *  registry never imports the service, so it stays testable with a stub. */
+export interface SectionDataSource {
+    getExecutionCount(orgId: string, orgIds?: string[], range?: {
+        from?: string;
+        to?: string;
+    }): Promise<unknown>;
+    getSuccessRate(orgId: string, interval: string, from: string, to: string, orgIds?: string[], bucket?: {
+        tz?: string;
+        weekStart?: 'monday' | 'sunday';
+    }): Promise<unknown>;
+    getAverageDuration(orgId: string, from: string, to: string, orgIds?: string[]): Promise<unknown>;
+    getStageFailures(orgId: string, from: string, to: string, orgIds?: string[]): Promise<unknown>;
+    getStageBottlenecks(orgId: string, from: string, to: string, orgIds?: string[]): Promise<unknown>;
+    getActionFailures(orgId: string, from: string, to: string, orgIds?: string[]): Promise<unknown>;
+    getErrors(orgId: string, from: string, to: string, limit?: number, orgIds?: string[]): Promise<unknown>;
+    getPluginSummary(orgId: string): Promise<unknown>;
+    getPluginDistribution(orgId: string): Promise<unknown>;
+    getPluginVersions(orgId: string): Promise<unknown>;
+    getBuildSuccessRate(orgId: string, interval: string, from: string, to: string, orgIds?: string[], bucket?: {
+        tz?: string;
+        weekStart?: 'monday' | 'sunday';
+    }): Promise<unknown>;
+    getBuildDuration(orgId: string, from: string, to: string, orgIds?: string[]): Promise<unknown>;
+    getBuildFailures(orgId: string, from: string, to: string, limit?: number, orgIds?: string[]): Promise<unknown>;
+    getDoraMetrics(orgId: string, from: string, to: string, orgIds?: string[], opts?: Record<string, unknown>): Promise<unknown>;
+    getDoraTrend(orgId: string, interval: string, from: string, to: string, orgIds?: string[], opts?: Record<string, unknown>): Promise<unknown>;
+    getBuildHealth(orgId: string, pipelineId: string, from: string, to: string): Promise<unknown>;
+    getReportEnvironments(orgId: string, from: string, to: string, orgIds?: string[]): Promise<unknown>;
+    getPipelineBreakdown(scope: AnalyticsScope, limit?: number): Promise<unknown>;
+    getFailureAnalysis(scope: AnalyticsScope, previous?: {
+        from: string;
+        to: string;
+    }): Promise<unknown>;
+    getStagePerformance(scope: AnalyticsScope, pipelineId: string, previous?: {
+        from: string;
+        to: string;
+    }): Promise<unknown>;
+    getResourceConsumption(scope: AnalyticsScope, limit?: number): Promise<unknown>;
+    getPromotionView(scope: AnalyticsScope, productionEnv?: string, limit?: number): Promise<unknown>;
+    getOutdatedPlugins(scope: AnalyticsScope, limit?: number): Promise<unknown>;
+    getPluginVulnerabilities(scope: AnalyticsScope, limit?: number): Promise<unknown>;
+    getAdoption(scope: AnalyticsScope, timeSavedMinutes?: number | null): Promise<unknown>;
+    /** Compliance + access posture, over a service-to-service read. Degrades. */
+    getCompliancePosture?(scope: AnalyticsScope): Promise<unknown>;
+    /** The evaluated needs-attention findings for the period. */
+    getNeedsAttention?(scope: AnalyticsScope, previous?: {
+        from: string;
+        to: string;
+    }): Promise<unknown>;
+}
+/** One registered section. */
+export interface SectionSpec {
+    id: string;
+    /** Manager-facing title. Not a metric name — "Deploys", not "deployment_frequency". */
+    title: string;
+    /** Feature the org must hold, or undefined for a free section. */
+    requiresFeature?: FeatureFlag;
+    /**
+     * True when this section's value is a single comparable number, so the composer
+     * can compute period-over-period change. A list section (top failures) has no
+     * meaningful "change", and pretending otherwise produces nonsense arrows.
+     */
+    comparable: boolean;
+    run(source: SectionDataSource, ctx: SectionContext): Promise<unknown>;
+}
+/** Register a section. Throws on a duplicate id or a per-person one. */
+export declare function registerSection(spec: SectionSpec): SectionSpec;
+/** Look a section up; undefined when the id is unknown. */
+export declare function getSection(id: string): SectionSpec | undefined;
+/** Every registered section, in registration order. */
+export declare function allSections(): SectionSpec[];
+/** The ids a caller may put in a definition. */
+export declare function sectionIds(): string[];