@pipeline-builder/pipeline-data 4.1.24 → 4.1.25

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

@@ -0,0 +1,115 @@
+/**
+ * The composer: turn a definition's section list into the snapshot a manager reads.
+ *
+ * Three things it does that the raw queries do not:
+ *
+ *  - PERIOD-OVER-PERIOD. Every comparable section is run twice, for this period
+ *    and the one before, so the snapshot carries "91% (down 3 points)". The trend
+ *    is what a manager acts on; the absolute number alone rarely is.
+ *  - LOCKED SECTIONS. A section whose feature the org lacks renders as locked
+ *    instead of failing the run. A report that dies because one gated section was
+ *    included is a support ticket; a locked panel is an upsell.
+ *  - DATA-QUALITY NOTES. Missing deploy tags and tiny samples are stated, not
+ *    silently rendered as zero. "0 deploys" and "we cannot see your deploys" look
+ *    identical on a chart and mean opposite things — a manager reading the first
+ *    when it is really the second draws exactly the wrong conclusion.
+ */
+import type { ResolvedPeriod } from './period.js';
+import { type SectionDataSource } from './sections.js';
+/** Below this many observations a rate is noise, and says so. */
+export declare const LOW_SAMPLE_THRESHOLD = 5;
+/** Which way a metric moved. `flat` when the change rounds to nothing. */
+export type TrendDirection = 'up' | 'down' | 'flat' | 'unknown';
+/** A data-quality caveat attached to the whole snapshot. */
+export interface DataQualityNote {
+    code: 'missing_deploy_tag' | 'missing_commit_data' | 'low_sample' | 'section_failed' | 'section_locked';
+    /** Manager-readable. Not a metric name and not a stack trace. */
+    message: string;
+    /** The section it concerns, when it is section-specific. */
+    sectionId?: string;
+}
+/** One composed section. */
+export interface ComposedSection {
+    id: string;
+    title: string;
+    /** `locked` when the org lacks the feature; `failed` when the query threw. */
+    state: 'ok' | 'locked' | 'failed';
+    /** The feature needed, when locked — drives the upsell copy. */
+    requiresFeature?: string;
+    /** This period's raw result, exactly as the dashboard would show it. */
+    current?: unknown;
+    /** The previous period's result, for comparable sections. */
+    previous?: unknown;
+    /** The single number a manager reads first, when the section has one. */
+    headline?: {
+        label: string;
+        value: number;
+        unit?: string;
+    };
+    /** Change versus the previous period, for comparable sections. */
+    change?: {
+        absolute: number;
+        percent: number | null;
+        direction: TrendDirection;
+    };
+}
+/** The frozen output of one run. */
+export interface ReportSnapshot {
+    /** Period bounds + label, copied in so the snapshot is self-describing. */
+    period: {
+        start: string;
+        end: string;
+        label: string;
+    };
+    previousPeriod: {
+        start: string;
+        end: string;
+    };
+    timezone: string;
+    weekStart: 'monday' | 'sunday';
+    sections: ComposedSection[];
+    notes: DataQualityNote[];
+    /**
+     * How every number here was produced, shown in the report footer. Managers
+     * compare reports to the dashboard; saying plainly that both run the same
+     * queries over the same window is what makes a difference investigable rather
+     * than a reason to distrust both.
+     */
+    methodology: string;
+    generatedAt: string;
+}
+/** What the composer needs to know about the org's entitlements. */
+export interface ComposeOptions {
+    source: SectionDataSource;
+    period: ResolvedPeriod;
+    timezone: string;
+    weekStart: 'monday' | 'sunday';
+    orgId: string;
+    orgIds?: string[];
+    /** Features the org holds. A section needing one that is absent renders locked. */
+    features: readonly string[];
+    now?: Date;
+}
+/**
+ * Features that, inside a REPORT, stand in for another.
+ *
+ * Buying Stakeholder Reports buys the DORA SECTIONS of a report. It does not buy the
+ * live DORA dashboard, which stays behind `advanced_reporting` and is gated on its own
+ * routes — so this substitution is deliberately scoped to composition and exists
+ * nowhere else. Without it, a Pro customer who bought the reports add-on would open
+ * their first weekly report and find its headline panels locked behind a second
+ * purchase, which is not what the add-on's own description promises.
+ *
+ * Stated as data rather than an `if`, so adding a section that needs a different
+ * feature cannot silently inherit the carve-out.
+ */
+export declare const REPORT_FEATURE_SUBSTITUTES: Readonly<Record<string, readonly string[]>>;
+/**
+ * Compose one period's snapshot.
+ *
+ * Never throws for a section-level problem: a section that fails is marked
+ * `failed` with a note, and the rest of the report still reaches the lead. A run
+ * that produces nine good sections and one failure is useful; a run that produces
+ * an exception is not.
+ */
+export declare function composeSnapshot(sectionIdList: readonly string[], opts: ComposeOptions): Promise<ReportSnapshot>;

