@oh-my-pi/omp-stats 18.3.5 → 18.4.1

package/dist/types/aggregator.d.ts

@@ -1,4 +1,5 @@
-import type { BehaviorDashboardStats, DashboardStats, FolderStats, MessageStats, ProviderDashboardStats, RequestDetails, ToolDashboardStats } from "./types.js";
+import { type RangeWindow } from "./rollup.js";
+import type { DashboardStats, FolderStats, MessageStats, ProviderDashboardStats, ProviderWindowStats, RequestDetails, ToolDashboardStats } from "./types.js";
 /**
  * Serialize stats ingestion and archive reconciliation across processes.
  * The lock covers file discovery, parsing, and the final SQLite write so a
@@ -11,7 +12,7 @@ export declare function withStatsSyncLock<T>(dbPath: string, fn: () => Promise<T
  * Progress event emitted after each session file is fully processed.
  * `current` is the number of files completed (skipped + parsed),
  * `total` is the size of the work set. `processed` is the running total
- * of inserted rows.
+ * of inserted rows. Parsed files are reported only after their batch commits.
  */
 export interface SyncProgress {
     current: number;
@@ -25,9 +26,14 @@ export interface SyncOptions {
     /**
      * Worker pool size. Defaults to a sensible value derived from the host
      * (capped to avoid drowning a small machine in workers). Set to `1` to
-     * force serial parsing without spawning workers.
+     * parse on the calling thread without spawning workers. File I/O is pipelined.
      */
     workers?: number;
+    /**
+     * Sync only these transcripts (e.g. files a watcher saw change) instead of
+     * listing every session. Missing files are skipped.
+     */
+    files?: readonly string[];
 }
 /**
  * Smoke test: spawns one sync worker, pings it, asserts the pong response,
@@ -51,9 +57,11 @@ export declare function smokeTestSyncWorker({ timeoutMs }?: {
 /**
  * Sync all session files to the database.
  *
- * `workers: 1` parses inline. Larger pools fan parsing out across workers
+ * `workers: 1` pipelines file reads and parses inline, committing in discovery order.
+ * Larger pools fan parsing out across workers
  * (one in-flight job per worker) while DB writes and offset bookkeeping stay on
- * the calling thread so the single SQLite handle stays uncontended.
+ * the calling thread. Bounded batches commit rows and cursors atomically without
+ * holding a database transaction open during file I/O.
  * `onProgress` fires once per completed file (skipped files included so the
  * bar walks at a steady rate).
  */
@@ -61,17 +69,8 @@ export declare function syncAllSessions(opts?: SyncOptions): Promise<{
     processed: number;
     files: number;
 }>;
-interface TimeRangeConfig {
-    timeSeriesHours: number;
-    timeSeriesBucketMs: number;
-    modelSeriesDays: number;
-    modelSeriesBucketMs: number;
-    modelPerformanceDays: number;
-    modelPerformanceBucketMs: number;
-    costSeriesDays: number;
-    cutoff: number | null;
-}
-export declare function getTimeRangeConfig(range?: string | null): TimeRangeConfig;
+/** Resolve a `?range=` value (default 24h) to its cutoff and series bucket size. */
+export declare function getTimeRangeConfig(range?: string | null): RangeWindow;
 /**
  * Get all dashboard stats.
  */
@@ -87,20 +86,24 @@ export declare function getRequestDetails(id: number): Promise<RequestDetails |
  * Get the current message count in the database.
  */
 export declare function getTotalMessageCount(): Promise<number>;
-export declare function getBehaviorDashboardStats(range?: string | null): Promise<BehaviorDashboardStats>;
 /**
  * Get the tools dashboard payload: per-tool totals, per-(tool, model)
- * breakdown, and the call time series (bucketed like the model series).
+ * breakdown, and the call time series.
  */
 export declare function getToolDashboardStats(range?: string | null): Promise<ToolDashboardStats>;
 /**
  * Get the providers dashboard payload: per-provider totals, peak-burn-hours
- * histogram, provider token time series, and subscription-window analytics
- * (utilization series + insights) derived from recorded usage-limit snapshots.
+ * histogram and provider token time series. Subscription windows are served
+ * separately by {@link getProviderWindowStats}.
+ */
+export declare function getProviderDashboardStats(range?: string | null): Promise<ProviderDashboardStats>;
+/**
+ * Subscription-window analytics derived from recorded usage-limit snapshots:
+ * insights for every provider window, plus utilization series for `provider`
+ * only (all series can number in the thousands).
  *
  * Window token estimates use broker-held fleet token burn when a broker is
  * configured — the window fractions cover every install sharing the broker's
  * credentials, so dividing them into local-only tokens would undercount.
  */
-export declare function getProviderDashboardStats(range?: string | null): Promise<ProviderDashboardStats>;
-export {};
+export declare function getProviderWindowStats(range?: string | null, provider?: string | null): Promise<ProviderWindowStats>;

package/dist/types/client/api.d.ts

@@ -1,4 +1,4 @@
-import type { BehaviorDashboardStats, CostDashboardStats, FolderStats, GainDashboardStats, MessageStats, ModelDashboardStats, OverviewStats, ProviderDashboardStats, RequestDetails, SessionSummary, SessionTrace, TimeRange, ToolDashboardStats } from "./types.js";
+import type { CostDashboardStats, FolderStats, FrustrationDashboardStats, FrustrationEstimate, FrustrationJobStatus, GainDashboardStats, LiveStatus, MessageStats, ModelDashboardStats, OverviewStats, ProviderDashboardStats, ProviderWindowStats, RequestDetails, SessionSummary, SessionTrace, TimeRange, ToolDashboardStats } from "./types.js";
 export declare class ApiError extends Error {
     status: number;
     endpoint: string;
@@ -10,16 +10,20 @@ export declare function getCostDashboardStats(range?: TimeRange, signal?: AbortS
 export declare function getRecentRequests(limit?: number, signal?: AbortSignal): Promise<MessageStats[]>;
 export declare function getRecentErrors(range?: TimeRange, limit?: number, signal?: AbortSignal): Promise<MessageStats[]>;
 export declare function getRequestDetails(id: number, signal?: AbortSignal): Promise<RequestDetails>;
-export declare function sync(signal?: AbortSignal): Promise<{
-    processed: number;
-    files: number;
-    totalMessages: number;
-}>;
-export declare function getBehaviorDashboardStats(range?: TimeRange, signal?: AbortSignal): Promise<BehaviorDashboardStats>;
+/** Ask the server to start a background sync; progress arrives on the `/api/events` stream. */
+export declare function requestSync(): Promise<LiveStatus>;
+export declare function getFrustrationDashboardStats(range?: TimeRange, signal?: AbortSignal): Promise<FrustrationDashboardStats>;
+/** Pre-run cost quote for judging every unjudged message in `range`. */
+export declare function getFrustrationEstimate(range: TimeRange, signal?: AbortSignal): Promise<FrustrationEstimate>;
+/** Start the judge run over the unjudged messages in `range`. Spends money. */
+export declare function startFrustrationRun(range: TimeRange): Promise<FrustrationJobStatus>;
+export declare function cancelFrustrationRun(): Promise<FrustrationJobStatus>;
 export declare function getFolderStats(range?: TimeRange, signal?: AbortSignal): Promise<FolderStats[]>;
 export declare function getGainDashboardStats(range?: TimeRange, project?: string | null, signal?: AbortSignal): Promise<GainDashboardStats>;
 export declare function getToolDashboardStats(range?: TimeRange, signal?: AbortSignal): Promise<ToolDashboardStats>;
 export declare function getProviderDashboardStats(range?: TimeRange, signal?: AbortSignal): Promise<ProviderDashboardStats>;
+/** Subscription-window insights (all providers) plus utilization series for `provider` only. */
+export declare function getProviderWindowStats(range: TimeRange, provider: string | null, signal?: AbortSignal): Promise<ProviderWindowStats>;
 export declare function getSessions(limit?: number, q?: string, signal?: AbortSignal): Promise<SessionSummary[]>;
 export declare function getSessionTrace(file: string, signal?: AbortSignal): Promise<SessionTrace>;
 /** Fetch one full journal entry for the span drawer. Entries are opaque JSON. */

package/dist/types/client/app/LiveChip.d.ts

@@ -0,0 +1,2 @@
+/** Topbar ingest status; click to sync now. */
+export declare function LiveChip(): import("react").JSX.Element;

package/dist/types/client/app/Shell.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from "react";
+import type { TimeRange } from "../types.js";
+import { type DashboardSection } from "./nav.js";
+export interface ShellProps {
+    section: DashboardSection;
+    onSectionChange: (section: DashboardSection) => void;
+    range: TimeRange;
+    onRangeChange: (range: TimeRange) => void;
+    children: ReactNode;
+}
+/**
+ * Fixed glass topbar + naked sidebar framing one inset content panel. Owns
+ * the global keyboard shortcuts: `1`–`6` pick a range, `g` then a letter jumps
+ * to a page.
+ */
+export declare function Shell({ section, onSectionChange, range, onRangeChange, children }: ShellProps): import("react").JSX.Element;

package/dist/types/client/app/ThemeToggle.d.ts

@@ -1 +1,2 @@
+/** Cycles system → light → dark. */
 export declare function ThemeToggle(): import("react").JSX.Element;

package/dist/types/client/app/nav.d.ts

@@ -0,0 +1,18 @@
+import { type LucideIcon } from "lucide-react";
+export type DashboardSection = "overview" | "models" | "providers" | "costs" | "requests" | "errors" | "traces" | "tools" | "frustration" | "projects" | "gain";
+export interface NavItem {
+    id: DashboardSection;
+    label: string;
+    icon: LucideIcon;
+    /** Second key of the `g <key>` jump shortcut. */
+    hotkey: string;
+}
+export interface NavGroup {
+    heading: string;
+    items: readonly NavItem[];
+}
+/** Sidebar structure; the order here is the order on screen. */
+export declare const NAV: readonly NavGroup[];
+export declare const NAV_ITEMS: readonly NavItem[];
+export declare const SECTIONS: readonly DashboardSection[];
+export declare function navItem(section: DashboardSection): NavItem;

package/dist/types/client/charts/BarList.d.ts

@@ -0,0 +1,17 @@
+import type { ReactNode } from "react";
+export interface BarListItem {
+    key: string;
+    label: ReactNode;
+    value: number;
+    /** Formatted figure; defaults to `value.toLocaleString()`. */
+    display?: string;
+    color?: string;
+}
+export interface BarListProps {
+    items: readonly BarListItem[];
+    /** Scale maximum; defaults to the largest value. */
+    max?: number;
+    onSelect?: (key: string) => void;
+}
+/** Ranked rows with a proportional tinted fill behind each label. */
+export declare function BarList({ items, max, onSelect }: BarListProps): import("react").JSX.Element;

package/dist/types/client/charts/Chart.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Core SVG chart: categorical x slots, stacked or grouped bars, stacked areas
+ * and lines, an optional right axis, a hover cursor and a floating tooltip.
+ * Marks are crisp and unsmoothed — square bars, straight segments.
+ *
+ * `TimeChart` wraps this for bucketed time series; use `Chart` directly for
+ * categorical axes (hour of day, model names).
+ */
+import { type ReactNode } from "react";
+import type { ChartKind, ChartSeries, ReferenceLine } from "./types.js";
+export interface ChartProps {
+    /** Number of x positions; every series' `values` has this length. */
+    slots: number;
+    /** Axis label for a slot. */
+    tickLabel: (index: number) => string;
+    /** Tooltip heading for a slot; defaults to `tickLabel`. */
+    tooltipTitle?: (index: number) => string;
+    series: readonly ChartSeries[];
+    /** Mark for series without their own `kind`. Default `"bars"`. */
+    kind?: ChartKind;
+    /** Stack left-axis bars/areas. Default true. */
+    stacked?: boolean;
+    /** Plot height in px (axes included). Default 220. */
+    height?: number;
+    /** Left-axis and tooltip formatter. Default compact number. */
+    format?: (value: number) => string;
+    formatRight?: (value: number) => string;
+    /** Tooltip value formatter (left axis); defaults to `format`. Use for full precision. */
+    formatTooltip?: (value: number) => string;
+    /** Fixed axis maxima (e.g. 1 for fractions); otherwise nice-rounded from data. */
+    yMax?: number;
+    yMaxRight?: number;
+    /** Series keys to omit (legend toggles). */
+    hidden?: ReadonlySet<string>;
+    /** Show a total row in the tooltip. Default: stacked with 2+ series. */
+    showTotal?: boolean;
+    references?: readonly ReferenceLine[];
+    onSelect?: (index: number) => void;
+    /** Shown over empty axes when every visible value is zero. */
+    emptyLabel?: ReactNode;
+    /** Extra tooltip rows for a slot (below the series rows). */
+    tooltipExtra?: (index: number) => ReactNode;
+}
+export declare function Chart({ slots, tickLabel, tooltipTitle, series, kind, stacked, height, format, formatRight, formatTooltip, yMax, yMaxRight, hidden, showTotal, references, onSelect, emptyLabel, tooltipExtra, }: ChartProps): import("react").JSX.Element;
+/** Round an axis maximum up to 1/2/2.5/5 × 10ⁿ and return evenly spaced ticks from 0. */
+export declare function niceScale(max: number): {
+    max: number;
+    ticks: number[];
+};

package/dist/types/client/charts/Legend.d.ts

@@ -0,0 +1,16 @@
+export interface LegendItem {
+    key: string;
+    label: string;
+    color: string;
+    /** Optional right-hand figure (e.g. the series total). */
+    value?: string;
+}
+export interface LegendProps {
+    items: readonly LegendItem[];
+    /** Keys currently hidden; with `onToggle` the items become buttons. */
+    hidden?: ReadonlySet<string>;
+    onToggle?: (key: string) => void;
+}
+export declare function Legend({ items, hidden, onToggle }: LegendProps): import("react").JSX.Element;
+/** Hidden-key set for toggleable legends. */
+export declare function useHiddenSeries(): [ReadonlySet<string>, (key: string) => void];

package/dist/types/client/charts/ShareBar.d.ts

@@ -0,0 +1,11 @@
+export interface ShareSegment {
+    key: string;
+    label: string;
+    value: number;
+    color: string;
+}
+/** Single horizontal bar split proportionally among segments (zero segments omitted). */
+export declare function ShareBar({ segments, height }: {
+    segments: readonly ShareSegment[];
+    height?: number;
+}): import("react").JSX.Element;

package/dist/types/client/charts/Sparkline.d.ts

@@ -0,0 +1,11 @@
+export interface SparklineProps {
+    values: readonly number[];
+    color?: string;
+    height?: number;
+    /** Fixed width; omit to fill the container. */
+    width?: number;
+    /** Fill under the line. Default true. */
+    area?: boolean;
+}
+/** Axis-free trend line for stat tiles and table cells. */
+export declare function Sparkline({ values, color, height, width, area }: SparklineProps): import("react").JSX.Element;

package/dist/types/client/charts/TimeChart.d.ts

@@ -0,0 +1,9 @@
+import { type ChartProps } from "./Chart.js";
+export interface TimeChartProps extends Omit<ChartProps, "slots" | "tickLabel" | "tooltipTitle" | "onSelect"> {
+    /** Ascending bucket starts (see `bucketAxis`); series values align with them. */
+    buckets: readonly number[];
+    bucketMs: number;
+    onSelectBucket?: (bucketStart: number) => void;
+}
+/** {@link Chart} over a bucketed time axis. */
+export declare function TimeChart({ buckets, bucketMs, onSelectBucket, ...rest }: TimeChartProps): import("react").JSX.Element;

package/dist/types/client/charts/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./BarList.js";
+export * from "./Chart.js";
+export * from "./Legend.js";
+export * from "./ShareBar.js";
+export * from "./Sparkline.js";
+export * from "./TimeChart.js";
+export * from "./types.js";

package/dist/types/client/charts/types.d.ts

@@ -0,0 +1,25 @@
+/** One plotted series. `values` align index-for-index with the chart's x slots. */
+export interface ChartSeries {
+    key: string;
+    label: string;
+    color: string;
+    /** `null` leaves a gap (lines) or an empty slot (bars). */
+    values: readonly (number | null)[];
+    /** Overrides the chart-level `kind` for this series (e.g. a line over bars). */
+    kind?: ChartKind;
+    /** Plot against the right axis (uses `formatRight`). Right-axis series never stack. */
+    axis?: "left" | "right";
+    /** Diagonal hatching instead of a solid fill (bars/areas). */
+    pattern?: "hatch";
+    /** Dashed stroke (lines). */
+    dashed?: boolean;
+    /** Leave this series out of the tooltip (e.g. a trend line that repeats a bar). */
+    tooltip?: false;
+}
+export type ChartKind = "bars" | "area" | "line";
+/** Horizontal guide drawn across the plot (e.g. a 100% capacity line). */
+export interface ReferenceLine {
+    value: number;
+    label?: string;
+    axis?: "left" | "right";
+}

package/dist/types/client/charts/useWidth.d.ts

@@ -0,0 +1,3 @@
+import { type RefObject } from "react";
+/** Track an element's content width (ResizeObserver). Returns 0 until measured. */
+export declare function useWidth<T extends HTMLElement>(): [RefObject<T | null>, number];

package/dist/types/client/data/colors.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Categorical series colors. Every multi-series chart and table swatch draws
+ * from {@link SERIES_COLORS}; ranking keeps the busiest series on the most
+ * legible hues and the same key on the same hue across charts of one page.
+ */
+/** Ten mid-luminance hues that read on both the black and the white chassis. */
+export declare const SERIES_COLORS: string[];
+/** Neutral used for "Other" rollups and unknown buckets. */
+export declare const OTHER_COLOR = "#6c6c74";
+/** Stable identity of a model across providers: `model::provider`. */
+export declare function modelKey(model: string, provider: string): string;
+/**
+ * Assign colors by descending weight (ties broken by key) so a model's hue is
+ * determined by its rank, not by response order. Used by every per-model view.
+ */
+export declare function buildModelColorLookup(records: readonly {
+    model: string;
+    provider: string;
+    totalRequests: number;
+}[]): Map<string, string>;
+/** Generic form of {@link buildModelColorLookup} for any keyed, weighted series. */
+export declare function buildColorLookup(items: readonly {
+    key: string;
+    weight: number;
+}[]): Map<string, string>;

package/dist/types/client/data/formatters.d.ts

@@ -5,14 +5,22 @@ export declare function formatCost(value: number, digits?: number): string;
 /** Format an API-equivalent estimate, using N/A when all usage is unpriced. */
 export declare function formatEstimatedCost(value: number, unpricedRequests: number, digits?: number): string;
 /**
- * Format one request's cost, distinguishing unpriced usage from free usage.
+ * Whether one request's zero cost means unknown spend rather than free usage.
  * Mirrors the server's `unpricedRequestSql`: `xai-oauth` is billed through a
  * subscription, and `costUnpriced` marks a row the ingest path could not price
  * (a scheduled card with no recoverable request timestamp).
  */
+export declare function isUnpricedMessage(message: Pick<MessageStats, "provider" | "usage" | "costUnpriced">): boolean;
+/** Format one request's cost, distinguishing unpriced usage from free usage. */
 export declare function formatMessageCost(message: Pick<MessageStats, "provider" | "usage" | "costUnpriced">, digits?: number): string;
 export declare function formatPercent(value: number, digits?: number): string;
 export declare function formatDurationMs(value: number | null, digits?: number): string;
+/** Wall-clock length: seconds below a minute, then `17m 41s` / `2h 05m`. */
+export declare function formatElapsed(ms: number): string;
 export declare function formatTokensPerSecond(value: number | null): string;
 export declare function formatRelativeTime(timestamp: number): string;
+/** Absolute local date and time to the second ("Sep 28, 14:03:22"). */
+export declare function formatTimestamp(timestamp: number): string;
+/** Project folder as stored by ingest (`/work-pi/`), without the slashes. */
+export declare function formatFolder(folder: string): string;
 export declare function formatBytes(value: number): string;

package/dist/types/client/data/live.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Live dashboard state streamed from the server (`/api/events`): the data
+ * version every query revalidates against, background ingest progress, and
+ * the rollup indexing backlog.
+ *
+ * Any component can `useLive()`; queries (see `useQuery`) refetch whenever
+ * `version` advances, so rows ingested in the background repaint the active
+ * page without a manual refresh.
+ */
+import { type ReactNode } from "react";
+import type { LiveSyncStatus } from "../types.js";
+export interface LiveState {
+    /**
+     * Client-side data version; bumps whenever the server's version changes
+     * (including after reconnecting to a restarted server).
+     */
+    version: number;
+    sync: LiveSyncStatus;
+    /** Hours whose rollups are still being built; wide ranges may be incomplete. */
+    indexingHours: number;
+    /** The event stream is open. */
+    connected: boolean;
+    /** Ask the server to ingest new session data now. */
+    requestSync: () => void;
+}
+export declare function LiveProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useLive(): LiveState;

package/dist/types/client/data/query.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `useQuery`: cached, live-revalidating data fetching for dashboard pages.
+ *
+ * - Results are cached per key for the page session, so revisiting a page or
+ *   a range renders instantly from memory.
+ * - A key change keeps the previous key's data on screen (`stale: true`) until
+ *   the new data lands, so charts morph instead of flashing skeletons.
+ * - Every cached entry remembers the live data version it was fetched at
+ *   (see `useLive`); when the version advances, enabled queries refetch in the
+ *   background, throttled so a burst of ingest batches costs one request.
+ * - Identical keys share one in-flight request.
+ */
+export interface QueryOptions {
+    /** Only enabled queries fetch; hidden (kept-alive) pages pass `false`. Default true. */
+    enabled?: boolean;
+    /** Additionally refetch on this interval while enabled and the tab is visible. */
+    pollMs?: number;
+}
+export interface QueryResult<T> {
+    /** Data for the current key, or the previous key's data while it loads. */
+    data: T | null;
+    error: Error | null;
+    /** Nothing to show yet (first load of this query). */
+    loading: boolean;
+    /** `data` belongs to a previous key; the current key is still loading. */
+    stale: boolean;
+    /** A background request is in flight. */
+    refreshing: boolean;
+    /** When the shown data was fetched. */
+    updatedAt: number | null;
+    refetch: () => void;
+}
+/** Warm the cache for a key the user is likely to open next. No-op if cached for this version. */
+export declare function prefetchQuery<T>(key: readonly unknown[], fetcher: () => Promise<T>, version: number): void;
+export declare function useQuery<T>(key: readonly unknown[], fetcher: () => Promise<T>, options?: QueryOptions): QueryResult<T>;

package/dist/types/client/data/range.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Time-range metadata shared by every page: labels, the server's bucket size
+ * for the range (mirrors `getTimeRangeConfig` in `aggregator.ts`), tick
+ * formatting, and the contiguous bucket axis charts plot against.
+ */
+import type { TimeRange } from "../types.js";
+export interface RangeMeta {
+    /** Short selector label ("24h"). */
+    label: string;
+    /** Prose label for subtitles ("the last 24 hours"). */
+    windowLabel: string;
+    /** Span covered by the range; `null` for all time. */
+    spanMs: number | null;
+    /** Bucket size of the server's primary time series for this range. */
+    bucketMs: number;
+}
+/** Ranges in selector order. */
+export declare const TIME_RANGES: readonly TimeRange[];
+export declare function rangeMeta(range: TimeRange): RangeMeta;
+/** Tick/tooltip label for a bucket start, precise enough for the bucket size. */
+export declare function formatBucket(timestamp: number, bucketMs: number): string;
+/** Compact axis tick for a bucket start. */
+export declare function formatTick(timestamp: number, bucketMs: number): string;
+/**
+ * Contiguous, ascending bucket starts covering `range`, aligned like the
+ * server's `(timestamp / bucketMs) * bucketMs`. For all time the axis starts at
+ * the earliest data point, so gaps between sessions still render as zeros;
+ * it is capped at {@link MAX_BUCKETS} so a stray epoch-zero timestamp cannot
+ * explode the axis into decades of empty days.
+ */
+export declare function bucketAxis(range: TimeRange, dataTimestamps: Iterable<number>, bucketMs?: number, now?: number): number[];

package/dist/types/client/data/series.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Turn the server's long-format bucket rows (`{ timestamp, key…, value }`)
+ * into dense chart series aligned to a bucket axis (see `bucketAxis`).
+ */
+import type { ChartSeries } from "../charts/types.js";
+/** Sum `value(point)` into a dense array aligned to `buckets`. Out-of-axis points are dropped. */
+export declare function densify<P extends {
+    timestamp: number;
+}>(points: readonly P[], buckets: readonly number[], value: (point: P) => number): number[];
+export interface PivotOptions<P> {
+    buckets: readonly number[];
+    /** Series identity for a row. */
+    key: (point: P) => string;
+    /** Display label for a series key; defaults to the key. */
+    label?: (key: string) => string;
+    value: (point: P) => number;
+    /** Keep the `limit` largest series (by total); fold the rest into "Other". */
+    limit?: number;
+    /** Fixed colors per key (e.g. from `buildModelColorLookup`); falls back to rank order. */
+    colors?: ReadonlyMap<string, string>;
+}
+/**
+ * Pivot long rows into one dense series per key, ranked by total (largest
+ * first). Series beyond `limit` merge into a trailing "Other" series.
+ */
+export declare function pivotSeries<P extends {
+    timestamp: number;
+}>(points: readonly P[], opts: PivotOptions<P>): ChartSeries[];

package/dist/types/client/data/useHashRoute.d.ts

@@ -1,10 +1,24 @@
-import type { DashboardSection } from "../app/routes.js";
+import { type DashboardSection } from "../app/nav.js";
 import type { TimeRange } from "../types.js";
+export interface HashRoute {
+    section: DashboardSection;
+    range: TimeRange;
+    /** Deep-linked trace session file (traces only). */
+    session: string | null;
+}
+export declare function parseHash(hash: string): HashRoute;
+export declare function buildHash({ section, range, session }: HashRoute): string;
+/**
+ * Dashboard location in the URL hash (`#/models?range=7d`). Setters update
+ * state synchronously and push a history entry, so the UI never waits on the
+ * `hashchange` round trip.
+ */
 export declare function useHashRoute(): {
     section: DashboardSection;
-    setSection: (newSection: DashboardSection) => void;
     range: TimeRange;
-    setRange: (newRange: string) => void;
+    /** Deep-linked trace session file (traces only). */
     session: string | null;
-    setSession: (file: string | null) => void;
+    setSection: (section: DashboardSection) => void;
+    setRange: (range: TimeRange) => void;
+    setSession: (session: string | null) => void;
 };