@pipeline-builder/pipeline-data 4.1.23 → 4.1.25

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

@@ -0,0 +1,273 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/** Read the wall-clock parts of `instant` as they read in `tz`. */
+function civilIn(instant, tz) {
+    // `en-CA` yields ISO-ish `YYYY-MM-DD`, and hourCycle h23 avoids a 24:00 hour.
+    const parts = new Intl.DateTimeFormat('en-CA', {
+        timeZone: tz,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hourCycle: 'h23',
+    }).formatToParts(instant);
+    const get = (type) => Number(parts.find((p) => p.type === type)?.value ?? '0');
+    return {
+        year: get('year'),
+        month: get('month'),
+        day: get('day'),
+        hour: get('hour'),
+        minute: get('minute'),
+        second: get('second'),
+    };
+}
+/**
+ * The UTC instant at which the given civil time occurs in `tz`.
+ *
+ * Two passes: guess by treating the civil time as UTC, measure how far that guess
+ * actually lands from the target in `tz`, correct, then re-measure once. The
+ * second pass matters exactly at a DST transition, where the first correction can
+ * overshoot into the other offset.
+ *
+ * For a civil midnight that does not exist (spring-forward skips it) this settles
+ * on the instant just after the gap, which is the start of the day as that zone
+ * experienced it — the right answer for a period boundary.
+ */
+function instantOfCivil(c, tz) {
+    const asUtc = Date.UTC(c.year, c.month - 1, c.day, 0, 0, 0);
+    let guess = asUtc;
+    for (let i = 0; i < 2; i++) {
+        const back = civilIn(new Date(guess), tz);
+        const backUtc = Date.UTC(back.year, back.month - 1, back.day, back.hour, back.minute, back.second);
+        const drift = backUtc - asUtc;
+        if (drift === 0)
+            break;
+        guess -= drift;
+    }
+    return new Date(guess);
+}
+/** 0 = Monday … 6 = Sunday, for a civil date (Zeller-free: use a UTC probe). */
+function civilWeekday(c) {
+    const dow = new Date(Date.UTC(c.year, c.month - 1, c.day)).getUTCDay(); // 0=Sun
+    return (dow + 6) % 7; // 0=Mon
+}
+/** Add `days` to a civil date, normalising via UTC arithmetic (no tz involved). */
+function addCivilDays(c, days) {
+    const d = new Date(Date.UTC(c.year, c.month - 1, c.day + days));
+    return { year: d.getUTCFullYear(), month: d.getUTCMonth() + 1, day: d.getUTCDate() };
+}
+/** Add `months` to a civil date, clamping the day into the target month. */
+function addCivilMonths(c, months) {
+    const zeroBased = (c.year * 12) + (c.month - 1) + months;
+    const year = Math.floor(zeroBased / 12);
+    const month = (zeroBased % 12) + 1;
+    const lastDay = new Date(Date.UTC(year, month, 0)).getUTCDate();
+    return { year, month, day: Math.min(c.day, lastDay) };
+}
+/** The civil start of the period containing `c`. */
+function startOfPeriod(c, cadence, weekStart) {
+    const date = { year: c.year, month: c.month, day: c.day };
+    if (cadence === 'weekly') {
+        const mondayIndex = civilWeekday(date);
+        // Sunday weeks start one day earlier than the Monday index implies.
+        const back = weekStart === 'sunday' ? (mondayIndex + 1) % 7 : mondayIndex;
+        return addCivilDays(date, -back);
+    }
+    if (cadence === 'monthly')
+        return { year: c.year, month: c.month, day: 1 };
+    // Quarterly: Jan/Apr/Jul/Oct.
+    const qStartMonth = Math.floor((c.month - 1) / 3) * 3 + 1;
+    return { year: c.year, month: qStartMonth, day: 1 };
+}
+/** Shift a civil period start by `n` whole periods. */
+function shiftPeriod(start, cadence, n) {
+    if (cadence === 'weekly')
+        return addCivilDays(start, 7 * n);
+    if (cadence === 'monthly')
+        return addCivilMonths(start, n);
+    return addCivilMonths(start, 3 * n);
+}
+/**
+ * ISO-8601 week number of a civil date. Used only for the weekly LABEL, and
+ * deliberately ISO even for a Sunday-week org: `2026-W38` is a recognised
+ * notation and inventing a Sunday-based numbering would make labels
+ * non-comparable with anything else.
+ */
+function isoWeek(c) {
+    const d = new Date(Date.UTC(c.year, c.month - 1, c.day));
+    const day = (d.getUTCDay() + 6) % 7; // 0=Mon
+    d.setUTCDate(d.getUTCDate() - day + 3); // nearest Thursday
+    const isoYear = d.getUTCFullYear();
+    const firstThursday = new Date(Date.UTC(isoYear, 0, 4));
+    const firstDay = (firstThursday.getUTCDay() + 6) % 7;
+    firstThursday.setUTCDate(firstThursday.getUTCDate() - firstDay + 3);
+    const week = 1 + Math.round((d.getTime() - firstThursday.getTime()) / (7 * 86_400_000));
+    return { year: isoYear, week };
+}
+/** The label for a period, from its civil start. */
+function formatLabel(start, cadence) {
+    if (cadence === 'weekly') {
+        const { year, week } = isoWeek(start);
+        return `${year}-W${String(week).padStart(2, '0')}`;
+    }
+    if (cadence === 'monthly')
+        return `${start.year}-${String(start.month).padStart(2, '0')}`;
+    return `${start.year}-Q${Math.floor((start.month - 1) / 3) + 1}`;
+}
+/**
+ * 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 function resolvePeriod(cadence, tz, weekStart = 'monday', now = new Date()) {
+    const nowCivil = civilIn(now, tz);
+    // Start of the period CONTAINING now = end of the last complete one.
+    const currentStart = startOfPeriod(nowCivil, cadence, weekStart);
+    const start = shiftPeriod(currentStart, cadence, -1);
+    const prevStart = shiftPeriod(currentStart, cadence, -2);
+    return {
+        start: instantOfCivil(start, tz),
+        end: instantOfCivil(currentStart, tz),
+        prevStart: instantOfCivil(prevStart, tz),
+        prevEnd: instantOfCivil(start, tz),
+        label: formatLabel(start, cadence),
+    };
+}
+/**
+ * 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 function resolvePeriodByLabel(label, cadence, tz, weekStart = 'monday') {
+    let start = null;
+    const week = /^(\d{4})-W(\d{2})$/.exec(label);
+    const month = /^(\d{4})-(\d{2})$/.exec(label);
+    const quarter = /^(\d{4})-Q([1-4])$/.exec(label);
+    if (cadence === 'weekly' && week) {
+        const year = Number(week[1]);
+        const wk = Number(week[2]);
+        if (wk < 1 || wk > 53)
+            return null;
+        // ISO week 1 contains Jan 4th; walk back to that week's start.
+        const jan4 = { year, month: 1, day: 4 };
+        const week1Start = startOfPeriod({ ...jan4, hour: 0, minute: 0, second: 0 }, 'weekly', weekStart);
+        start = addCivilDays(week1Start, (wk - 1) * 7);
+        // A 53rd week that does not exist in this ISO year lands in the next one.
+        if (isoWeek(start).year !== year && wk === 53)
+            return null;
+    }
+    else if (cadence === 'monthly' && month) {
+        const m = Number(month[2]);
+        if (m < 1 || m > 12)
+            return null;
+        start = { year: Number(month[1]), month: m, day: 1 };
+    }
+    else if (cadence === 'quarterly' && quarter) {
+        start = { year: Number(quarter[1]), month: (Number(quarter[2]) - 1) * 3 + 1, day: 1 };
+    }
+    if (!start)
+        return null;
+    const end = shiftPeriod(start, cadence, 1);
+    const prevStart = shiftPeriod(start, cadence, -1);
+    return {
+        start: instantOfCivil(start, tz),
+        end: instantOfCivil(end, tz),
+        prevStart: instantOfCivil(prevStart, tz),
+        prevEnd: instantOfCivil(start, tz),
+        label: formatLabel(start, cadence),
+    };
+}
+/**
+ * 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 function rejectUnreportablePeriod(period, opts) {
+    const now = opts.now ?? new Date();
+    if (period.end.getTime() > now.getTime()) {
+        return {
+            reason: 'in_progress',
+            message: `Period ${period.label} has not finished yet (ends ${period.end.toISOString()}). A report covers the last COMPLETE period.`,
+        };
+    }
+    if (opts.minFromMs > 0) {
+        // The comparison period is part of the report when a section shows change, so
+        // its start is the real floor — otherwise "vs last week" silently reads zero.
+        const earliest = opts.includePrevious === false ? period.start : period.prevStart;
+        if (earliest.getTime() < opts.minFromMs) {
+            return {
+                reason: 'before_retention',
+                message: `Period ${period.label} starts ${earliest.toISOString()}, before this organization's reporting retention horizon (${new Date(opts.minFromMs).toISOString()}). The underlying events have been purged.`,
+            };
+        }
+    }
+    return 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 function nextPeriodBoundary(cadence, tz, weekStart = 'monday', from = new Date()) {
+    const containing = startOfPeriod(civilIn(from, tz), cadence, weekStart);
+    return instantOfCivil(shiftPeriod(containing, cadence, 1), tz);
+}
+/**
+ * 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 function completePeriodsSince(cadence, tz, weekStart, since, now = new Date(), max = 4) {
+    const latest = resolvePeriod(cadence, tz, weekStart, now);
+    if (max <= 0)
+        return [];
+    // No previous run: report the latest complete period only. A definition created
+    // today does not owe its owner a backfill they never asked for.
+    if (!since)
+        return [latest];
+    const out = [];
+    const latestStart = startOfPeriod(civilIn(latest.start, tz), cadence, weekStart);
+    for (let back = 0; back < max; back += 1) {
+        const start = shiftPeriod(latestStart, cadence, -back);
+        const instant = instantOfCivil(start, tz);
+        // `since` is the last run's period END for a run that happened, so a period
+        // whose end is at or before it has already been reported.
+        if (instantOfCivil(shiftPeriod(start, cadence, 1), tz).getTime() <= since.getTime())
+            break;
+        const prevStart = shiftPeriod(start, cadence, -1);
+        out.push({
+            start: instant,
+            end: instantOfCivil(shiftPeriod(start, cadence, 1), tz),
+            prevStart: instantOfCivil(prevStart, tz),
+            prevEnd: instant,
+            label: formatLabel(start, cadence),
+        });
+    }
+    return out.reverse();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"period.js","sourceRoot":"","sources":["../../../../src/api/reporting/stakeholder/period.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Period resolution for scheduled reports: which complete week, month or quarter\n * a run covers, and the one before it for comparison.\n *\n * A report covers the LAST COMPLETE period, never a partial one. \"Deploys this\n * week\" on a Monday morning means last week — a manager reading a half-finished\n * week sees numbers that change under them.\n *\n * Everything here is computed in the report's IANA timezone, without a date\n * library. `Intl.DateTimeFormat` with a `timeZone` is the only tz database Node\n * ships, so the approach is: read the wall-clock parts in that zone, do civil\n * arithmetic on them (which is exact — months and quarters are defined on the\n * calendar, not on elapsed milliseconds), then convert the resulting civil\n * midnight back to a UTC instant by measuring the zone's offset AT that instant.\n *\n * Measuring the offset at the target instant rather than at `now` is what makes\n * DST correct: a weekly period that starts before a transition and ends after it\n * is not 168 hours long, and a resolver that added `7 * 24 * 3600_000` would\n * silently shift every boundary by an hour for half the year.\n */\n\nimport type { ReportCadence } from '../../../database/schema/reporting-stakeholder.js';\n\n/** One resolved reporting period, plus the previous one for comparison. */\nexport interface ResolvedPeriod {\n  /** Inclusive start of the period being reported (UTC instant). */\n  start: Date;\n  /** Exclusive end — also the start of the period in progress. */\n  end: Date;\n  /** Inclusive start of the PREVIOUS period, for period-over-period change. */\n  prevStart: Date;\n  /** Exclusive end of the previous period (=== `start`). */\n  prevEnd: Date;\n  /** Human label in the report's timezone: `2026-W38`, `2026-08`, `2026-Q3`. */\n  label: string;\n}\n\n/** Civil (wall-clock) date parts in a given zone. */\ninterface Civil { year: number; month: number; day: number; hour: number; minute: number; second: number }\n\n/** Read the wall-clock parts of `instant` as they read in `tz`. */\nfunction civilIn(instant: Date, tz: string): Civil {\n  // `en-CA` yields ISO-ish `YYYY-MM-DD`, and hourCycle h23 avoids a 24:00 hour.\n  const parts = new Intl.DateTimeFormat('en-CA', {\n    timeZone: tz,\n    year: 'numeric',\n    month: '2-digit',\n    day: '2-digit',\n    hour: '2-digit',\n    minute: '2-digit',\n    second: '2-digit',\n    hourCycle: 'h23',\n  }).formatToParts(instant);\n  const get = (type: string): number => Number(parts.find((p) => p.type === type)?.value ?? '0');\n  return {\n    year: get('year'),\n    month: get('month'),\n    day: get('day'),\n    hour: get('hour'),\n    minute: get('minute'),\n    second: get('second'),\n  };\n}\n\n/**\n * The UTC instant at which the given civil time occurs in `tz`.\n *\n * Two passes: guess by treating the civil time as UTC, measure how far that guess\n * actually lands from the target in `tz`, correct, then re-measure once. The\n * second pass matters exactly at a DST transition, where the first correction can\n * overshoot into the other offset.\n *\n * For a civil midnight that does not exist (spring-forward skips it) this settles\n * on the instant just after the gap, which is the start of the day as that zone\n * experienced it — the right answer for a period boundary.\n */\nfunction instantOfCivil(c: { year: number; month: number; day: number }, tz: string): Date {\n  const asUtc = Date.UTC(c.year, c.month - 1, c.day, 0, 0, 0);\n  let guess = asUtc;\n  for (let i = 0; i < 2; i++) {\n    const back = civilIn(new Date(guess), tz);\n    const backUtc = Date.UTC(back.year, back.month - 1, back.day, back.hour, back.minute, back.second);\n    const drift = backUtc - asUtc;\n    if (drift === 0) break;\n    guess -= drift;\n  }\n  return new Date(guess);\n}\n\n/** 0 = Monday … 6 = Sunday, for a civil date (Zeller-free: use a UTC probe). */\nfunction civilWeekday(c: { year: number; month: number; day: number }): number {\n  const dow = new Date(Date.UTC(c.year, c.month - 1, c.day)).getUTCDay(); // 0=Sun\n  return (dow + 6) % 7; // 0=Mon\n}\n\n/** Add `days` to a civil date, normalising via UTC arithmetic (no tz involved). */\nfunction addCivilDays(c: { year: number; month: number; day: number }, days: number): { year: number; month: number; day: number } {\n  const d = new Date(Date.UTC(c.year, c.month - 1, c.day + days));\n  return { year: d.getUTCFullYear(), month: d.getUTCMonth() + 1, day: d.getUTCDate() };\n}\n\n/** Add `months` to a civil date, clamping the day into the target month. */\nfunction addCivilMonths(c: { year: number; month: number; day: number }, months: number): { year: number; month: number; day: number } {\n  const zeroBased = (c.year * 12) + (c.month - 1) + months;\n  const year = Math.floor(zeroBased / 12);\n  const month = (zeroBased % 12) + 1;\n  const lastDay = new Date(Date.UTC(year, month, 0)).getUTCDate();\n  return { year, month, day: Math.min(c.day, lastDay) };\n}\n\n/** The civil start of the period containing `c`. */\nfunction startOfPeriod(\n  c: Civil,\n  cadence: ReportCadence,\n  weekStart: 'monday' | 'sunday',\n): { year: number; month: number; day: number } {\n  const date = { year: c.year, month: c.month, day: c.day };\n  if (cadence === 'weekly') {\n    const mondayIndex = civilWeekday(date);\n    // Sunday weeks start one day earlier than the Monday index implies.\n    const back = weekStart === 'sunday' ? (mondayIndex + 1) % 7 : mondayIndex;\n    return addCivilDays(date, -back);\n  }\n  if (cadence === 'monthly') return { year: c.year, month: c.month, day: 1 };\n  // Quarterly: Jan/Apr/Jul/Oct.\n  const qStartMonth = Math.floor((c.month - 1) / 3) * 3 + 1;\n  return { year: c.year, month: qStartMonth, day: 1 };\n}\n\n/** Shift a civil period start by `n` whole periods. */\nfunction shiftPeriod(\n  start: { year: number; month: number; day: number },\n  cadence: ReportCadence,\n  n: number,\n): { year: number; month: number; day: number } {\n  if (cadence === 'weekly') return addCivilDays(start, 7 * n);\n  if (cadence === 'monthly') return addCivilMonths(start, n);\n  return addCivilMonths(start, 3 * n);\n}\n\n/**\n * ISO-8601 week number of a civil date. Used only for the weekly LABEL, and\n * deliberately ISO even for a Sunday-week org: `2026-W38` is a recognised\n * notation and inventing a Sunday-based numbering would make labels\n * non-comparable with anything else.\n */\nfunction isoWeek(c: { year: number; month: number; day: number }): { year: number; week: number } {\n  const d = new Date(Date.UTC(c.year, c.month - 1, c.day));\n  const day = (d.getUTCDay() + 6) % 7; // 0=Mon\n  d.setUTCDate(d.getUTCDate() - day + 3); // nearest Thursday\n  const isoYear = d.getUTCFullYear();\n  const firstThursday = new Date(Date.UTC(isoYear, 0, 4));\n  const firstDay = (firstThursday.getUTCDay() + 6) % 7;\n  firstThursday.setUTCDate(firstThursday.getUTCDate() - firstDay + 3);\n  const week = 1 + Math.round((d.getTime() - firstThursday.getTime()) / (7 * 86_400_000));\n  return { year: isoYear, week };\n}\n\n/** The label for a period, from its civil start. */\nfunction formatLabel(start: { year: number; month: number; day: number }, cadence: ReportCadence): string {\n  if (cadence === 'weekly') {\n    const { year, week } = isoWeek(start);\n    return `${year}-W${String(week).padStart(2, '0')}`;\n  }\n  if (cadence === 'monthly') return `${start.year}-${String(start.month).padStart(2, '0')}`;\n  return `${start.year}-Q${Math.floor((start.month - 1) / 3) + 1}`;\n}\n\n/**\n * Resolve the last COMPLETE period for `cadence` in `tz`.\n *\n * The period in progress is excluded: its end is the boundary, so a Monday run\n * reports last week and a run on the 1st reports last month.\n */\nexport function resolvePeriod(\n  cadence: ReportCadence,\n  tz: string,\n  weekStart: 'monday' | 'sunday' = 'monday',\n  now: Date = new Date(),\n): ResolvedPeriod {\n  const nowCivil = civilIn(now, tz);\n  // Start of the period CONTAINING now = end of the last complete one.\n  const currentStart = startOfPeriod(nowCivil, cadence, weekStart);\n  const start = shiftPeriod(currentStart, cadence, -1);\n  const prevStart = shiftPeriod(currentStart, cadence, -2);\n  return {\n    start: instantOfCivil(start, tz),\n    end: instantOfCivil(currentStart, tz),\n    prevStart: instantOfCivil(prevStart, tz),\n    prevEnd: instantOfCivil(start, tz),\n    label: formatLabel(start, cadence),\n  };\n}\n\n/**\n * Resolve a SPECIFIC period by its label (`2026-W38`, `2026-08`, `2026-Q3`), for\n * on-demand runs and backfills. Returns null when the label does not parse or\n * does not match the cadence.\n */\nexport function resolvePeriodByLabel(\n  label: string,\n  cadence: ReportCadence,\n  tz: string,\n  weekStart: 'monday' | 'sunday' = 'monday',\n): ResolvedPeriod | null {\n  let start: { year: number; month: number; day: number } | null = null;\n\n  const week = /^(\\d{4})-W(\\d{2})$/.exec(label);\n  const month = /^(\\d{4})-(\\d{2})$/.exec(label);\n  const quarter = /^(\\d{4})-Q([1-4])$/.exec(label);\n\n  if (cadence === 'weekly' && week) {\n    const year = Number(week[1]);\n    const wk = Number(week[2]);\n    if (wk < 1 || wk > 53) return null;\n    // ISO week 1 contains Jan 4th; walk back to that week's start.\n    const jan4 = { year, month: 1, day: 4 };\n    const week1Start = startOfPeriod(\n      { ...jan4, hour: 0, minute: 0, second: 0 },\n      'weekly',\n      weekStart,\n    );\n    start = addCivilDays(week1Start, (wk - 1) * 7);\n    // A 53rd week that does not exist in this ISO year lands in the next one.\n    if (isoWeek(start).year !== year && wk === 53) return null;\n  } else if (cadence === 'monthly' && month) {\n    const m = Number(month[2]);\n    if (m < 1 || m > 12) return null;\n    start = { year: Number(month[1]), month: m, day: 1 };\n  } else if (cadence === 'quarterly' && quarter) {\n    start = { year: Number(quarter[1]), month: (Number(quarter[2]) - 1) * 3 + 1, day: 1 };\n  }\n  if (!start) return null;\n\n  const end = shiftPeriod(start, cadence, 1);\n  const prevStart = shiftPeriod(start, cadence, -1);\n  return {\n    start: instantOfCivil(start, tz),\n    end: instantOfCivil(end, tz),\n    prevStart: instantOfCivil(prevStart, tz),\n    prevEnd: instantOfCivil(start, tz),\n    label: formatLabel(start, cadence),\n  };\n}\n\n/**\n * Why a period cannot be reported. Returned rather than thrown so a route can\n * turn it into a 4xx with the reason, and the scheduler can pause with it.\n */\nexport type PeriodRejection =\n  | { reason: 'in_progress'; message: string }\n  | { reason: 'before_retention'; message: string };\n\n/**\n * Refuse a period the org's data cannot support.\n *\n * A window older than the retention horizon must be REFUSED with the reason, not\n * silently truncated: a report labelled `2026-Q1` that quietly covers only the\n * last 30 days of it is worse than no report, because a manager cannot tell.\n *\n * `minFromMs` is the retention floor from `orgRetentionWindowFromSettings`\n * (0 = unlimited).\n */\nexport function rejectUnreportablePeriod(\n  period: ResolvedPeriod,\n  opts: { minFromMs: number; now?: Date; includePrevious?: boolean },\n): PeriodRejection | null {\n  const now = opts.now ?? new Date();\n  if (period.end.getTime() > now.getTime()) {\n    return {\n      reason: 'in_progress',\n      message: `Period ${period.label} has not finished yet (ends ${period.end.toISOString()}). A report covers the last COMPLETE period.`,\n    };\n  }\n  if (opts.minFromMs > 0) {\n    // The comparison period is part of the report when a section shows change, so\n    // its start is the real floor — otherwise \"vs last week\" silently reads zero.\n    const earliest = opts.includePrevious === false ? period.start : period.prevStart;\n    if (earliest.getTime() < opts.minFromMs) {\n      return {\n        reason: 'before_retention',\n        message: `Period ${period.label} starts ${earliest.toISOString()}, before this organization's reporting retention horizon (${new Date(opts.minFromMs).toISOString()}). The underlying events have been purged.`,\n      };\n    }\n  }\n  return null;\n}\n\n/**\n * The instant the period CONTAINING `from` ends — that is, the moment the next\n * complete period becomes reportable.\n *\n * This is what a definition's `nextRunAt` is derived from, and it is deliberately\n * the boundary rather than \"last run + 7 days\": a weekly report whose next run is\n * computed by adding elapsed milliseconds drifts an hour at every DST transition\n * and eventually fires on a Sunday. The boundary is a calendar fact in the\n * report's own timezone, so it is the same answer whatever the previous run did.\n *\n * Strictly after `from`: a `from` sitting exactly on a boundary gets the NEXT one,\n * so a run that completes at the instant of the boundary cannot re-claim it.\n */\nexport function nextPeriodBoundary(\n  cadence: ReportCadence,\n  tz: string,\n  weekStart: 'monday' | 'sunday' = 'monday',\n  from: Date = new Date(),\n): Date {\n  const containing = startOfPeriod(civilIn(from, tz), cadence, weekStart);\n  return instantOfCivil(shiftPeriod(containing, cadence, 1), tz);\n}\n\n/**\n * Every COMPLETE period that ended after `since`, oldest first.\n *\n * This is the catch-up list: a service that was down over a weekend, a definition\n * created with a back-dated `nextRunAt`, or a scheduler disabled by its kill switch\n * for a fortnight all leave periods that were never reported. Returning them in\n * order matters — a manager reading three weekly reports that arrive at once needs\n * them to make sense read downwards.\n *\n * `max` bounds the walk. A definition untouched for two years must not produce 104\n * weekly reports in one cycle; the cap means the oldest are skipped, which is the\n * right trade — nobody wants last April's weekly status, and the snapshot for it\n * would be past the retention horizon anyway.\n */\nexport function completePeriodsSince(\n  cadence: ReportCadence,\n  tz: string,\n  weekStart: 'monday' | 'sunday',\n  since: Date | null,\n  now: Date = new Date(),\n  max = 4,\n): ResolvedPeriod[] {\n  const latest = resolvePeriod(cadence, tz, weekStart, now);\n  if (max <= 0) return [];\n  // No previous run: report the latest complete period only. A definition created\n  // today does not owe its owner a backfill they never asked for.\n  if (!since) return [latest];\n\n  const out: ResolvedPeriod[] = [];\n  const latestStart = startOfPeriod(civilIn(latest.start, tz), cadence, weekStart);\n  for (let back = 0; back < max; back += 1) {\n    const start = shiftPeriod(latestStart, cadence, -back);\n    const instant = instantOfCivil(start, tz);\n    // `since` is the last run's period END for a run that happened, so a period\n    // whose end is at or before it has already been reported.\n    if (instantOfCivil(shiftPeriod(start, cadence, 1), tz).getTime() <= since.getTime()) break;\n    const prevStart = shiftPeriod(start, cadence, -1);\n    out.push({\n      start: instant,\n      end: instantOfCivil(shiftPeriod(start, cadence, 1), tz),\n      prevStart: instantOfCivil(prevStart, tz),\n      prevEnd: instant,\n      label: formatLabel(start, cadence),\n    });\n  }\n  return out.reverse();\n}\n"]}

package/lib/api/reporting/stakeholder/report-html.d.ts

@@ -0,0 +1,93 @@
+/**
+ * The snapshot, as one self-contained HTML document — the input the PDF renderer prints.
+ *
+ * WHY HTML AND NOT A PDF LIBRARY. A layout engine we would have to teach about page
+ * breaks, table widths and font metrics is a second renderer to maintain; Chromium
+ * already has one. So the pipeline is snapshot -> HTML -> `Page.printToPDF`, and this
+ * file owns the first arrow. It is pure: a string in, a string out, no I/O, no clock, no
+ * database. That is what makes the PDF's content testable without a browser.
+ *
+ * SELF-CONTAINED, AND THAT IS A SECURITY PROPERTY, not tidiness. No <script>, no
+ * stylesheet link, no web font, no image URL — everything is inline. The renderer loads
+ * this through `setContent` with the page offline, so a document that referenced anything
+ * external would either hang or quietly render without it. Stated here because the
+ * temptation to add a logo by URL will come up, and it would be the one change that gives
+ * the renderer a reason to talk to the network.
+ *
+ * EVERY INTERPOLATION IS ESCAPED. The snapshot carries org-controlled text — pipeline
+ * names, a lead's notes, a section title — into markup that a browser then parses. That
+ * is the same boundary as any XSS sink, and it does not stop mattering because the output
+ * is a PDF: unescaped notes could close a tag and rewrite the rest of the report, which is
+ * a document-forgery bug in a document people make decisions from. `esc()` is applied at
+ * every single insertion point and there is no "trusted" caller.
+ *
+ * NO COLOUR-ONLY MEANING, and no bare glyph carrying information (WCAG 1.4.1 / 1.1.1). A
+ * locked panel says "Not on your plan" in words; a trend says "down 3 points" in words
+ * rather than leaning on an arrow. There are no charts in a snapshot today — every section
+ * renders as a number, a word and a table row — so the plan's "alt text on charts" has
+ * nothing to attach to yet. The rule that replaces it is stricter and survives a chart
+ * being added later: if a reader with no colour vision, no images and a screen reader
+ * cannot get a fact out of this document, the fact is not in it.
+ */
+import type { ComposedSection, ReportSnapshot } from './compose.js';
+/** What the renderer needs to produce one report document. */
+export interface ReportHtmlInput {
+    /** The definition's name. Heads the document. */
+    title: string;
+    periodLabel: string;
+    periodStart: string;
+    periodEnd: string;
+    /** Regenerations are normal; a reader must be able to tell which one they hold. */
+    version: number;
+    publishedAt?: string | null;
+    /** The lead's own words. Rendered ABOVE the numbers — see the ordering note below. */
+    leadNotes?: string | null;
+    /**
+     * The AI-drafted executive summary, when the run has one and the caller is allowed to
+     * see it. Never fetched here: a caller that should not disclose it simply omits it.
+     */
+    executiveSummary?: string | null;
+    snapshot: ReportSnapshot | null;
+    /** True when pipeline/project names were replaced — said in the document, not implied. */
+    namesRedacted?: boolean;
+    /** Shown in the footer of a shared copy, so a bookmarked link's death is not a surprise. */
+    expiresAt?: string | null;
+    /**
+     * Stamped in the footer as the moment the FILE was made, distinct from the snapshot's
+     * own `generatedAt`. Two dates because they answer different questions: "is this report
+     * current?" and "is this the copy I was sent?".
+     */
+    renderedAt: string;
+}
+/**
+ * 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 declare function trendSentence(section: ComposedSection): string | null;
+/**
+ * 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 declare function renderReportHtml(input: ReportHtmlInput): string;
+/**
+ * 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 declare function reportFileName(title: string, periodLabel: string, version: number): string;