package/lib/api/reporting/stakeholder/compose.js

@@ -0,0 +1,234 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { getSection } from './sections.js';
+/** Below this many observations a rate is noise, and says so. */
+export const LOW_SAMPLE_THRESHOLD = 5;
+/**
+ * Features that, inside a REPORT, stand in for another.
+ *
+ * Buying Stakeholder Reports buys the DORA SECTIONS of a report. It does not buy the
+ * live DORA dashboard, which stays behind `advanced_reporting` and is gated on its own
+ * routes — so this substitution is deliberately scoped to composition and exists
+ * nowhere else. Without it, a Pro customer who bought the reports add-on would open
+ * their first weekly report and find its headline panels locked behind a second
+ * purchase, which is not what the add-on's own description promises.
+ *
+ * Stated as data rather than an `if`, so adding a section that needs a different
+ * feature cannot silently inherit the carve-out.
+ */
+export const REPORT_FEATURE_SUBSTITUTES = Object.freeze({
+    advanced_reporting: ['stakeholder_reports'],
+});
+/** Does the org hold `required`, or something that stands in for it in a report? */
+function satisfies(features, required) {
+    if (features.includes(required))
+        return true;
+    return (REPORT_FEATURE_SUBSTITUTES[required] ?? []).some((alt) => features.includes(alt));
+}
+/** Pull a comparable number out of a section result, or null when there isn't one. */
+function headlineOf(sectionId, value) {
+    if (value === null || value === undefined)
+        return null;
+    // Time series (success rate, build success): the LAST bucket is "now".
+    if (Array.isArray(value) && value.length > 0) {
+        const last = value[value.length - 1];
+        if (typeof last?.success_pct === 'number')
+            return { label: 'Success rate', value: last.success_pct, unit: '%' };
+        // Execution counts: total runs across pipelines.
+        //
+        // A total of ZERO is a real headline, not missing data: "0 deploys, down from
+        // 5" is the single most important thing a weekly report can tell a manager,
+        // and treating 0 as "no value" made exactly that case disappear — the change
+        // came back `unknown` and no arrow was shown. So the test is whether any row
+        // CARRIED a count, not whether the sum is positive.
+        let counted = false;
+        const total = value.reduce((sum, row) => {
+            const n = row.total ?? row.count ?? row.executions;
+            if (typeof n !== 'number')
+                return sum;
+            counted = true;
+            return sum + n;
+        }, 0);
+        if (counted)
+            return { label: 'Total', value: total };
+        return null;
+    }
+    const obj = value;
+    // DORA: deployment frequency is the headline a manager recognises.
+    const envs = obj.environments;
+    if (Array.isArray(envs) && envs.length > 0) {
+        const first = envs[0];
+        const df = first.deploymentFrequency?.deployments;
+        if (typeof df === 'number')
+            return { label: 'Deploys', value: df };
+    }
+    // Plugin summary and friends: a plain total.
+    // Zero is a value here too — `plugin_versions` reporting 0 outdated plugins is
+    // good news a manager should see, not an absent section.
+    for (const key of ['total', 'count', 'deployments']) {
+        if (typeof obj[key] === 'number')
+            return { label: sectionId === 'plugin_versions' ? 'Outdated' : 'Total', value: obj[key] };
+    }
+    return null;
+}
+/** Change between two headline numbers. */
+function changeOf(current, previous) {
+    if (!current || !previous)
+        return { absolute: 0, percent: null, direction: 'unknown' };
+    const absolute = Number((current.value - previous.value).toFixed(2));
+    // A percent change off a zero baseline is undefined, not infinite: going from 0
+    // to 5 deploys is "5 more", never "+∞%".
+    const percent = previous.value === 0 ? null : Number(((absolute / previous.value) * 100).toFixed(1));
+    const direction = absolute === 0 ? 'flat' : absolute > 0 ? 'up' : 'down';
+    return { absolute, percent, direction };
+}
+/** Count the observations behind a section, for the low-sample note. */
+function sampleSize(value) {
+    if (Array.isArray(value)) {
+        return value.reduce((sum, row) => {
+            const n = row.total ?? row.count ?? row.executions ?? row.deployments;
+            return sum + (typeof n === 'number' ? n : 0);
+        }, 0);
+    }
+    const obj = value;
+    const envs = obj?.environments;
+    if (Array.isArray(envs)) {
+        return envs.reduce((sum, e) => {
+            const attempts = e.changeFailureRate?.attempts;
+            return sum + (typeof attempts === 'number' ? attempts : 0);
+        }, 0);
+    }
+    return null;
+}
+/** Deploy-coverage notes: the difference between "zero deploys" and "blind". */
+function deployCoverageNotes(dora) {
+    const notes = [];
+    const coverage = dora?.coverage;
+    const without = coverage?.withoutDeploys;
+    if (typeof without === 'number' && without > 0) {
+        notes.push({
+            code: 'missing_deploy_tag',
+            sectionId: 'dora',
+            message: `Deploy data unavailable for ${without} pipeline${without === 1 ? '' : 's'}: they have not re-synthed with deploy tags, so their deploys are not counted here. This is not "zero deploys".`,
+        });
+    }
+    const envs = dora?.environments;
+    if (Array.isArray(envs)) {
+        const noLead = envs.filter((e) => {
+            const lt = e.leadTime;
+            return lt && lt.medianSeconds === null;
+        });
+        if (noLead.length > 0) {
+            notes.push({
+                code: 'missing_commit_data',
+                sectionId: 'dora',
+                message: `Lead time unavailable for ${noLead.length} environment${noLead.length === 1 ? '' : 's'}: no successful deploy carried a resolvable commit timestamp, so commit-to-deploy time could not be measured.`,
+            });
+        }
+    }
+    return notes;
+}
+/**
+ * Compose one period's snapshot.
+ *
+ * Never throws for a section-level problem: a section that fails is marked
+ * `failed` with a note, and the rest of the report still reaches the lead. A run
+ * that produces nine good sections and one failure is useful; a run that produces
+ * an exception is not.
+ */
+export async function composeSnapshot(sectionIdList, opts) {
+    const { source, period, timezone, weekStart, orgId, orgIds, features } = opts;
+    const notes = [];
+    const sections = [];
+    const ctxFor = (from, to) => ({
+        orgId,
+        ...(orgIds ? { orgIds } : {}),
+        from: from.toISOString(),
+        to: to.toISOString(),
+        tz: timezone,
+        weekStart,
+        // The previous period travels WITH the context, for the analytics sections
+        // whose trend is per category, per stage or per pipeline. Those cannot be
+        // handled by running the section twice and comparing one headline — the
+        // comparison is a join, and doing it in the composer afterwards would mean
+        // re-implementing it for every shape.
+        previousFrom: period.prevStart.toISOString(),
+        previousTo: period.prevEnd.toISOString(),
+    });
+    const currentCtx = ctxFor(period.start, period.end);
+    const previousCtx = ctxFor(period.prevStart, period.prevEnd);
+    for (const id of sectionIdList) {
+        const spec = getSection(id);
+        if (!spec) {
+            // An unknown id is a definition referencing a section that no longer exists.
+            // Recorded rather than dropped, so the lead can see why a panel vanished.
+            sections.push({ id, title: id, state: 'failed' });
+            notes.push({ code: 'section_failed', sectionId: id, message: `Unknown report section "${id}" — it may have been removed.` });
+            continue;
+        }
+        if (spec.requiresFeature && !satisfies(features, spec.requiresFeature)) {
+            sections.push({
+                id, title: spec.title, state: 'locked', requiresFeature: spec.requiresFeature,
+            });
+            notes.push({
+                code: 'section_locked',
+                sectionId: id,
+                message: `"${spec.title}" needs the ${spec.requiresFeature} add-on. The rest of this report is unaffected.`,
+            });
+            continue;
+        }
+        try {
+            const current = await spec.run(source, currentCtx);
+            const composed = { id, title: spec.title, state: 'ok', current };
+            const head = headlineOf(id, current);
+            if (head)
+                composed.headline = head;
+            if (spec.comparable) {
+                // The comparison is best-effort: a failed previous period must not cost the
+                // lead this period's numbers.
+                try {
+                    const previous = await spec.run(source, previousCtx);
+                    composed.previous = previous;
+                    composed.change = changeOf(head, headlineOf(id, previous));
+                }
+                catch {
+                    composed.change = { absolute: 0, percent: null, direction: 'unknown' };
+                }
+            }
+            const sample = sampleSize(current);
+            if (sample !== null && sample > 0 && sample < LOW_SAMPLE_THRESHOLD) {
+                notes.push({
+                    code: 'low_sample',
+                    sectionId: id,
+                    message: `"${spec.title}" is based on ${sample} observation${sample === 1 ? '' : 's'} — percentages swing wildly at this volume. Read the counts, not the rate.`,
+                });
+            }
+            if (id === 'dora')
+                notes.push(...deployCoverageNotes(current));
+            sections.push(composed);
+        }
+        catch (err) {
+            sections.push({ id, title: spec.title, state: 'failed' });
+            notes.push({
+                code: 'section_failed',
+                sectionId: id,
+                message: `"${spec.title}" could not be computed for this period. The rest of the report is unaffected.`,
+            });
+            void err; // the reason is logged by the caller, never shown to a manager
+        }
+    }
+    return {
+        period: { start: period.start.toISOString(), end: period.end.toISOString(), label: period.label },
+        previousPeriod: { start: period.prevStart.toISOString(), end: period.prevEnd.toISOString() },
+        timezone,
+        weekStart,
+        sections,
+        notes,
+        methodology: `Computed from pipeline events between ${period.start.toISOString()} and ${period.end.toISOString()}, `
+            + `bucketed in ${timezone} with weeks starting ${weekStart}. Comparison period: `
+            + `${period.prevStart.toISOString()} to ${period.prevEnd.toISOString()}. `
+            + 'These are the same queries the dashboard runs over the same window, so the two agree.',
+        generatedAt: (opts.now ?? new Date()).toISOString(),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compose.js","sourceRoot":"","sources":["../../../../src/api/reporting/stakeholder/compose.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The composer: turn a definition's section list into the snapshot a manager reads.\n *\n * Three things it does that the raw queries do not:\n *\n *  - PERIOD-OVER-PERIOD. Every comparable section is run twice, for this period\n *    and the one before, so the snapshot carries \"91% (down 3 points)\". The trend\n *    is what a manager acts on; the absolute number alone rarely is.\n *  - LOCKED SECTIONS. A section whose feature the org lacks renders as locked\n *    instead of failing the run. A report that dies because one gated section was\n *    included is a support ticket; a locked panel is an upsell.\n *  - DATA-QUALITY NOTES. Missing deploy tags and tiny samples are stated, not\n *    silently rendered as zero. \"0 deploys\" and \"we cannot see your deploys\" look\n *    identical on a chart and mean opposite things — a manager reading the first\n *    when it is really the second draws exactly the wrong conclusion.\n */\n\nimport type { ResolvedPeriod } from './period.js';\nimport { getSection, type SectionContext, type SectionDataSource, type SectionSpec } from './sections.js';\n\n/** Below this many observations a rate is noise, and says so. */\nexport const LOW_SAMPLE_THRESHOLD = 5;\n\n/** Which way a metric moved. `flat` when the change rounds to nothing. */\nexport type TrendDirection = 'up' | 'down' | 'flat' | 'unknown';\n\n/** A data-quality caveat attached to the whole snapshot. */\nexport interface DataQualityNote {\n  code: 'missing_deploy_tag' | 'missing_commit_data' | 'low_sample' | 'section_failed' | 'section_locked';\n  /** Manager-readable. Not a metric name and not a stack trace. */\n  message: string;\n  /** The section it concerns, when it is section-specific. */\n  sectionId?: string;\n}\n\n/** One composed section. */\nexport interface ComposedSection {\n  id: string;\n  title: string;\n  /** `locked` when the org lacks the feature; `failed` when the query threw. */\n  state: 'ok' | 'locked' | 'failed';\n  /** The feature needed, when locked — drives the upsell copy. */\n  requiresFeature?: string;\n  /** This period's raw result, exactly as the dashboard would show it. */\n  current?: unknown;\n  /** The previous period's result, for comparable sections. */\n  previous?: unknown;\n  /** The single number a manager reads first, when the section has one. */\n  headline?: { label: string; value: number; unit?: string };\n  /** Change versus the previous period, for comparable sections. */\n  change?: { absolute: number; percent: number | null; direction: TrendDirection };\n}\n\n/** The frozen output of one run. */\nexport interface ReportSnapshot {\n  /** Period bounds + label, copied in so the snapshot is self-describing. */\n  period: { start: string; end: string; label: string };\n  previousPeriod: { start: string; end: string };\n  timezone: string;\n  weekStart: 'monday' | 'sunday';\n  sections: ComposedSection[];\n  notes: DataQualityNote[];\n  /**\n   * How every number here was produced, shown in the report footer. Managers\n   * compare reports to the dashboard; saying plainly that both run the same\n   * queries over the same window is what makes a difference investigable rather\n   * than a reason to distrust both.\n   */\n  methodology: string;\n  generatedAt: string;\n}\n\n/** What the composer needs to know about the org's entitlements. */\nexport interface ComposeOptions {\n  source: SectionDataSource;\n  period: ResolvedPeriod;\n  timezone: string;\n  weekStart: 'monday' | 'sunday';\n  orgId: string;\n  orgIds?: string[];\n  /** Features the org holds. A section needing one that is absent renders locked. */\n  features: readonly string[];\n  now?: Date;\n}\n\n/**\n * Features that, inside a REPORT, stand in for another.\n *\n * Buying Stakeholder Reports buys the DORA SECTIONS of a report. It does not buy the\n * live DORA dashboard, which stays behind `advanced_reporting` and is gated on its own\n * routes — so this substitution is deliberately scoped to composition and exists\n * nowhere else. Without it, a Pro customer who bought the reports add-on would open\n * their first weekly report and find its headline panels locked behind a second\n * purchase, which is not what the add-on's own description promises.\n *\n * Stated as data rather than an `if`, so adding a section that needs a different\n * feature cannot silently inherit the carve-out.\n */\nexport const REPORT_FEATURE_SUBSTITUTES: Readonly<Record<string, readonly string[]>> = Object.freeze({\n  advanced_reporting: ['stakeholder_reports'],\n});\n\n/** Does the org hold `required`, or something that stands in for it in a report? */\nfunction satisfies(features: readonly string[], required: string): boolean {\n  if (features.includes(required)) return true;\n  return (REPORT_FEATURE_SUBSTITUTES[required] ?? []).some((alt) => features.includes(alt));\n}\n\n/** Pull a comparable number out of a section result, or null when there isn't one. */\nfunction headlineOf(sectionId: string, value: unknown): { label: string; value: number; unit?: string } | null {\n  if (value === null || value === undefined) return null;\n\n  // Time series (success rate, build success): the LAST bucket is \"now\".\n  if (Array.isArray(value) && value.length > 0) {\n    const last = value[value.length - 1] as Record<string, unknown>;\n    if (typeof last?.success_pct === 'number') return { label: 'Success rate', value: last.success_pct, unit: '%' };\n    // Execution counts: total runs across pipelines.\n    //\n    // A total of ZERO is a real headline, not missing data: \"0 deploys, down from\n    // 5\" is the single most important thing a weekly report can tell a manager,\n    // and treating 0 as \"no value\" made exactly that case disappear — the change\n    // came back `unknown` and no arrow was shown. So the test is whether any row\n    // CARRIED a count, not whether the sum is positive.\n    let counted = false;\n    const total = (value as Array<Record<string, unknown>>).reduce((sum, row) => {\n      const n = row.total ?? row.count ?? row.executions;\n      if (typeof n !== 'number') return sum;\n      counted = true;\n      return sum + n;\n    }, 0);\n    if (counted) return { label: 'Total', value: total };\n    return null;\n  }\n\n  const obj = value as Record<string, unknown>;\n  // DORA: deployment frequency is the headline a manager recognises.\n  const envs = obj.environments;\n  if (Array.isArray(envs) && envs.length > 0) {\n    const first = envs[0] as Record<string, unknown>;\n    const df = (first.deploymentFrequency as Record<string, unknown> | undefined)?.deployments;\n    if (typeof df === 'number') return { label: 'Deploys', value: df };\n  }\n  // Plugin summary and friends: a plain total.\n  // Zero is a value here too — `plugin_versions` reporting 0 outdated plugins is\n  // good news a manager should see, not an absent section.\n  for (const key of ['total', 'count', 'deployments']) {\n    if (typeof obj[key] === 'number') return { label: sectionId === 'plugin_versions' ? 'Outdated' : 'Total', value: obj[key] as number };\n  }\n  return null;\n}\n\n/** Change between two headline numbers. */\nfunction changeOf(\n  current: { value: number } | null,\n  previous: { value: number } | null,\n): ComposedSection['change'] {\n  if (!current || !previous) return { absolute: 0, percent: null, direction: 'unknown' };\n  const absolute = Number((current.value - previous.value).toFixed(2));\n  // A percent change off a zero baseline is undefined, not infinite: going from 0\n  // to 5 deploys is \"5 more\", never \"+∞%\".\n  const percent = previous.value === 0 ? null : Number(((absolute / previous.value) * 100).toFixed(1));\n  const direction: TrendDirection = absolute === 0 ? 'flat' : absolute > 0 ? 'up' : 'down';\n  return { absolute, percent, direction };\n}\n\n/** Count the observations behind a section, for the low-sample note. */\nfunction sampleSize(value: unknown): number | null {\n  if (Array.isArray(value)) {\n    return (value as Array<Record<string, unknown>>).reduce((sum, row) => {\n      const n = row.total ?? row.count ?? row.executions ?? row.deployments;\n      return sum + (typeof n === 'number' ? n : 0);\n    }, 0);\n  }\n  const obj = value as Record<string, unknown> | null;\n  const envs = obj?.environments;\n  if (Array.isArray(envs)) {\n    return envs.reduce((sum: number, e) => {\n      const attempts = ((e as Record<string, unknown>).changeFailureRate as Record<string, unknown> | undefined)?.attempts;\n      return sum + (typeof attempts === 'number' ? attempts : 0);\n    }, 0);\n  }\n  return null;\n}\n\n/** Deploy-coverage notes: the difference between \"zero deploys\" and \"blind\". */\nfunction deployCoverageNotes(dora: unknown): DataQualityNote[] {\n  const notes: DataQualityNote[] = [];\n  const coverage = (dora as Record<string, unknown> | null)?.coverage as Record<string, unknown> | undefined;\n  const without = coverage?.withoutDeploys;\n  if (typeof without === 'number' && without > 0) {\n    notes.push({\n      code: 'missing_deploy_tag',\n      sectionId: 'dora',\n      message: `Deploy data unavailable for ${without} pipeline${without === 1 ? '' : 's'}: they have not re-synthed with deploy tags, so their deploys are not counted here. This is not \"zero deploys\".`,\n    });\n  }\n  const envs = (dora as Record<string, unknown> | null)?.environments;\n  if (Array.isArray(envs)) {\n    const noLead = (envs as Array<Record<string, unknown>>).filter((e) => {\n      const lt = e.leadTime as Record<string, unknown> | undefined;\n      return lt && lt.medianSeconds === null;\n    });\n    if (noLead.length > 0) {\n      notes.push({\n        code: 'missing_commit_data',\n        sectionId: 'dora',\n        message: `Lead time unavailable for ${noLead.length} environment${noLead.length === 1 ? '' : 's'}: no successful deploy carried a resolvable commit timestamp, so commit-to-deploy time could not be measured.`,\n      });\n    }\n  }\n  return notes;\n}\n\n/**\n * Compose one period's snapshot.\n *\n * Never throws for a section-level problem: a section that fails is marked\n * `failed` with a note, and the rest of the report still reaches the lead. A run\n * that produces nine good sections and one failure is useful; a run that produces\n * an exception is not.\n */\nexport async function composeSnapshot(sectionIdList: readonly string[], opts: ComposeOptions): Promise<ReportSnapshot> {\n  const { source, period, timezone, weekStart, orgId, orgIds, features } = opts;\n  const notes: DataQualityNote[] = [];\n  const sections: ComposedSection[] = [];\n\n  const ctxFor = (from: Date, to: Date): SectionContext => ({\n    orgId,\n    ...(orgIds ? { orgIds } : {}),\n    from: from.toISOString(),\n    to: to.toISOString(),\n    tz: timezone,\n    weekStart,\n    // The previous period travels WITH the context, for the analytics sections\n    // whose trend is per category, per stage or per pipeline. Those cannot be\n    // handled by running the section twice and comparing one headline — the\n    // comparison is a join, and doing it in the composer afterwards would mean\n    // re-implementing it for every shape.\n    previousFrom: period.prevStart.toISOString(),\n    previousTo: period.prevEnd.toISOString(),\n  });\n  const currentCtx = ctxFor(period.start, period.end);\n  const previousCtx = ctxFor(period.prevStart, period.prevEnd);\n\n  for (const id of sectionIdList) {\n    const spec: SectionSpec | undefined = getSection(id);\n    if (!spec) {\n      // An unknown id is a definition referencing a section that no longer exists.\n      // Recorded rather than dropped, so the lead can see why a panel vanished.\n      sections.push({ id, title: id, state: 'failed' });\n      notes.push({ code: 'section_failed', sectionId: id, message: `Unknown report section \"${id}\" — it may have been removed.` });\n      continue;\n    }\n\n    if (spec.requiresFeature && !satisfies(features, spec.requiresFeature)) {\n      sections.push({\n        id, title: spec.title, state: 'locked', requiresFeature: spec.requiresFeature,\n      });\n      notes.push({\n        code: 'section_locked',\n        sectionId: id,\n        message: `\"${spec.title}\" needs the ${spec.requiresFeature} add-on. The rest of this report is unaffected.`,\n      });\n      continue;\n    }\n\n    try {\n      const current = await spec.run(source, currentCtx);\n      const composed: ComposedSection = { id, title: spec.title, state: 'ok', current };\n\n      const head = headlineOf(id, current);\n      if (head) composed.headline = head;\n\n      if (spec.comparable) {\n        // The comparison is best-effort: a failed previous period must not cost the\n        // lead this period's numbers.\n        try {\n          const previous = await spec.run(source, previousCtx);\n          composed.previous = previous;\n          composed.change = changeOf(head, headlineOf(id, previous));\n        } catch {\n          composed.change = { absolute: 0, percent: null, direction: 'unknown' };\n        }\n      }\n\n      const sample = sampleSize(current);\n      if (sample !== null && sample > 0 && sample < LOW_SAMPLE_THRESHOLD) {\n        notes.push({\n          code: 'low_sample',\n          sectionId: id,\n          message: `\"${spec.title}\" is based on ${sample} observation${sample === 1 ? '' : 's'} — percentages swing wildly at this volume. Read the counts, not the rate.`,\n        });\n      }\n\n      if (id === 'dora') notes.push(...deployCoverageNotes(current));\n      sections.push(composed);\n    } catch (err) {\n      sections.push({ id, title: spec.title, state: 'failed' });\n      notes.push({\n        code: 'section_failed',\n        sectionId: id,\n        message: `\"${spec.title}\" could not be computed for this period. The rest of the report is unaffected.`,\n      });\n      void err; // the reason is logged by the caller, never shown to a manager\n    }\n  }\n\n  return {\n    period: { start: period.start.toISOString(), end: period.end.toISOString(), label: period.label },\n    previousPeriod: { start: period.prevStart.toISOString(), end: period.prevEnd.toISOString() },\n    timezone,\n    weekStart,\n    sections,\n    notes,\n    methodology:\n      `Computed from pipeline events between ${period.start.toISOString()} and ${period.end.toISOString()}, `\n      + `bucketed in ${timezone} with weeks starting ${weekStart}. Comparison period: `\n      + `${period.prevStart.toISOString()} to ${period.prevEnd.toISOString()}. `\n      + 'These are the same queries the dashboard runs over the same window, so the two agree.',\n    generatedAt: (opts.now ?? new Date()).toISOString(),\n  };\n}\n"]}

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

@@ -0,0 +1,14 @@
+/**
+ * The stakeholder-report engine: period resolution, the section registry, the
+ * templates, and the composer that turns them into a frozen snapshot.
+ *
+ * Enumerated rather than `export *` so the module's internals (the civil-date
+ * helpers, the headline heuristics) stay private — the same discipline
+ * reporting-service.ts applies to the reporting modules.
+ */
+export { resolvePeriod, resolvePeriodByLabel, rejectUnreportablePeriod, nextPeriodBoundary, completePeriodsSince, type ResolvedPeriod, type PeriodRejection, } from './period.js';
+export { registerSection, getSection, allSections, sectionIds, type SectionSpec, type SectionContext, type SectionDataSource, } from './sections.js';
+export { REPORT_TEMPLATE_SPECS, getTemplate, assertTemplatesResolve, type TemplateSpec, } from './templates.js';
+export { composeSnapshot, LOW_SAMPLE_THRESHOLD, REPORT_FEATURE_SUBSTITUTES, type ReportSnapshot, type ComposedSection, type DataQualityNote, type ComposeOptions, type TrendDirection, } from './compose.js';
+export { renderReportHtml, reportFileName, trendSentence, type ReportHtmlInput, } from './report-html.js';
+export { StakeholderReportStore, stakeholderReportStore, hashToken, mintToken, DEFAULT_SHARE_LINK_TTL_DAYS, MAX_SHARE_LINK_TTL_DAYS, MAX_BOUNCES, VERIFICATION_TTL_MS, type CreateDefinitionInput, type UpdateDefinitionInput, type MintedShareLink, type ResolvedShareLink, } from './store.js';

package/lib/api/reporting/stakeholder/index.js

@@ -0,0 +1,17 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The stakeholder-report engine: period resolution, the section registry, the
+ * templates, and the composer that turns them into a frozen snapshot.
+ *
+ * Enumerated rather than `export *` so the module's internals (the civil-date
+ * helpers, the headline heuristics) stay private — the same discipline
+ * reporting-service.ts applies to the reporting modules.
+ */
+export { resolvePeriod, resolvePeriodByLabel, rejectUnreportablePeriod, nextPeriodBoundary, completePeriodsSince, } from './period.js';
+export { registerSection, getSection, allSections, sectionIds, } from './sections.js';
+export { REPORT_TEMPLATE_SPECS, getTemplate, assertTemplatesResolve, } from './templates.js';
+export { composeSnapshot, LOW_SAMPLE_THRESHOLD, REPORT_FEATURE_SUBSTITUTES, } from './compose.js';
+export { renderReportHtml, reportFileName, trendSentence, } from './report-html.js';
+export { StakeholderReportStore, stakeholderReportStore, hashToken, mintToken, DEFAULT_SHARE_LINK_TTL_DAYS, MAX_SHARE_LINK_TTL_DAYS, MAX_BOUNCES, VERIFICATION_TTL_MS, } from './store.js';
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,102 @@
+/**
+ * Period resolution for scheduled reports: which complete week, month or quarter
+ * a run covers, and the one before it for comparison.
+ *
+ * A report covers the LAST COMPLETE period, never a partial one. "Deploys this
+ * week" on a Monday morning means last week — a manager reading a half-finished
+ * week sees numbers that change under them.
+ *
+ * Everything here is computed in the report's IANA timezone, without a date
+ * library. `Intl.DateTimeFormat` with a `timeZone` is the only tz database Node
+ * ships, so the approach is: read the wall-clock parts in that zone, do civil
+ * arithmetic on them (which is exact — months and quarters are defined on the
+ * calendar, not on elapsed milliseconds), then convert the resulting civil
+ * midnight back to a UTC instant by measuring the zone's offset AT that instant.
+ *
+ * Measuring the offset at the target instant rather than at `now` is what makes
+ * DST correct: a weekly period that starts before a transition and ends after it
+ * is not 168 hours long, and a resolver that added `7 * 24 * 3600_000` would
+ * silently shift every boundary by an hour for half the year.
+ */
+import type { ReportCadence } from '../../../database/schema/reporting-stakeholder.js';
+/** One resolved reporting period, plus the previous one for comparison. */
+export interface ResolvedPeriod {
+    /** Inclusive start of the period being reported (UTC instant). */
+    start: Date;
+    /** Exclusive end — also the start of the period in progress. */
+    end: Date;
+    /** Inclusive start of the PREVIOUS period, for period-over-period change. */
+    prevStart: Date;
+    /** Exclusive end of the previous period (=== `start`). */
+    prevEnd: Date;
+    /** Human label in the report's timezone: `2026-W38`, `2026-08`, `2026-Q3`. */
+    label: string;
+}
+/**
+ * Resolve the last COMPLETE period for `cadence` in `tz`.
+ *
+ * The period in progress is excluded: its end is the boundary, so a Monday run
+ * reports last week and a run on the 1st reports last month.
+ */
+export declare function resolvePeriod(cadence: ReportCadence, tz: string, weekStart?: 'monday' | 'sunday', now?: Date): ResolvedPeriod;
+/**
+ * Resolve a SPECIFIC period by its label (`2026-W38`, `2026-08`, `2026-Q3`), for
+ * on-demand runs and backfills. Returns null when the label does not parse or
+ * does not match the cadence.
+ */
+export declare function resolvePeriodByLabel(label: string, cadence: ReportCadence, tz: string, weekStart?: 'monday' | 'sunday'): ResolvedPeriod | null;
+/**
+ * Why a period cannot be reported. Returned rather than thrown so a route can
+ * turn it into a 4xx with the reason, and the scheduler can pause with it.
+ */
+export type PeriodRejection = {
+    reason: 'in_progress';
+    message: string;
+} | {
+    reason: 'before_retention';
+    message: string;
+};
+/**
+ * Refuse a period the org's data cannot support.
+ *
+ * A window older than the retention horizon must be REFUSED with the reason, not
+ * silently truncated: a report labelled `2026-Q1` that quietly covers only the
+ * last 30 days of it is worse than no report, because a manager cannot tell.
+ *
+ * `minFromMs` is the retention floor from `orgRetentionWindowFromSettings`
+ * (0 = unlimited).
+ */
+export declare function rejectUnreportablePeriod(period: ResolvedPeriod, opts: {
+    minFromMs: number;
+    now?: Date;
+    includePrevious?: boolean;
+}): PeriodRejection | null;
+/**
+ * The instant the period CONTAINING `from` ends — that is, the moment the next
+ * complete period becomes reportable.
+ *
+ * This is what a definition's `nextRunAt` is derived from, and it is deliberately
+ * the boundary rather than "last run + 7 days": a weekly report whose next run is
+ * computed by adding elapsed milliseconds drifts an hour at every DST transition
+ * and eventually fires on a Sunday. The boundary is a calendar fact in the
+ * report's own timezone, so it is the same answer whatever the previous run did.
+ *
+ * Strictly after `from`: a `from` sitting exactly on a boundary gets the NEXT one,
+ * so a run that completes at the instant of the boundary cannot re-claim it.
+ */
+export declare function nextPeriodBoundary(cadence: ReportCadence, tz: string, weekStart?: 'monday' | 'sunday', from?: Date): Date;
+/**
+ * Every COMPLETE period that ended after `since`, oldest first.
+ *
+ * This is the catch-up list: a service that was down over a weekend, a definition
+ * created with a back-dated `nextRunAt`, or a scheduler disabled by its kill switch
+ * for a fortnight all leave periods that were never reported. Returning them in
+ * order matters — a manager reading three weekly reports that arrive at once needs
+ * them to make sense read downwards.
+ *
+ * `max` bounds the walk. A definition untouched for two years must not produce 104
+ * weekly reports in one cycle; the cap means the oldest are skipped, which is the
+ * right trade — nobody wants last April's weekly status, and the snapshot for it
+ * would be past the retention horizon anyway.
+ */
+export declare function completePeriodsSince(cadence: ReportCadence, tz: string, weekStart: 'monday' | 'sunday', since: Date | null, now?: Date, max?: number): ResolvedPeriod[];