@camstack/ui-library 1.2.305 → 1.2.306

package/dist/{MotionZonesSettings-C3Tj12yc.js → MotionZonesSettings-DR1g9ja3.js}

@@ -1,4 +1,4 @@
-import { TEXT_HINT, UiTrans, WidgetPanel, isAbsentProvider, useDeviceProxy, usePlayerOverlayLayer, useSystem, useUiText, yn as Grid2x2 } from "./index.js";
+import { TEXT_HINT, UiTrans, WidgetPanel, bn as Grid2x2, isAbsentProvider, useDeviceProxy, usePlayerOverlayLayer, useSystem, useUiText } from "./index.js";
 import { MaskShapeCanvas } from "./MaskShapeCanvas-C9cJlxvG.js";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";

package/dist/{PrivacyMaskSettings-C9wfHkiB.js → PrivacyMaskSettings-CtetT6Jl.js}

@@ -1,5 +1,5 @@
 import { n as Hexagon, t as MicOff } from "./mic-off-C2VTYr91.js";
-import { H as Square, Nn as EyeOff, TEXT_HINT, UiTrans, Ut as Mic, WidgetPanel, isAbsentProvider, k as Trash2, useDeviceProxy, usePlayerOverlayLayer, useSystem, useUiText } from "./index.js";
+import { H as Square, Pn as EyeOff, TEXT_HINT, UiTrans, Ut as Mic, WidgetPanel, isAbsentProvider, k as Trash2, useDeviceProxy, usePlayerOverlayLayer, useSystem, useUiText } from "./index.js";
 import { MaskShapeCanvas } from "./MaskShapeCanvas-C9cJlxvG.js";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";

package/dist/{SceneMonitorEditor-30H29vN4.js → SceneMonitorEditor-BQhVO2F2.js}

@@ -1,5 +1,5 @@
 import { t as Settings2 } from "./settings-2-jT1iBqHD.js";
-import { SCENE_CAPTURE_VARIANTS, TEXT_HINT, UiTrans, badgeFor, br as Camera, coverageLine, dn as ImageOff, ft as RotateCcw, hubPath, isAbsentProvider, k as Trash2, roiTooLarge, statusLine, useDeviceProxy, useDeviceSnapshotImage, useDeviceStateSlice, useSystem, useUiText, variantLabel } from "./index.js";
+import { SCENE_CAPTURE_VARIANTS, Sr as Camera, TEXT_HINT, UiTrans, badgeFor, coverageLine, dn as ImageOff, ft as RotateCcw, hubPath, isAbsentProvider, k as Trash2, roiTooLarge, statusLine, useDeviceProxy, useDeviceSnapshotImage, useDeviceStateSlice, useSystem, useUiText, variantLabel } from "./index.js";
 import { MaskShapeCanvas } from "./MaskShapeCanvas-C9cJlxvG.js";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";

package/dist/composites/cap-settings/EventHeatmap.d.ts

@@ -1,5 +1,5 @@
-import type { DensityBucket } from "./recording-timeline-model";
 import { type JSX } from "react";
