@arcfusionz/arc-analytic-ui 0.0.0

package/dist/components/StatusCard/StatusCard.model.js

@@ -0,0 +1,776 @@
+import { formatDate, formatDateRange, formatNumber, parseArcNumberFormat } from "../../lib/vega/formatters.js";
+import { resolveInstant, zonedDayStart } from "../../lib/vega/time.js";
+//#region src/components/StatusCard/StatusCard.model.ts
+const SECOND_MS = 1e3;
+const MINUTE_MS = 6e4;
+const HOUR_MS = 36e5;
+const DAY_MS = 864e5;
+const WEEK_MS = 7 * DAY_MS;
+const DATE_ONLY = /^(\d{4})-(\d{2})-(\d{2})$/;
+/** Every level in ladder order — the order the key row and the table use. */
+const STATUS_LEVELS = [
+	"operational",
+	"degraded",
+	"down",
+	"maintenance",
+	"unknown"
+];
+/**
+* How bad each level is. A strip cell takes the WORST level it overlaps, so
+* an outage can never be averaged away by the operational time around it; a
+* gap in monitoring outranks planned work, because "we don't know" is worse
+* news than "we took it down on purpose".
+*/
+const STATUS_SEVERITY = {
+	operational: 0,
+	maintenance: 1,
+	unknown: 2,
+	degraded: 3,
+	down: 4
+};
+/** Levels that count as an incident: something was wrong and nobody planned it. */
+const INCIDENT_LEVELS = ["degraded", "down"];
+/**
+* The state machine. Error wins; loading over existing data is a refresh (the
+* previous render stays under the veil); a missing level is `no-match` when
+* the consumer's filter caused it and `empty` otherwise; a level with no run
+* behind it is `insufficient` — the card reports the state and says it has no
+* history rather than drawing a single cell as if it were one.
+*/
+function deriveStatusState({ status, hasLevel, hasHistory, hasData, filtered }) {
+	if (status === "error") return "error";
+	if (status === "loading") return hasData ? "refreshing" : "loading";
+	if (hasLevel) return hasHistory ? "ready" : "insufficient";
+	return filtered ? "no-match" : "empty";
+}
+/**
+* The strip's domain. An explicit `window` wins; otherwise it spans the
+* history — from the first reported start to the last reported end, extended
+* to `asOf` when the card knows when it was last true, so a still-running
+* state reaches the right-hand edge. `null` when there is nothing to span or
+* the bounds have no length.
+*/
+function resolveStatusWindow(window, history, asOf, timeZone) {
+	const bounded = (start, end) => Number.isFinite(start) && Number.isFinite(end) && end > start ? {
+		start,
+		end,
+		span: end - start
+	} : null;
+	if (window) {
+		const declared = typeof window.end === "string" && DATE_ONLY.test(window.end) ? resolveInstant(window.end, timeZone) + DAY_MS : resolveInstant(window.end, timeZone);
+		const start = resolveInstant(window.start, timeZone);
+		return bounded(start, asOf != null && asOf > start && asOf < declared ? asOf : declared);
+	}
+	if (!history?.length) return null;
+	let start = Infinity;
+	let end = -Infinity;
+	for (const period of history) {
+		const from = resolveInstant(period.start, timeZone);
+		if (!Number.isFinite(from)) continue;
+		start = Math.min(start, from);
+		end = Math.max(end, from);
+		if (period.end != null) {
+			const to = resolveInstant(period.end, timeZone);
+			if (Number.isFinite(to)) end = Math.max(end, to);
+		}
+	}
+	if (asOf != null) end = Math.max(end, asOf);
+	return bounded(start, end);
+}
+/**
+* The reported states as one contiguous run across the window: resolved to
+* instants, sorted, clipped to the window, implicit ends closed by the next
+* start, overlaps resolved in favour of the later report (a correction
+* supersedes what it corrects), holes filled with explicit `unknown` segments
+* — a gap in monitoring is a fact, not a blank — and neighbours at the same
+* level merged so the run reads as states rather than as reports.
+*/
+function normalizeHistory(history, window, timeZone) {
+	const reported = (history ?? []).map((period) => ({
+		level: period.level,
+		start: resolveInstant(period.start, timeZone),
+		end: period.end == null ? null : resolveInstant(period.end, timeZone),
+		label: period.label
+	})).filter((period) => Number.isFinite(period.start) && (period.end == null || Number.isFinite(period.end)) && STATUS_SEVERITY[period.level] != null).sort((a, b) => a.start - b.start);
+	const placed = [];
+	for (let index = 0; index < reported.length; index += 1) {
+		const period = reported[index];
+		const next = reported[index + 1];
+		const closed = period.end ?? next?.start ?? window.end;
+		const start = Math.max(window.start, period.start);
+		const end = Math.min(window.end, closed, next ? Math.max(next.start, start) : closed);
+		if (!(end > start)) continue;
+		placed.push({
+			level: period.level,
+			start,
+			end,
+			duration: end - start,
+			...period.label ? { label: period.label } : {}
+		});
+	}
+	const filled = [];
+	let cursor = window.start;
+	const gap = (start, end) => ({
+		level: "unknown",
+		start,
+		end,
+		duration: end - start,
+		gap: true
+	});
+	for (const segment of placed) {
+		if (segment.start > cursor) filled.push(gap(cursor, segment.start));
+		filled.push(segment);
+		cursor = segment.end;
+	}
+	if (cursor < window.end) filled.push(gap(cursor, window.end));
+	const merged = [];
+	for (const segment of filled) {
+		const previous = merged.at(-1);
+		if (previous && previous.level === segment.level && previous.gap === segment.gap) {
+			previous.end = segment.end;
+			previous.duration = previous.end - previous.start;
+			if (!previous.label && segment.label) previous.label = segment.label;
+			continue;
+		}
+		merged.push({ ...segment });
+	}
+	return merged;
+}
+function worstOf(levels) {
+	return levels.reduce((worst, level) => STATUS_SEVERITY[level] > STATUS_SEVERITY[worst] ? level : worst, "operational");
+}
+/** The `degraded` / `down` runs inside a normalised run. */
+function deriveIncidents(segments) {
+	const incidents = [];
+	let current = null;
+	for (const segment of segments) {
+		if (!INCIDENT_LEVELS.includes(segment.level)) {
+			current = null;
+			continue;
+		}
+		const level = segment.level;
+		const downtime = level === "down" ? segment.duration : 0;
+		if (current) {
+			current.end = segment.end;
+			current.duration = current.end - current.start;
+			current.downtime += downtime;
+			if (STATUS_SEVERITY[level] > STATUS_SEVERITY[current.level]) current.level = level;
+			if (!current.label && segment.label) current.label = segment.label;
+			continue;
+		}
+		current = {
+			start: segment.start,
+			end: segment.end,
+			duration: segment.duration,
+			level,
+			downtime,
+			...segment.label ? { label: segment.label } : {}
+		};
+		incidents.push(current);
+	}
+	return incidents;
+}
+/**
+* Everything the card reports, measured on the exact segments — never on the
+* strip's cells, so the figures stay true however coarsely the strip has to
+* draw. `null` when there is no window to measure over.
+*
+* A reported `level` is the current state, appended to the history as a
+* still-running period: from `since` when the consumer knows when it began,
+* otherwise from wherever the history stops — so the strip's right-hand edge
+* always agrees with the word in the headline instead of contradicting it.
+* With no `level` at all, the current state is read off the end of the run.
+*/
+function deriveStatusRun({ level, since, history, window, asOf = null, uptimeTarget, mode = "monitored", timeZone }) {
+	const explicitSince = since == null ? null : resolveInstant(since, timeZone);
+	const sinceMsGiven = explicitSince != null && Number.isFinite(explicitSince) ? explicitSince : null;
+	const currentStart = sinceMsGiven ?? lastReportedInstant(history, timeZone);
+	const bounds = resolveStatusWindow(window, level != null && currentStart != null ? [...history ?? [], {
+		level,
+		start: currentStart
+	}] : history, asOf, timeZone);
+	if (!bounds) return null;
+	const segments = normalizeHistory([...(history ?? []).flatMap((period) => {
+		if (sinceMsGiven == null) return [period];
+		const start = resolveInstant(period.start, timeZone);
+		if (!Number.isFinite(start) || start >= sinceMsGiven) return [];
+		const end = period.end == null ? sinceMsGiven : Math.min(resolveInstant(period.end, timeZone), sinceMsGiven);
+		return [{
+			...period,
+			end
+		}];
+	}), ...level != null ? [{
+		level,
+		start: currentStart ?? bounds.start
+	}] : []], bounds, timeZone);
+	if (segments.length === 0) return null;
+	const durations = {
+		operational: 0,
+		degraded: 0,
+		down: 0,
+		maintenance: 0,
+		unknown: 0
+	};
+	for (const segment of segments) durations[segment.level] += segment.duration;
+	const last = segments.at(-1);
+	const currentLevel = level ?? last.level;
+	let sinceMs = last.start;
+	for (let index = segments.length - 1; index >= 0; index -= 1) {
+		if (segments[index].level !== currentLevel) break;
+		sinceMs = segments[index].start;
+	}
+	const incidents = deriveIncidents(segments);
+	const longestIncident = incidents.reduce((longest, incident) => longest == null || incident.duration > longest.duration ? incident : longest, null);
+	const excluded = durations.maintenance + durations.unknown;
+	const monitored = mode === "window" ? bounds.span : bounds.span - excluded;
+	const uptime = monitored > 0 ? durations.operational / monitored : null;
+	const target = typeof uptimeTarget === "number" && Number.isFinite(uptimeTarget) && uptimeTarget > 0 && uptimeTarget <= 1 ? uptimeTarget : null;
+	const sla = target != null && uptime != null ? (() => {
+		const allowed = Math.round(monitored * (1 - target));
+		const used = Math.round(monitored - durations.operational);
+		return {
+			target,
+			verdict: uptime >= target ? "met" : "missed",
+			allowed,
+			used,
+			remaining: Math.max(0, allowed - used),
+			consumed: allowed > 0 ? used / allowed : used > 0 ? Infinity : 0
+		};
+	})() : null;
+	return {
+		window: bounds,
+		segments,
+		durations,
+		level: currentLevel,
+		since: sinceMs,
+		sinceDuration: bounds.end - sinceMs,
+		sinceClipped: sinceMs <= bounds.start,
+		worst: worstOf(segments.map((segment) => segment.level)),
+		incidents,
+		longestIncident,
+		downtime: durations.down,
+		excluded,
+		monitored,
+		uptime,
+		mode,
+		sla,
+		polarity: sla ? sla.verdict === "met" ? "positive" : "negative" : "neutral"
+	};
+}
+/** The last instant the reported history reaches, or `null` when it reports nothing. */
+function lastReportedInstant(history, timeZone) {
+	let latest = null;
+	for (const period of history ?? []) for (const bound of [period.start, period.end]) {
+		if (bound == null) continue;
+		const instant = resolveInstant(bound, timeZone);
+		if (Number.isFinite(instant) && (latest == null || instant > latest)) latest = instant;
+	}
+	return latest;
+}
+/**
+* The current state's age. From the run when there is one; from `since`
+* against `asOf` when the card has a level but no window to draw (the
+* `insufficient` state still owes the reader "how long"). `null` when nothing
+* pins the moment it began.
+*/
+function resolveStatusHold({ run, since, asOf, timeZone }) {
+	if (run) return {
+		since: run.since,
+		duration: run.sinceDuration,
+		atLeast: run.sinceClipped
+	};
+	if (since == null || asOf == null) return null;
+	const from = resolveInstant(since, timeZone);
+	if (!Number.isFinite(from) || asOf < from) return null;
+	return {
+		since: from,
+		duration: asOf - from,
+		atLeast: false
+	};
+}
+const STEP_LADDER = [
+	MINUTE_MS,
+	5 * MINUTE_MS,
+	15 * MINUTE_MS,
+	HOUR_MS,
+	6 * HOUR_MS,
+	12 * HOUR_MS,
+	DAY_MS,
+	2 * DAY_MS,
+	3 * DAY_MS,
+	WEEK_MS
+];
+const NAMED_STEPS = {
+	minute: MINUTE_MS,
+	hour: HOUR_MS,
+	day: DAY_MS,
+	week: WEEK_MS
+};
+/** The hue a level paints with, from the theme's status ladder. */
+function statusHue(tokens, level) {
+	return tokens.status[level];
+}
+const STEP_KEYS = [
+	[MINUTE_MS, "minute"],
+	[5 * MINUTE_MS, "5-minute"],
+	[15 * MINUTE_MS, "15-minute"],
+	[HOUR_MS, "hour"],
+	[6 * HOUR_MS, "6-hour"],
+	[12 * HOUR_MS, "12-hour"],
+	[DAY_MS, "day"],
+	[2 * DAY_MS, "2-day"],
+	[3 * DAY_MS, "3-day"],
+	[WEEK_MS, "week"]
+];
+/** The resolved granularity as a word — the value of `data-resolution`. */
+function statusStepKey(step) {
+	if (step == null) return "exact";
+	return STEP_KEYS.find(([size]) => size === step)?.[1] ?? `${step}ms`;
+}
+/**
+* Buckets ≥ 1 hour align to the zone's calendar so a "day" cell is a day a
+* reader recognises rather than a 24-hour block starting whenever monitoring
+* did; the first cell is clipped back to the window.
+*/
+function alignStepStart(instant, step, timeZone) {
+	if (step < HOUR_MS) return Math.floor(instant / step) * step;
+	if (step < DAY_MS) {
+		const dayStart = zonedDayStart(instant, timeZone);
+		return dayStart + Math.floor((instant - dayStart) / step) * step;
+	}
+	const dayStart = zonedDayStart(instant, timeZone);
+	if (step === DAY_MS) return dayStart;
+	return dayStart;
+}
+/**
+* The rows the strip draws. `exact` emits the true segments; every other
+* resolution divides the window into equal cells, each painted the worst
+* level it overlaps — the Statuspage rule, and the only way a 40-second
+* outage in a 90-day window is visible at all. `auto` takes the finest step
+* from the ladder whose cells still clear `minCellPx` at the measured width,
+* so a narrow tile degrades to coarser cells instead of to sub-pixel slivers.
+*
+* Cells are inset by a share of their own pitch so touching fills stay apart
+* without a stroke eating a narrow cell, and each row keeps its true bounds
+* and its true per-level durations for the tooltip — the drawing rounds, the
+* numbers never do.
+*/
+function buildStatusStrip({ run, resolution, tokens, plotWidth, minCellPx, gapRatio, gapMinPx, gapMaxPx, timeZone }) {
+	const { window, segments } = run;
+	const msPerPx = plotWidth > 0 ? window.span / plotWidth : 0;
+	const emptyDurations = () => ({
+		operational: 0,
+		degraded: 0,
+		down: 0,
+		maintenance: 0,
+		unknown: 0
+	});
+	const step = resolveStep(resolution, window.span, plotWidth, minCellPx);
+	const granularity = step == null || step < DAY_MS ? "datetime" : "day";
+	const axisGranularity = window.span > 2 * DAY_MS ? "day-short" : window.span > 12 * HOUR_MS ? "day-time" : "time";
+	const cells = [];
+	if (step == null) for (const segment of segments) cells.push({
+		from: segment.start,
+		to: segment.end
+	});
+	else {
+		let cursor = alignStepStart(window.start, step, timeZone);
+		while (cursor < window.end) {
+			const from = Math.max(window.start, cursor);
+			const to = Math.min(window.end, cursor + step);
+			if (to > from) cells.push({
+				from,
+				to
+			});
+			cursor += step;
+		}
+	}
+	let cursorIndex = 0;
+	return {
+		rows: cells.map(({ from, to }) => {
+			const durations = emptyDurations();
+			let label;
+			while (cursorIndex > 0 && segments[cursorIndex - 1].end > from) cursorIndex -= 1;
+			for (let index = cursorIndex; index < segments.length; index += 1) {
+				const segment = segments[index];
+				if (segment.start >= to) break;
+				if (segment.end <= from) {
+					cursorIndex = index + 1;
+					continue;
+				}
+				durations[segment.level] += Math.min(segment.end, to) - Math.max(segment.start, from);
+				if (!label && segment.label) label = segment.label;
+			}
+			const level = worstOf(Object.keys(durations).filter((candidate) => durations[candidate] > 0));
+			const pitchPx = msPerPx > 0 ? (to - from) / msPerPx : 0;
+			const gapPx = Math.min(gapMaxPx, Math.max(gapMinPx, pitchPx * gapRatio));
+			const inset = Math.min(gapPx * msPerPx, (to - from) / 2);
+			return {
+				start: from + inset / 2,
+				end: to - inset / 2,
+				from,
+				to,
+				level,
+				c: statusHue(tokens, level),
+				durations,
+				...label ? { label } : {}
+			};
+		}),
+		step,
+		granularity,
+		axisGranularity
+	};
+}
+/** The bucket width, or `null` for exact segments. Exported for the unit tests. */
+function resolveStep(resolution, span, plotWidth, minCellPx) {
+	if (resolution === "exact") return null;
+	if (resolution !== "auto") return NAMED_STEPS[resolution];
+	const budget = plotWidth > 0 ? Math.max(1, Math.floor(plotWidth / minCellPx)) : 1;
+	for (const candidate of STEP_LADDER) if (Math.ceil(span / candidate) <= budget) return candidate;
+	return Math.max(MINUTE_MS, Math.ceil(span / budget / MINUTE_MS) * MINUTE_MS);
+}
+/**
+* A duration in the two most significant units it has — `6d 4h`, `2h 14m`,
+* `41m`, `18s`. Precision to the decision (Few's pitfall #3): nobody pages
+* anyone over the seconds of a six-day uptime. Units come from `labels` so a
+* Thai product reads in Thai; `Intl.DurationFormat` is deliberately not used
+* — it is too new to rely on across the runtimes this package supports.
+*/
+function formatDuration(ms, { units, locale, maxUnits = 2, zero }) {
+	if (ms == null || !Number.isFinite(ms)) return "—";
+	const total = Math.max(0, Math.round(ms));
+	if (total === 0) return zero;
+	const ladder = [
+		[DAY_MS, units.day],
+		[HOUR_MS, units.hour],
+		[MINUTE_MS, units.minute],
+		[SECOND_MS, units.second]
+	];
+	const parts = [];
+	let rest = total;
+	for (const [size, unit] of ladder) {
+		if (parts.length >= maxUnits) break;
+		const count = Math.floor(rest / size);
+		if (count === 0 && parts.length === 0) continue;
+		if (count > 0) parts.push(`${formatNumber(count, "integer", locale)}${unit}`);
+		rest -= count * size;
+	}
+	return parts.length > 0 ? parts.join(" ") : `${formatNumber(1, "integer", locale)}${units.second}`;
+}
+/** One grammar for every surface, so the same duration or share never reads two ways. */
+function createStatusFormatters({ uptimeFormat, formatUptimeValue, units, zeroDuration, locale, timeZone }) {
+	const uptimeDigits = parseArcNumberFormat(uptimeFormat).digits;
+	const uptimeExtra = uptimeDigits == null ? void 0 : { minimumFractionDigits: uptimeDigits };
+	return {
+		formatUptime: (value) => value == null || !Number.isFinite(value) ? "—" : formatUptimeValue ? formatUptimeValue(value) : formatNumber(value, uptimeFormat, locale, uptimeExtra),
+		formatDuration: (ms) => formatDuration(ms, {
+			units,
+			locale,
+			zero: zeroDuration
+		}),
+		formatInstant: (instant, granularity = "day") => instant == null ? "—" : formatDate(instant, {
+			granularity,
+			locale,
+			timeZone
+		}),
+		formatSpan: (from, to, granularity = "day") => formatDateRange(from, to, {
+			granularity,
+			locale,
+			timeZone
+		})
+	};
+}
+const DEFAULT_STATUS_LABELS = {
+	levelNames: {
+		operational: "Operational",
+		degraded: "Degraded",
+		down: "Down",
+		maintenance: "Maintenance",
+		unknown: "No data"
+	},
+	heldFor: (duration) => `for ${duration}`,
+	heldAtLeast: (duration) => `for over ${duration}`,
+	uptimeOver: (span) => `uptime · ${span}`,
+	vsTarget: (target, met) => `${target} target ${met ? "met" : "missed"}`,
+	uptime: "Uptime",
+	monitored: "Monitored",
+	window: "Window",
+	incidents: (count, n) => `${count} ${n === 1 ? "incident" : "incidents"}`,
+	downFor: (duration) => `${duration} down`,
+	budgetLeft: (duration) => `${duration} budget left`,
+	budgetOver: (duration) => `${duration} over budget`,
+	currentRow: "Current",
+	sinceRow: "Since",
+	durationRow: "Duration",
+	worstRow: "Worst in window",
+	incidentsRow: "Incidents",
+	longestIncidentRow: "Longest incident",
+	downtimeRow: "Downtime",
+	excludedRow: "Excluded",
+	targetRow: "Target",
+	budgetRow: "Error budget",
+	stripRow: "Strip",
+	resolutionNote: (step) => `worst status per ${step}`,
+	exactNote: "exact state durations",
+	verdictNames: {
+		met: "Target met",
+		missed: "Target missed"
+	},
+	tableItem: "Item",
+	tableValue: "Value",
+	incidentTableWhen: "When",
+	incidentTableLevel: "State",
+	incidentTableFor: "For",
+	incidentTableCaption: (name) => `Incidents in ${name}`,
+	noIncidents: "No incidents",
+	durationUnits: {
+		day: "d",
+		hour: "h",
+		minute: "m",
+		second: "s"
+	},
+	zeroDuration: "none",
+	noData: "No data",
+	noMatch: "No matching data",
+	clearFilters: "Clear filters",
+	error: "Couldn't load this status",
+	retry: "Try again",
+	noHistory: "No history yet",
+	stale: "Stale",
+	asOf: "As of",
+	showTable: (name) => `Show the details behind ${name}`,
+	hideTable: (name) => `Hide the details behind ${name}`,
+	about: (name) => `About ${name}`,
+	loading: (name) => `Loading ${name}`,
+	tableCaption: (name) => `Availability details of ${name}`,
+	uptimeGroup: (name) => `${name} availability`,
+	levelGroup: (name) => `${name} status`,
+	insightMark: "Insight",
+	explanation: ({ uptimeText, spanText, monitoredText, mode, excludedText, downtimeText, incidentsText, sla }) => {
+		const rows = [[DEFAULT_STATUS_LABELS.uptime, uptimeText], [DEFAULT_STATUS_LABELS.window, spanText]];
+		if (mode === "monitored") rows.push([DEFAULT_STATUS_LABELS.monitored, monitoredText]);
+		if (excludedText) rows.push([DEFAULT_STATUS_LABELS.excludedRow, excludedText]);
+		rows.push([DEFAULT_STATUS_LABELS.downtimeRow, downtimeText]);
+		rows.push([DEFAULT_STATUS_LABELS.incidentsRow, incidentsText]);
+		if (sla) {
+			rows.push([DEFAULT_STATUS_LABELS.targetRow, `${sla.targetText} (${sla.verdictText})`]);
+			rows.push([DEFAULT_STATUS_LABELS.budgetRow, sla.over ? DEFAULT_STATUS_LABELS.budgetOver(sla.remainingText) : DEFAULT_STATUS_LABELS.budgetLeft(sla.remainingText)]);
+		}
+		return rows;
+	},
+	levelSentence: ({ name, level, duration, atLeast }) => `${name}: ${level} ${atLeast ? DEFAULT_STATUS_LABELS.heldAtLeast(duration) : DEFAULT_STATUS_LABELS.heldFor(duration)}.`,
+	uptimeSentence: ({ uptime, span, monitored, mode }) => mode === "monitored" && monitored !== span ? `${uptime} uptime over ${span}, ${monitored} monitored.` : `${uptime} uptime over ${span}.`,
+	incidentSentence: ({ count, countText, downtime, longest }) => count === 0 ? "No incidents." : `${countText} ${count === 1 ? "incident" : "incidents"}, ${downtime} down${longest ? `, longest ${longest}` : ""}.`,
+	slaSentence: ({ target, met, remaining, over }) => `${target} target ${met ? "met" : "missed"}: ${over ? `${remaining} over budget` : `${remaining} of error budget left`}.`,
+	windowSentence: ({ range }) => `Window ${range}.`,
+	chartDescription: ({ name, rangeText, resolutionText, levels, incidents }) => `Status timeline of ${name} over ${rangeText}, ${resolutionText}: ${levels.map(([level, duration]) => `${level.toLowerCase()} ${duration}`).join(", ")}. ${incidents}`
+};
+function resolveStatusLabels(overrides) {
+	return overrides ? {
+		...DEFAULT_STATUS_LABELS,
+		...overrides
+	} : DEFAULT_STATUS_LABELS;
+}
+/** The levels present in the window, in ladder order, with their durations — the key row, the table and the descriptions all read from this. */
+function statusLevelBreakdown(run, formatters, labels) {
+	return STATUS_LEVELS.filter((level) => run.durations[level] > 0).map((level) => ({
+		level,
+		name: labels.levelNames[level],
+		duration: run.durations[level],
+		durationText: formatters.formatDuration(run.durations[level])
+	}));
+}
+/**
+* A strip cell's span as the tooltip states it. A bucket's `end` is EXCLUSIVE,
+* so at day granularity a single-day cell would read "Sep 2 – 3, 2026" — two
+* days for one cell. Closing the range on the last instant the cell actually
+* covers collapses it to "Sep 2, 2026" and turns a three-day cell into
+* "Jun 12 – 14, 2026". Sub-day cells keep the exclusive bound, where
+* "12:00 AM – 12:00 PM" reads better than "12:00 AM – 11:59 AM".
+*/
+function formatStripCell(row, strip, formatters) {
+	const inclusive = strip.step != null && strip.granularity === "day";
+	return formatters.formatSpan(row.from, inclusive ? row.to - 1 : row.to, strip.granularity);
+}
+/** How the strip's granularity is stated, in words. */
+function describeResolution(strip, formatters, labels) {
+	return strip.step == null ? labels.exactNote : labels.resolutionNote(formatters.formatDuration(strip.step));
+}
+/** The rows behind the availability badge — hover, and `aria-describedby`. */
+function buildStatusExplanation({ run, formatters, labels }) {
+	return labels.explanation({
+		uptimeText: formatters.formatUptime(run.uptime),
+		spanText: formatters.formatDuration(run.window.span),
+		monitoredText: formatters.formatDuration(run.monitored),
+		mode: run.mode,
+		excludedText: run.excluded > 0 ? formatters.formatDuration(run.excluded) : null,
+		downtimeText: formatters.formatDuration(run.downtime),
+		incidentsText: formatNumber(run.incidents.length, "integer"),
+		sla: run.sla ? {
+			targetText: formatters.formatUptime(run.sla.target),
+			verdictText: labels.verdictNames[run.sla.verdict],
+			remainingText: formatters.formatDuration(run.sla.remaining > 0 ? run.sla.remaining : run.sla.used - run.sla.allowed),
+			over: run.sla.remaining <= 0 && run.sla.used > run.sla.allowed
+		} : null
+	});
+}
+/** The summary table twin: every figure the card face and its tooltips show. */
+function buildStatusDetailRows({ run, strip, formatters, labels }) {
+	const rows = [
+		{
+			key: "current",
+			label: labels.currentRow,
+			value: labels.levelNames[run.level]
+		},
+		{
+			key: "since",
+			label: labels.sinceRow,
+			value: formatters.formatInstant(run.since, "datetime")
+		},
+		{
+			key: "duration",
+			label: labels.durationRow,
+			value: formatters.formatDuration(run.sinceDuration)
+		},
+		{
+			key: "uptime",
+			label: labels.uptime,
+			value: formatters.formatUptime(run.uptime),
+			...run.sla ? { tone: run.polarity } : {}
+		},
+		{
+			key: "window",
+			label: labels.window,
+			value: formatters.formatDuration(run.window.span)
+		}
+	];
+	if (run.mode === "monitored" && run.excluded > 0) {
+		rows.push({
+			key: "monitored",
+			label: labels.monitored,
+			value: formatters.formatDuration(run.monitored)
+		});
+		rows.push({
+			key: "excluded",
+			label: labels.excludedRow,
+			value: formatters.formatDuration(run.excluded)
+		});
+	}
+	for (const entry of statusLevelBreakdown(run, formatters, labels)) rows.push({
+		key: `level-${entry.level}`,
+		label: entry.name,
+		value: entry.durationText
+	});
+	rows.push({
+		key: "worst",
+		label: labels.worstRow,
+		value: labels.levelNames[run.worst]
+	});
+	rows.push({
+		key: "incidents",
+		label: labels.incidentsRow,
+		value: formatNumber(run.incidents.length, "integer")
+	});
+	if (run.longestIncident) rows.push({
+		key: "longest",
+		label: labels.longestIncidentRow,
+		value: formatters.formatDuration(run.longestIncident.duration)
+	});
+	if (run.sla) {
+		rows.push({
+			key: "target",
+			label: labels.targetRow,
+			value: `${formatters.formatUptime(run.sla.target)} · ${labels.verdictNames[run.sla.verdict]}`,
+			tone: run.polarity
+		});
+		const over = run.sla.remaining <= 0 && run.sla.used > run.sla.allowed;
+		rows.push({
+			key: "budget",
+			label: labels.budgetRow,
+			value: over ? labels.budgetOver(formatters.formatDuration(run.sla.used - run.sla.allowed)) : labels.budgetLeft(formatters.formatDuration(run.sla.remaining)),
+			tone: over ? "negative" : "neutral"
+		});
+	}
+	if (strip) rows.push({
+		key: "resolution",
+		label: labels.stripRow,
+		value: describeResolution(strip, formatters, labels)
+	});
+	return rows;
+}
+/** The incident table twin — every incident the strip paints, with its true duration. */
+function buildStatusIncidentRows({ run, formatters, labels }) {
+	return run.incidents.map((incident, index) => ({
+		key: `incident-${index}`,
+		when: formatters.formatInstant(incident.start, "datetime"),
+		level: incident.level,
+		levelName: labels.levelNames[incident.level],
+		duration: formatters.formatDuration(incident.duration),
+		...incident.label ? { label: incident.label } : {}
+	}));
+}
+/**
+* The card's generated accessible description: the state and how long it has
+* held, availability over the window (and how much of it was monitored), the
+* incidents and the downtime, the SLA verdict with the budget it leaves, the
+* window, and when the data was last true — Amy Cesal's alt-text formula
+* applied to a status tile.
+*/
+function buildStatusDescription({ name, state, run, level, hold, formatters, labels, asOfText }) {
+	if (state === "loading" || state === "refreshing") return labels.loading(name);
+	if (state === "error") return `${name}: ${labels.error}.`;
+	if (state === "empty") return `${name}: ${labels.noData}.`;
+	if (state === "no-match") return `${name}: ${labels.noMatch}.`;
+	const current = level ?? run?.level ?? null;
+	if (!current) return `${name}: ${labels.noData}.`;
+	const sentences = [hold ? labels.levelSentence({
+		name,
+		level: labels.levelNames[current],
+		duration: formatters.formatDuration(hold.duration),
+		atLeast: hold.atLeast
+	}) : `${name}: ${labels.levelNames[current]}.`];
+	if (state === "insufficient" || !run) sentences.push(`${labels.noHistory}.`);
+	else {
+		sentences.push(labels.uptimeSentence({
+			uptime: formatters.formatUptime(run.uptime),
+			span: formatters.formatDuration(run.window.span),
+			monitored: formatters.formatDuration(run.monitored),
+			mode: run.mode
+		}));
+		sentences.push(labels.incidentSentence({
+			count: run.incidents.length,
+			countText: formatNumber(run.incidents.length, "integer"),
+			downtime: formatters.formatDuration(run.downtime),
+			longest: run.longestIncident ? formatters.formatDuration(run.longestIncident.duration) : null
+		}));
+		if (run.sla) {
+			const over = run.sla.remaining <= 0 && run.sla.used > run.sla.allowed;
+			sentences.push(labels.slaSentence({
+				target: formatters.formatUptime(run.sla.target),
+				met: run.sla.verdict === "met",
+				remaining: formatters.formatDuration(over ? run.sla.used - run.sla.allowed : run.sla.remaining),
+				over
+			}));
+		}
+		sentences.push(labels.windowSentence({ range: formatters.formatSpan(run.window.start, run.window.end, "day") }));
+	}
+	if (asOfText) sentences.push(`${labels.asOf} ${asOfText}.`);
+	return sentences.join(" ");
+}
+/** The strip's own `aria-label` — chart type, what data, at what granularity, and what it adds up to. */
+function buildStatusChartDescription({ name, run, strip, formatters, labels }) {
+	return labels.chartDescription({
+		name,
+		rangeText: formatters.formatSpan(run.window.start, run.window.end, "day"),
+		resolutionText: describeResolution(strip, formatters, labels),
+		levels: statusLevelBreakdown(run, formatters, labels).map((entry) => [entry.name, entry.durationText]),
+		incidents: labels.incidentSentence({
+			count: run.incidents.length,
+			countText: formatNumber(run.incidents.length, "integer"),
+			downtime: formatters.formatDuration(run.downtime),
+			longest: null
+		})
+	});
+}
+//#endregion
+export { DEFAULT_STATUS_LABELS, STATUS_LEVELS, STATUS_SEVERITY, buildStatusChartDescription, buildStatusDescription, buildStatusDetailRows, buildStatusExplanation, buildStatusIncidentRows, buildStatusStrip, createStatusFormatters, deriveIncidents, deriveStatusRun, deriveStatusState, describeResolution, formatDuration, formatStripCell, normalizeHistory, resolveStatusHold, resolveStatusLabels, resolveStatusWindow, resolveStep, statusHue, statusLevelBreakdown, statusStepKey };