+import type { DensityBucket } from "./recording-timeline-model";
 interface EventHeatmapProps {
 	readonly windowFrom: number;
 	readonly windowTo: number;
@@ -7,5 +7,11 @@ interface EventHeatmapProps {
 	readonly selectedIndex: number | null;
 	readonly onSelectBucket: (index: number) => void;
 }
-export declare function EventHeatmap({ windowFrom, windowTo, buckets, selectedIndex, onSelectBucket }: EventHeatmapProps): JSX.Element | null;
+/**
+* Event-density strip under a recording timeline: one stacked bar per bucket
+* (motion / object / audio), height normalised to the busiest bucket, on the
+* timeline's own window. A click (or the bucket's button, for keyboard and
+* screen readers) selects the bucket — it drives the drill-down strip.
+*/
+export declare function EventHeatmap({ windowFrom, windowTo, buckets, selectedIndex, onSelectBucket }: EventHeatmapProps): JSX.Element;
 export {};

package/dist/composites/charts/BarSeries.d.ts

@@ -0,0 +1,49 @@
+/**
+* BarSeries — bucketed counts or deltas on wall time (uPlot), optionally
+* stacked, with a window total (kWh per hour with the day's sum, detections
+* per 5 minutes by class, event density under a recording timeline).
+*
+* Bars sit on their bucket's real span, so a missing bucket is a missing bar
+* and never a zero bar. `compact` drops the frame and axes for a strip that
+* lives inside another control; there a bucket can be selected (`onSelect`)
+* and every bucket is also a real button for keyboard and screen readers.
+*/
+import { type JSX, type ReactNode } from "react";
+import { type ChartWindowToggleProps } from "./chart-window";
+import { type BarBucket, type BarLayerDef } from "./bar-series-model";
+import type { ChartRange } from "./TimeSeriesChart";
+export type { BarBucket, BarLayerDef } from "./bar-series-model";
+export interface BarSeriesProps<TId extends string = string> {
+	readonly title: string;
+	readonly layers: readonly BarLayerDef[];
+	readonly buckets: readonly BarBucket[];
+	/** The width of one bucket in ms (5 min, 1 h, 1 d). */
+	readonly bucketMs: number;
+	readonly range: ChartRange;
+	readonly unit?: string | null;
+	readonly formatValue?: (v: number, unit: string | null) => string;
+	/** Plot height in px. Default 100 (24 when `compact`). */
+	readonly height?: number;
+	/** Stack the layers (default true for more than one layer). */
+	readonly stacked?: boolean;
+	/** Say the window total under the chart ("Total 12.4 kWh"). */
+	readonly showTotal?: boolean;
+	readonly syncKey?: string;
+	readonly pending?: boolean;
+	readonly emptyMessage?: string;
+	readonly actions?: ReactNode;
+	readonly footer?: ReactNode;
+	readonly windowToggle?: ChartWindowToggleProps<TId>;
+	/** No frame, no axes: a strip inside another control. */
+	readonly compact?: boolean;
+	/** A non-zero bar is at least this fraction of the plot (compact strips). */
+	readonly minBarFraction?: number;
+	readonly selectedIndex?: number | null;
+	readonly onSelect?: (index: number) => void;
+	/** Text for a bucket (its button and native tooltip). */
+	readonly bucketLabel?: (bucket: BarBucket, index: number) => string;
+	/** `data-testid` on each bucket button. */
+	readonly bucketTestId?: string;
+	readonly className?: string;
+}
+export declare function BarSeries<TId extends string = string>({ title, layers, buckets, bucketMs, range, unit, formatValue, height, stacked, showTotal, syncKey, pending, emptyMessage, actions, footer, windowToggle, compact, minBarFraction, selectedIndex, onSelect, bucketLabel, bucketTestId, className }: BarSeriesProps<TId>): JSX.Element;

package/dist/composites/charts/Sparkline.d.ts

@@ -0,0 +1,26 @@
+/**
+* Sparkline — one series, no axes, no cursor: a trend beside a number in a
+* row (a training job's mAP per epoch). The x is whatever the caller orders
+* by (an epoch, a time); the value next to it names what the line is.
+*/
+import { type JSX } from "react";
+import { type ChartChromeToken, type ChartSeriesToken } from "./chart-palette";
+export interface SparklinePoint {
+	readonly x: number;
+	readonly v: number | null;
+}
+export interface SparklineProps {
+	readonly points: readonly SparklinePoint[];
+	/** Accessible name ("mAP50 per epoch"). */
+	readonly ariaLabel: string;
+	/** Line colour token. Default `chart-series-a`. */
+	readonly token?: ChartSeriesToken | Extract<ChartChromeToken, "primary">;
+	/** Plot height in px. Default 32. */
+	readonly height?: number;
+	/** Width class of the box (default `w-40`). */
+	readonly widthClassName?: string;
+	/** Start the value axis at zero (default true). */
+	readonly zeroBased?: boolean;
+	readonly className?: string;
+}
+export declare function Sparkline({ points, ariaLabel, token, height, widthClassName, zeroBased, className }: SparklineProps): JSX.Element;

package/dist/composites/charts/StateTimeline.d.ts

@@ -0,0 +1,47 @@
+/**
+* StateTimeline — boolean and enum states as bands over wall time (uPlot).
+*
+* One row per state series. A state is a filled band in its categorical slot
+* (the ordinal of the value in its `states` list, so a colour follows the
+* state, never its rank); a boolean's `false` is a recessive fill, and a span
+* nothing was recorded for is left EMPTY — unknown never looks like a state.
+* The legend gives the time spent in each state over the window ("open
+* 2h 14m"), and the cursor (synced through `syncKey`) names the state under it.
+*/
+import { type JSX, type ReactNode } from "react";
+import { type StateSegment } from "./chart-data";
+import { type ChartSwatchToken } from "./chart-palette";
+import type { ChartRange } from "./TimeSeriesChart";
+export interface StateRowDef {
+	readonly id: string;
+	readonly label: string;
+	readonly segments: readonly StateSegment[];
+	/** Every state this row can take, in their stable order (an enum's value list). */
+	readonly states: readonly string[];
+	/** `boolean`: `states[1]` is the "on" state, drawn in `colorIndex`; `states[0]` is recessive. */
+	readonly kind: "boolean" | "enum";
+	/** Boolean: the slot of the "on" state. Enum: the slot offset of `states[0]`. Default 0. */
+	readonly colorIndex?: number;
+	/** Operator text for a state value ("open" for `true`). */
+	readonly stateLabel?: (state: string) => string;
+	/**
+	* Exact time per state when the segments are an approximation (a rollup
+	* bucket drawn in its dominant state); default: summed from the segments.
+	*/
+	readonly totals?: ReadonlyMap<string, number>;
+}
+export interface StateTimelineProps {
+	readonly title: string;
+	readonly rows: readonly StateRowDef[];
+	readonly range: ChartRange;
+	readonly syncKey?: string;
+	readonly pending?: boolean;
+	readonly emptyMessage?: string;
+	readonly actions?: ReactNode;
+	readonly className?: string;
+}
+/** The colour role of a state on a row: a categorical slot, or the recessive "off". */
+export declare function stateStyle(row: Pick<StateRowDef, "kind" | "states" | "colorIndex">, state: string): {
+	readonly token: ChartSwatchToken;
+};
+export declare function StateTimeline({ title, rows, range, syncKey, pending, emptyMessage, actions, className }: StateTimelineProps): JSX.Element;

package/dist/composites/charts/TimeSeriesChart.d.ts

@@ -0,0 +1,48 @@
+/**
+* TimeSeriesChart — gauges and counters over wall time (uPlot).
+*
+* Lines, an optional min/max band, stacked areas, null gaps (a hole breaks
+* the line AND is shaded), one value axis per unit (left, right, left …),
+* a synced cursor across every chart sharing `syncKey`, an optional window
+* toggle. Identity is never colour alone: one series is named by the title,
+* two or more always carry a legend with direct values.
+*
+* A device page draws ONE unit per chart; overlaying units (several axes) is
+* for the cross-device History page, where the reader chose the series.
+*/
+import { type JSX, type ReactNode } from "react";
+import { type ValueAxisSpec } from "./chart-uplot";
+import { type ChartWindowToggleProps } from "./chart-window";
+import { type TimeSeriesDef } from "./time-series-model";
+export type { TimeSeriesDef } from "./time-series-model";
+export interface ChartRange {
+	readonly from: number;
+	readonly to: number;
+}
+export interface TimeSeriesChartProps<TId extends string = string> {
+	readonly title: string;
+	readonly series: readonly TimeSeriesDef[];
+	/** The window the x axis spans; default: the data's own span. */
+	readonly range?: ChartRange;
+	/** Plot height in px. Default 120. */
+	readonly height?: number;
+	/** Stack the non-compare series as areas (parts of one total). */
+	readonly stacked?: boolean;
+	/** Fill a single line down to its baseline. */
+	readonly area?: boolean;
+	/** Charts with the same key move one cursor together. */
+	readonly syncKey?: string;
+	/** Value formatter per unit; default: bytes binary, `%` glued, unit after a space. */
+	readonly formatValue?: (v: number, unit: string | null) => string;
+	/** Axis layout per unit; default by unit (°C floats, `%` floors at 10, bytes binary). */
+	readonly axisFor?: (unit: string | null) => ValueAxisSpec;
+	/** Shown when no series has a known value. */
+	readonly emptyMessage?: string;
+	/** The query has not answered: a placeholder, never an empty chart. */
+	readonly pending?: boolean;
+	readonly actions?: ReactNode;
+	readonly footer?: ReactNode;
+	readonly windowToggle?: ChartWindowToggleProps<TId>;
+	readonly className?: string;
+}
+export declare function TimeSeriesChart<TId extends string = string>({ title, series, range, height, stacked, area, syncKey, formatValue, axisFor, emptyMessage, pending, actions, footer, windowToggle, className }: TimeSeriesChartProps<TId>): JSX.Element;

package/dist/composites/charts/bar-series-model.d.ts

@@ -0,0 +1,25 @@
+/**
+* The pure half of `BarSeries`: buckets on a fixed grid, optionally stacked,
+* with a total. A bucket the source did not answer is `null` (no bar, not a
+* zero bar); a bucket it answered with nothing is `0`.
+*/
+/** One bucket: its START and one value per stack layer (`null` = not measured). */
+export interface BarBucket {
+	readonly t: number;
+	readonly values: readonly (number | null)[];
+}
+export interface BarLayerDef {
+	readonly id: string;
+	readonly label: string;
+	readonly colorIndex: number;
+}
+/** Cumulative tops per layer, bottom layer first: `tops[l][i] = values[0..l]` summed. */
+export declare function stackBuckets(buckets: readonly BarBucket[], layers: number): readonly (readonly (number | null)[])[];
+/** Total per layer and overall over the window (unknown buckets add nothing). */
+export declare function bucketTotals(buckets: readonly BarBucket[], layers: number): {
+	readonly perLayer: readonly number[];
+	readonly total: number;
+	readonly known: boolean;
+};
+/** Index of the bucket that holds `t`, or `null`. */
+export declare function bucketIndexAt(buckets: readonly BarBucket[], bucketMs: number, t: number): number | null;

package/dist/composites/charts/chart-data.d.ts

@@ -0,0 +1,87 @@
+/**
+* Data shaping for the chart family — pure, no DOM, no uPlot.
+*
+* uPlot draws from ONE shared x array with one y array per series. Two kinds
+* of "no value" must stay distinct when several series are joined onto it:
+*
+*  - `undefined` — this series has no sample at an x another series has. The
+*    line is JOINED across it (alignment filler, not a claim).
+*  - `null` — nobody measured here: an explicit unknown sample, or a hole
+*    longer than the series' `gapMs`. The line BREAKS and is never drawn as 0.
+*/
+/** One sample. `null` is unknown, never zero. */
+export interface TimePoint {
+	readonly t: number;
+	readonly v: number | null;
+	/** Optional spread of a rolled-up bucket — drawn as a band. */
+	readonly min?: number | null;
+	readonly max?: number | null;
+}
+export interface AlignInput {
+	readonly points: readonly TimePoint[];
+	/** Longest interval between two samples that may be joined; omit for change-only (held) series. */
+	readonly gapMs?: number;
+}
+export type AlignedValue = number | null | undefined;
+export interface AlignedSeries {
+	/** Ascending, unique, epoch ms. */
+	readonly xs: readonly number[];
+	readonly ys: readonly (readonly AlignedValue[])[];
+	readonly mins: readonly (readonly AlignedValue[])[];
+	readonly maxs: readonly (readonly AlignedValue[])[];
+}
+/** Join several series onto one x array, inserting a `null` inside every hole wider than its `gapMs`. */
+export declare function alignSeries(inputs: readonly AlignInput[]): AlignedSeries;
+/** A time range nobody measured, for shading. */
+export interface GapSpan {
+	readonly from: number;
+	readonly to: number;
+}
+/**
+* The holes every series shares (the intersection), so the chart shades only
+* what NOBODY measured. Series without `gapMs` never contribute a hole and so
+* make the intersection empty: a held value is not unmeasured.
+*/
+export declare function sharedGapSpans(inputs: readonly AlignInput[]): readonly GapSpan[];
+/**
+* Cumulative sums for a stacked area: `out[i] = ys[0] + … + ys[i]`. A stack
+* level is unknown (`null`) as soon as any layer under it is unknown, and an
+* alignment filler stays a filler.
+*/
+export declare function stackSeries(ys: readonly (readonly AlignedValue[])[]): AlignedValue[][];
+/**
+* The value a reader sees at index `idx`: the nearest sample at or before it
+* that is not an alignment filler. A `null` there is answered as unknown.
+*/
+export declare function valueAtOrBefore(xs: readonly number[], ys: readonly AlignedValue[], idx: number): number | null;
+/** A state held from `from` until `to`. `state: null` is unknown (not recorded), never a state. */
+export interface StateSegment {
+	readonly from: number;
+	readonly to: number;
+	readonly state: string | null;
+}
+/** One state change, as a history read answers it: the state from `t` on. */
+export interface StateChange {
+	readonly t: number;
+	readonly state: string | null;
+}
+/**
+* Turn change points into segments clipped to [from, to]. `before` is the
+* state in force when the window opens (the last change before it); without
+* it the window starts unknown until the first change.
+*/
+export declare function segmentsFromChanges(changes: readonly StateChange[], from: number, to: number, before?: string | null): readonly StateSegment[];
+/** Total milliseconds per state over the segments (unknown spans are not counted). */
+export declare function timeInState(segments: readonly StateSegment[]): ReadonlyMap<string, number>;
+/** The state in force at `t`, or `null` when nothing was recorded there. */
+export declare function stateAt(segments: readonly StateSegment[], t: number): string | null;
+/** `2h 14m`, `3d 4h`, `45s` — two units at most, for a legend. */
+export declare function formatSpan(ms: number): string;
+/**
+* A wall-clock label at the precision the window's length justifies:
+* seconds under ten minutes, `HH:MM` within two days, the date past that,
+* month + year past ~4 months.
+*/
+export declare function formatTimeLabel(t: number, spanMs: number): string;
+/** A cursor readout time: always the full instant at the window's precision. */
+export declare function formatCursorTime(t: number, spanMs: number): string;

package/dist/composites/charts/chart-frame.d.ts

@@ -0,0 +1,53 @@
+/**
+* The DOM half every chart of the family shares: the title, the cursor
+* readout, the legend with direct values, the actions slot (a ⋯ menu) and the
+* accessible summary. The plot itself is canvas; everything a reader or a
+* screen reader needs to IDENTIFY a series is here, in text tokens — a series
+* colour only ever sits on a swatch beside the text.
+*
+* One series: no legend box — the title names it, the value sits beside it.
+* Two or more: a legend is always present and every entry carries its value.
+*/
+import { type JSX, type ReactNode } from "react";
+import { type ChartSwatchToken } from "./chart-palette";
+export interface ChartLegendEntry {
+	readonly id: string;
+	readonly label: string;
+	/** The swatch colour: the series' token. */
+	readonly token: ChartSwatchToken;
+	/** The swatch is drawn as a dashed line (a compare series, or a ninth+ series). */
+	readonly dashed?: boolean;
+	/** The value at the cursor (or the latest); `undefined` hides it. */
+	readonly value?: string;
+	/** A secondary entry (a compare period): recessive text. */
+	readonly muted?: boolean;
+}
+export interface ChartFrameProps {
+	readonly title: string;
+	/** Controls at the right of the title (a ⋯ menu). */
+	readonly actions?: ReactNode;
+	/** The instant the readout shows, when the cursor is on the plot. */
+	readonly readoutTime?: string | null;
+	readonly legend: readonly ChartLegendEntry[];
+	/** One sentence a screen reader gets instead of the canvas. */
+	readonly summary: string;
+	/** Text under the legend (a total, what one bar covers). */
+	readonly footer?: ReactNode;
+	/** Rendered INSTEAD of the plot (empty or not-yet-answered). */
+	readonly placeholder?: ReactNode;
+	/** Interactive content tied to the plot (bucket buttons), kept OUTSIDE its `role="img"`. */
+	readonly controls?: ReactNode;
+	readonly className?: string;
+	readonly children?: ReactNode;
+}
+export declare function ChartFrame({ title, actions, readoutTime, legend, summary, footer, placeholder, controls, className, children }: ChartFrameProps): JSX.Element;
+/** The swatch: a filled square, or a dashed bar for a dashed series. */
+export declare function ChartSwatch({ token, dashed }: {
+	readonly token: ChartSwatchToken;
+	readonly dashed?: boolean;
+}): JSX.Element;
+/** The plot-sized box for an empty or pending chart: a dashed outline and one line of text. */
+export declare function ChartPlaceholder({ message, height }: {
+	readonly message: string;
+	readonly height: "sm" | "md" | "lg";
+}): JSX.Element;

package/dist/composites/charts/chart-palette.d.ts

@@ -0,0 +1,46 @@
+/**
+* The chart family's colours — theme tokens only.
+*
+* Categorical identity comes from the eight `--color-chart-series-*` tokens in
+* `tailwind/camstack-theme.css`, in FIXED order (a blue, b magenta, c yellow,
+* d aqua, e orange, f violet, g green, h red). A series keeps its slot for as
+* long as it is on screen: the caller assigns the index, never the rank, so a
+* filter that hides one series does not repaint the others.
+*
+* Past eight, a slot is reused with a dash pattern (composite encoding) — a
+* generated ninth hue would be indistinguishable from one of the eight.
+*
+* Canvas cannot read `var(--…)`, so a token is resolved through
+* `getComputedStyle` at DRAW time: a theme switch (`.dark` / `.light` on
+* `<html>`) followed by a redraw picks the new value up with no re-creation.
+*/
+/** The categorical slots, in their fixed order. */
+export declare const CHART_SERIES_TOKENS: readonly ["chart-series-a", "chart-series-b", "chart-series-c", "chart-series-d", "chart-series-e", "chart-series-f", "chart-series-g", "chart-series-h"];
+export type ChartSeriesToken = (typeof CHART_SERIES_TOKENS)[number];
+export interface ChartSeriesStyle {
+	readonly token: ChartSeriesToken;
+	/** Empty for a solid line. */
+	readonly dash: readonly number[];
+}
+/** The style of the series at `index` (0-based, its stable identity slot). */
+export declare function chartSeriesStyle(index: number): ChartSeriesStyle;
+/** A token a DOM swatch can wear: a series slot, or the recessive "off" state. */
+export type ChartSwatchToken = ChartSeriesToken | "border";
+/** The utility that fills a swatch with `token`. */
+export declare function swatchFillClass(token: ChartSwatchToken): string;
+/** The utility that colours a dashed swatch's line with `token`. */
+export declare function swatchLineClass(token: ChartSwatchToken): string;
+/** Neutral roles the canvas draws with (axes, grid, gap shading). */
+export type ChartChromeToken = "foreground-subtle" | "foreground-muted" | "border" | "border-subtle" | "surface" | "primary";
+/**
+* Resolve a theme token to the colour the canvas paints. Reads the computed
+* value of `--color-<token>` on the chart's own root (so a scoped theme block
+* wins); answers `transparent` when the document has no value (a test DOM).
+*/
+export declare function resolveChartColor(token: ChartSeriesToken | ChartChromeToken, el?: Element): string;
+/**
+* `color` with `alpha` (0..1). A resolved token is a six-digit hex, which
+* becomes the eight-digit form every canvas accepts; anything else falls back
+* to `color-mix`.
+*/
+export declare function withAlpha(color: string, alpha: number): string;

package/dist/composites/charts/chart-scale.d.ts

@@ -0,0 +1,29 @@
+/**
+* Value-axis arithmetic for the chart family — pure, unit-tested, because the
+* ways a chart LIES are arithmetic (a truncated baseline, an axis that tops
+* out on `4.7 GB`, a gap threshold that either shatters every line or bridges
+* an outage). Moved from the admin-ui load charts, which proved these rules.
+*/
+/** `bytes` rounds on powers of two (what `formatBytes` prints); `linear` on 1/2/5×10ⁿ. */
+export type AxisScale = "linear" | "bytes";
+/**
+* Nice upper bound of a value axis that starts at zero. `floor` is returned
+* VERBATIM when nothing exceeds it, so an idle series keeps the scale the
+* caller chose instead of a 0–0.3 axis on which noise looks like load.
+*/
+export declare function niceMax(values: readonly (number | null)[], floor: number, scale?: AxisScale): number;
+/** Gridline values for an axis topping out at `max`, ascending, `max` last; zero is the baseline, not a tick. */
+export declare function axisTicks(max: number, scale?: AxisScale): readonly number[];
+/**
+* Nice [min, max] for a series that need NOT start at zero (a temperature, a
+* dBFS level): the data range padded by a tenth and rounded outward to a
+* readable step. A flat series gets a ±1 window so it is not a degenerate axis.
+*/
+export declare function niceRange(values: readonly (number | null)[]): readonly [number, number] | null;
+/**
+* How many sampling intervals of silence make a HOLE rather than a late tick:
+* past any plausible delivery jitter, well inside the shortest outage worth seeing.
+*/
+export declare const GAP_INTERVAL_FACTOR = 2.5;
+/** The gap threshold for a series sampled every `intervalMs` — derived, never a literal. */
+export declare function gapThresholdMs(intervalMs: number): number;

package/dist/composites/charts/chart-uplot.d.ts

@@ -0,0 +1,44 @@
+/**
+* uPlot option builders shared by the family: the wall-time x axis, a value
+* axis per unit, recessive chrome in theme tokens, the synced cursor and the
+* hole shading. Every colour is a FUNCTION so a theme switch is a redraw.
+*/
+import type uPlot from "uplot";
+import { type GapSpan } from "./chart-data";
+import { type AxisScale } from "./chart-scale";
+/** The x axis: wall-clock time under the plot, at the window's precision. */
+export declare function timeAxis(spanMs: () => number, show?: boolean): uPlot.Axis;
+/** How a value axis is laid out. */
+export interface ValueAxisSpec {
+	/** `bytes` rounds the top on powers of two. Default `linear`. */
+	readonly scale?: AxisScale;
+	/** Start at zero (default) — false for a level that lives far from it (°C, dBFS). */
+	readonly zeroBased?: boolean;
+	/** The axis top never goes below this (an idle 0.4 % must not fill the plot). */
+	readonly floor?: number;
+	/** Fixed range, e.g. `[0, 100]` for a percentage. */
+	readonly fixed?: readonly [number, number];
+}
+/** A y scale's range from the values it carries, per the axis spec. */
+export declare function valueRange(values: readonly (number | null | undefined)[], spec: ValueAxisSpec): readonly [number, number];
+/** Tick positions for a value axis over `range`: readable steps, 3–6 intervals. */
+export declare function valueSplits(range: readonly [number, number], spec: ValueAxisSpec): number[];
+/** One value axis. `side` 3 = left, 1 = right. */
+export declare function valueAxis(scaleKey: string, side: 1 | 3, format: (v: number) => string, showGrid: boolean): uPlot.Axis;
+/** The cursor: a vertical crosshair, synced across every chart with the same key. */
+export declare function chartCursor(syncKey: string | undefined): uPlot.Cursor;
+/**
+* Shade every hole nobody measured, UNDER the series, so an outage reads as
+* missing ground and never as a quiet period.
+*/
+export declare function gapShadeHook(spans: () => readonly GapSpan[]): (u: uPlot) => void;
+/** Is this unit a byte count (binary axis and formatter)? */
+export declare function isByteUnit(unit: string | null | undefined): boolean;
+/** The default axis spec for a unit. */
+export declare function defaultAxisSpec(unit: string | null | undefined): ValueAxisSpec;
+/** Binary byte count: `512 B`, `3.4 MB`, `1.2 GB`. */
+export declare function formatChartBytes(bytes: number): string;
+/** A number at a precision its magnitude justifies. */
+export declare function formatChartNumber(v: number): string;
+/** The default value formatter: bytes binary, `%` glued, any other unit after a space. */
+export declare function formatChartValue(v: number, unit: string | null | undefined): string;

package/dist/composites/charts/chart-window.d.ts

@@ -0,0 +1,19 @@
+/**
+* The window toggle every chart of the family uses: a small segmented control
+* of presets. Pure display — the parent owns `value` and `onChange`. A control
+* with one option is not rendered.
+*/
+import { type JSX } from "react";
+export interface ChartWindowOption<TId extends string> {
+	readonly id: TId;
+	readonly label: string;
+}
+export interface ChartWindowToggleProps<TId extends string> {
+	readonly options: readonly ChartWindowOption<TId>[];
+	readonly value: TId;
+	readonly onChange: (id: TId) => void;
+	/** Names the group for assistive tech ("Time window"). */
+	readonly ariaLabel: string;
+	readonly className?: string;
+}
+export declare function ChartWindowToggle<TId extends string>({ options, value, onChange, ariaLabel, className }: ChartWindowToggleProps<TId>): JSX.Element | null;

package/dist/composites/charts/index.d.ts

@@ -0,0 +1,16 @@
+/**
+* The chart family (D899): one look for every time-based chart, built on
+* uPlot, themed only through `--color-chart-series-*` and the neutral tokens.
+*/
+export { TimeSeriesChart, type ChartRange, type TimeSeriesChartProps } from "./TimeSeriesChart";
+export { StateTimeline, stateStyle, type StateRowDef, type StateTimelineProps } from "./StateTimeline";
+export { BarSeries, type BarSeriesProps } from "./BarSeries";
+export { Sparkline, type SparklinePoint, type SparklineProps } from "./Sparkline";
+export { ChartFrame, ChartPlaceholder, ChartSwatch, type ChartFrameProps, type ChartLegendEntry } from "./chart-frame";
+export { ChartWindowToggle, type ChartWindowOption, type ChartWindowToggleProps } from "./chart-window";
+export { CHART_SERIES_TOKENS, chartSeriesStyle, swatchFillClass, swatchLineClass, type ChartSeriesStyle, type ChartSwatchToken, type ChartSeriesToken } from "./chart-palette";
+export { GAP_INTERVAL_FACTOR, axisTicks, gapThresholdMs, niceMax, niceRange, type AxisScale } from "./chart-scale";
+export { alignSeries, formatSpan, formatTimeLabel, segmentsFromChanges, sharedGapSpans, stackSeries, stateAt, timeInState, type GapSpan, type StateChange, type StateSegment, type TimePoint } from "./chart-data";
+export { defaultAxisSpec, formatChartBytes, formatChartNumber, formatChartValue, isByteUnit, type ValueAxisSpec } from "./chart-uplot";
+export { buildTimeSeriesModel, unitAxes, type SeriesInterpolation, type TimeSeriesDef } from "./time-series-model";
+export { bucketTotals, stackBuckets, type BarBucket, type BarLayerDef } from "./bar-series-model";

package/dist/composites/charts/time-series-model.d.ts

@@ -0,0 +1,47 @@
+/**
+* The pure half of `TimeSeriesChart`: which series go on which value axis,
+* the aligned data uPlot draws, and what the readout says at an index.
+*/
+import { type AlignedValue, type GapSpan, type TimePoint } from "./chart-data";
+export type SeriesInterpolation = "linear" | "step";
+export interface TimeSeriesDef {
+	/** Stable id — React key and the identity the colour follows. */
+	readonly id: string;
+	readonly label: string;
+	/** `null` is an unknown unit; series sharing a unit share an axis. */
+	readonly unit?: string | null;
+	readonly points: readonly TimePoint[];
+	/** Categorical slot (`chartSeriesStyle`); the caller keeps it stable across filters. */
+	readonly colorIndex: number;
+	/** `step` holds each value until the next (a change-only series). Default `linear`. */
+	readonly interpolation?: SeriesInterpolation;
+	/** Longest gap that may be joined; omit for a change-only series (it is held, never a hole). */
+	readonly gapMs?: number;
+	/** Draw the points' `min`/`max` as a band behind the line. */
+	readonly band?: boolean;
+	/** A previous-period overlay: dashed, recessive, excluded from stacking and gap shading. */
+	readonly compare?: boolean;
+}
+/** The unit key a series lives on (`''` for no / unknown unit). */
+export declare function unitKey(unit: string | null | undefined): string;
+/** Units in order of first appearance — one value axis each. */
+export declare function unitAxes(series: readonly TimeSeriesDef[]): readonly string[];
+export interface TimeSeriesModel {
+	readonly xs: readonly number[];
+	/** RAW values per series (index-aligned with the input), for the readout. */
+	readonly raw: readonly (readonly AlignedValue[])[];
+	/** What is drawn per series: raw, or cumulative when stacked. */
+	readonly drawn: readonly (readonly AlignedValue[])[];
+	readonly mins: readonly (readonly AlignedValue[])[];
+	readonly maxs: readonly (readonly AlignedValue[])[];
+	readonly units: readonly string[];
+	readonly gaps: readonly GapSpan[];
+	/** No series has a single known value. */
+	readonly empty: boolean;
+}
+/** Align, stack (non-compare series only) and find the shared holes. */
+export declare function buildTimeSeriesModel(series: readonly TimeSeriesDef[], stacked: boolean): TimeSeriesModel;
+/** The value per series a reader sees at `idx` (`null` = cursor off → the latest). */
+export declare function readoutAt(model: TimeSeriesModel, idx: number | null): readonly (number | null)[];
+/** The last known value of each series (for the accessible summary). */
+export declare function latestValues(model: TimeSeriesModel): readonly (number | null)[];

package/dist/composites/charts/uplot-host.d.ts

@@ -0,0 +1,34 @@
+/**
+* The one place the chart family touches uPlot.
+*
+* - uPlot is imported LAZILY: its module reads `matchMedia` at load time, and
+*   a document without a 2D canvas (a test DOM, a print preview) has nothing
+*   for it to draw on. There the chart's DOM half — title, legend, readout and
+*   the accessible summary — still renders; only the plot is absent.
+* - Width follows the container (`ResizeObserver`); the height is the caller's.
+* - A theme switch (`.dark` / `.light` on `<html>`) only REDRAWS: every colour
+*   is a function that resolves its token at draw time (`chart-palette.ts`).
+* - `optionsKey` decides when the plot is rebuilt (series set, axes); new
+*   `data` under the same key is a cheap `setData`.
+*/
+import { type JSX } from "react";
+import type uPlot from "uplot";
+export type UPlotCtor = typeof uPlot;
+/** Options without the size: the host owns width (the container) and height (the prop). */
+export type ChartPlotOptions = Omit<uPlot.Options, "width" | "height">;
+/** A 2D canvas this document can draw on — false in a test DOM. */
+export declare function canDrawCanvas(): boolean;
+export interface UPlotHostProps {
+	/** Rebuild the plot when this changes (series set, axes, scales). */
+	readonly optionsKey: string;
+	/** Build the options for a width; called on (re)build only. `lib` carries uPlot's path builders. */
+	readonly buildOptions: (width: number, lib: UPlotCtor) => ChartPlotOptions;
+	readonly data: uPlot.AlignedData;
+	readonly height: number;
+	/** Called with the live instance after each (re)build, and `null` when it goes. */
+	readonly onInstance?: (u: uPlot | null) => void;
+	readonly className?: string;
+	/** Render a `<span class="block">` host, for a plot inside phrasing content. */
+	readonly inline?: boolean;
+}
+export declare function UPlotHost({ optionsKey, buildOptions, data, height, onInstance, className, inline }: UPlotHostProps): JSX.Element;