@camstack/ui-library 1.2.304 → 1.2.306

package/dist/composites/device-history/DeviceHistoryView.d.ts

@@ -0,0 +1,26 @@
+/**
+* DeviceHistoryView — a device's recorded history (device-history, D850):
+* the device page's History tab, and — with `fixedWindow="24h"` — the last
+* day on a camera's Live Stats tab. One code path for both.
+*
+* Grouping mirrors the State panel: one collapsible section per capability
+* (catalog order), then per producer addon; inside, one chart per unit and
+* one timeline per state. Every chart shares one cursor. A chart's ⋯ menu
+* opens its series on the History page or hides it (remembered in the
+* user's account preferences).
+*
+* Absent and pending are different screens (D315): device-history not
+* installed, the list not answered yet, and "nothing recorded" each say so.
+*/
+import { type JSX } from "react";
+import { type HistoryWindowId } from "./history-window";
+export interface DeviceHistoryViewProps {
+	readonly deviceId: number;
+	/** A fixed window with no window controls (the Live Stats tab's last day). */
+	readonly fixedWindow?: Exclude<HistoryWindowId, "custom">;
+	/** In-app navigation (react-router); default a page load under the mount. */
+	readonly onNavigate?: (path: string) => void;
+}
+/** `climate-control` → `Climate control`. */
+export declare function humanizeName(name: string): string;
+export declare function DeviceHistoryView({ deviceId, fixedWindow, onNavigate }: DeviceHistoryViewProps): JSX.Element;

package/dist/composites/device-history/HistoryChart.d.ts

@@ -0,0 +1,31 @@
+/**
+* One chart of a device's History view, from its spec and the reads.
+* Lines → `TimeSeriesChart`, states → `StateTimeline`, energy → `BarSeries`
+* with the window total, occupancy → one `TimeSeriesChart` of every
+* (zone × class) scope with zone and class filters.
+*
+* A read that failed says so in place of the chart; a read that answered no
+* point is the empty state — never a flat zero.
+*/
+import { type JSX, type ReactNode } from "react";
+import type { DeviceHistoryQueryManyEntry } from "@camstack/types";
+import { type UiTextFn } from "../../contexts/ui-text";
+import { type HistoryChartSpec } from "./history-model";
+import type { HistoryReads } from "./use-device-history";
+import type { HistoryWindow } from "./history-window";
+export interface HistoryChartProps {
+	readonly spec: HistoryChartSpec;
+	/** Entry for a series key (all scopes), current and previous period. */
+	readonly entryFor: (key: string, previous: boolean) => DeviceHistoryQueryManyEntry | undefined;
+	readonly reads: HistoryReads | null;
+	readonly window: HistoryWindow;
+	readonly compare: boolean;
+	readonly syncKey: string;
+	readonly actions?: ReactNode;
+}
+/** Operator words for a boolean field's two states. */
+export declare function booleanLabels(key: string, t: UiTextFn): {
+	readonly on: string;
+	readonly off: string;
+};
+export declare function HistoryChart({ spec, entryFor, reads, window, compare, syncKey, actions }: HistoryChartProps): JSX.Element;

package/dist/composites/device-history/HistoryWindowBar.d.ts

@@ -0,0 +1,16 @@
+/**
+* The window controls on top of a History view: 24h | 7d | 30d | 1y | custom,
+* a custom from/to when picked, and "compare with previous period".
+*/
+import { type JSX } from "react";
+import type { CustomWindow, HistoryWindowId } from "./history-window";
+export interface HistoryWindowBarProps {
+	readonly value: HistoryWindowId;
+	readonly onChange: (id: HistoryWindowId) => void;
+	readonly custom: CustomWindow | null;
+	readonly onCustomChange: (w: CustomWindow) => void;
+	/** Omit to hide the compare control. */
+	readonly compare?: boolean;
+	readonly onCompareChange?: (on: boolean) => void;
+}
+export declare function HistoryWindowBar({ value, onChange, custom, onCustomChange, compare, onCompareChange }: HistoryWindowBarProps): JSX.Element;

package/dist/composites/device-history/history-model.d.ts

@@ -0,0 +1,121 @@
+/**
+* The pure half of a device's History view: which charts a device's series
+* make, in which sections, and how a `query` answer becomes chart data.
+*
+* Grouping mirrors the State panel: one section per capability in
+* `HISTORY_CATALOG` order (its fields in catalog order), then one section per
+* producer addon, sorted. Inside a section: one line chart per UNIT (never
+* two units on one axis), one state timeline per boolean or enum, the
+* derived energy as bars. A camera's occupancy is ONE chart of every
+* (zone × class) scope.
+*/
+import { type DeviceHistoryQueryResult, type DeviceHistorySeriesInfo } from "@camstack/types";
+import type { BarBucket } from "../charts/bar-series-model";
+import type { StateSegment, TimePoint } from "../charts/chart-data";
+/** The producer series a camera's occupancy chart reads. */
+export declare const OCCUPANCY_KEY = "addon:pipeline-analytics/occupancy";
+export type HistoryChartSpec = {
+	readonly type: "lines";
+	readonly id: string;
+	readonly title: string;
+	readonly unit: string | null;
+	readonly series: readonly DeviceHistorySeriesInfo[];
+} | {
+	readonly type: "states";
+	readonly id: string;
+	readonly title: string;
+	readonly series: DeviceHistorySeriesInfo;
+} | {
+	readonly type: "energy";
+	readonly id: string;
+	readonly title: string;
+	readonly series: DeviceHistorySeriesInfo;
+} | {
+	readonly type: "occupancy";
+	readonly id: string;
+	readonly title: string;
+	readonly series: readonly DeviceHistorySeriesInfo[];
+};
+export interface HistorySection {
+	readonly id: string;
+	/** `cap` — a capability's fields; `producer` — an addon's declared series. */
+	readonly kind: "cap" | "producer";
+	/** Capability name or producer addon id. */
+	readonly name: string;
+	readonly charts: readonly HistoryChartSpec[];
+}
+/** `cap:<capName>.<fieldPath>` → its parts; `null` for any other key. */
+export declare function parseCapKey(key: string): {
+	readonly cap: string;
+	readonly field: string;
+} | null;
+/** `addon:<addonId>/<name>` → its parts; `null` for any other key. */
+export declare function parseProducerKey(key: string): {
+	readonly addonId: string;
+	readonly name: string;
+} | null;
+/**
+* Group a device's series into sections. Energy (a derived key) joins the
+* `power-meter` section when the device has one, else gets its own.
+*/
+export declare function groupDeviceSeries(series: readonly DeviceHistorySeriesInfo[], capTitle: (cap: string) => string): readonly HistorySection[];
+/** The unique keys a set of charts reads (one `queryMany` item each: every scope comes back). */
+export declare function chartKeys(charts: readonly HistoryChartSpec[]): readonly string[];
+/** One series of a `query` answer, found by scope. */
+export declare function seriesOf(result: DeviceHistoryQueryResult | undefined, scope: string): DeviceHistoryQueryResult["series"][number] | undefined;
+/**
+* Line points for a gauge or counter. A rolled-up answer carries its
+* min/max (a band). A CAP series is change-only and held, so the window
+* opens on the value in force (`before`); a producer's buckets are not held
+* and an absent bucket is a hole.
+*/
+export declare function linePoints(info: DeviceHistorySeriesInfo, result: DeviceHistoryQueryResult | undefined, from: number): {
+	readonly points: readonly TimePoint[];
+	readonly gapMs: number | undefined;
+	readonly held: boolean;
+};
+/** Shift every point by `shiftMs` (a previous period laid over the current one). */
+export declare function shiftPoints(points: readonly TimePoint[], shiftMs: number): readonly TimePoint[];
+/** The state names a boolean series takes, `false` first. */
+export declare const BOOLEAN_STATES: readonly ["false", "true"];
+/**
+* A state series as segments plus the exact time spent in each state.
+*
+* Raw points are changes. A rollup bucket is drawn in its DOMINANT state
+* (the one held longest in it), while the totals add the bucket's real
+* per-state milliseconds — so "open 2h 14m" stays exact at any zoom.
+*/
+export declare function stateRow(info: DeviceHistorySeriesInfo, result: DeviceHistoryQueryResult | undefined, from: number, to: number): {
+	readonly segments: readonly StateSegment[];
+	readonly totals: ReadonlyMap<string, number>;
+	readonly states: readonly string[];
+};
+/** Energy bars: one bucket per point, the kWh used in it (`delta`). */
+export declare function energyBuckets(result: DeviceHistoryQueryResult | undefined): {
+	readonly buckets: readonly BarBucket[];
+	readonly bucketMs: number;
+};
+export interface OccupancyScopeLine {
+	readonly scope: string;
+	/** `''` = the whole frame. */
+	readonly zoneId: string;
+	/** `undefined` = every class. */
+	readonly className: string | undefined;
+}
+export declare function occupancyLines(series: readonly DeviceHistorySeriesInfo[]): readonly OccupancyScopeLine[];
+/** The filter values an occupancy chart offers: zones and classes that exist. */
+export declare function occupancyFacets(lines: readonly OccupancyScopeLine[]): {
+	readonly zones: readonly string[];
+	readonly classes: readonly string[];
+};
+/** `null` = all. */
+export interface OccupancyFilter {
+	readonly zone: string | null;
+	readonly className: string | null;
+}
+/**
+* The lines a filter keeps. With no class picked the per-zone AGGREGATE lines
+* show (summing classes again would double count); a class shows that class
+* in every (or the picked) zone.
+*/
+export declare function filterOccupancyLines(lines: readonly OccupancyScopeLine[], filter: OccupancyFilter): readonly OccupancyScopeLine[];

package/dist/composites/device-history/history-reads.d.ts

@@ -0,0 +1,43 @@
+/**
+* Batched history reads. `queryMany` answers up to 24 reads over one window
+* in one call — but it is admin-only (its subjects are nested where the
+* device scope gate cannot see them). A principal it refuses reads each
+* DEVICE series through `query` instead; a node series has no other door and
+* is reported as refused.
+*
+* Every item gets an entry, in order: an answer, or the error that item met.
+* A failed item never hides the others, and is never an empty series.
+*/
+import { type DeviceHistoryQueryManyEntry, type DeviceHistoryQueryManyItem, type DeviceHistoryQueryResult } from "@camstack/types";
+export interface HistoryReadWindow {
+	readonly from: number;
+	readonly to: number;
+	readonly maxPoints?: number;
+}
+/** The two doors `readHistory` uses — the tRPC client in the app, a fake in a spec. */
+export interface HistoryReader {
+	queryMany(input: {
+		readonly items: DeviceHistoryQueryManyItem[];
+		readonly from: number;
+		readonly to: number;
+		readonly resolution: "auto";
+		readonly maxPoints: number;
+	}): Promise<{
+		readonly results: readonly DeviceHistoryQueryManyEntry[];
+	}>;
+	query(input: {
+		readonly deviceId: number;
+		readonly key: string;
+		readonly scope?: string;
+		readonly from: number;
+		readonly to: number;
+		readonly resolution: "auto";
+		readonly maxPoints: number;
+	}): Promise<DeviceHistoryQueryResult>;
+}
+/** Split into batches of at most `size`. */
+export declare function chunk<T>(items: readonly T[], size: number): readonly (readonly T[])[];
+/** Did the hub refuse this principal (rather than fail)? */
+export declare function isRefusal(err: unknown): boolean;
+/** Read every item over one window; one entry per item, in order. */
+export declare function readHistory(reader: HistoryReader, items: readonly DeviceHistoryQueryManyItem[], window: HistoryReadWindow): Promise<readonly DeviceHistoryQueryManyEntry[]>;

package/dist/composites/device-history/history-selection.d.ts

@@ -0,0 +1,55 @@
+import { type HistoryWindowId } from "./history-window";
+export type HistorySubject = {
+	readonly kind: "device";
+	readonly deviceId: number;
+} | {
+	readonly kind: "node";
+	readonly nodeId: string;
+};
+export interface HistorySeriesRef {
+	readonly subject: HistorySubject;
+	readonly key: string;
+	readonly scope: string;
+}
+/** The most series one overlay may carry — one `queryMany` batch. */
+export declare const HISTORY_SELECTION_MAX = 24;
+/** Stable identity of a series ref (React key, dedup, colour slot). */
+export declare function seriesRefId(ref: HistorySeriesRef): string;
+/** One `?s=` value: `d,<deviceId>,<key>,<scope>` or `n,<nodeId>,<key>,<scope>`, each part URI-encoded. */
+export declare function encodeSeriesRef(ref: HistorySeriesRef): string;
+export declare function decodeSeriesRef(raw: string): HistorySeriesRef | null;
+/** Unique refs, in order, capped at {@link HISTORY_SELECTION_MAX}. */
+export declare function normalizeSelection(refs: readonly HistorySeriesRef[]): readonly HistorySeriesRef[];
+/** The History page path showing `refs` over `window`. */
+export declare function historyPageHref(refs: readonly HistorySeriesRef[], window?: HistoryWindowId): string;
+/** The cross-device History page's route. */
+export declare const HISTORY_PAGE_PATH = "/system/history";
+/** The account preference namespace that holds saved panels and hidden charts. */
+export declare const HISTORY_PANELS_NAMESPACE = "admin.history-panels";
+export interface HistoryPanel {
+	readonly id: string;
+	readonly name: string;
+	readonly window: HistoryWindowId;
+	readonly selection: readonly HistorySeriesRef[];
+}
+export interface HistoryPanelsValue {
+	readonly version: 1;
+	readonly panels: readonly HistoryPanel[];
+	/** Chart ids an operator hid on a device's History tab, per device id. */
+	readonly hidden: Readonly<Record<string, readonly string[]>>;
+}
+export declare const EMPTY_HISTORY_PANELS: HistoryPanelsValue;
+/**
+* Read a stored row's value. A row this client cannot read (another
+* version, a hand edit) is answered as empty rather than throwing — and the
+* caller must not write over it blindly: `parsed: false` says so.
+*/
+export declare function readHistoryPanels(value: unknown): {
+	readonly value: HistoryPanelsValue;
+	readonly parsed: boolean;
+};
+/** A copy of `value` with chart `chartId` hidden (or shown again) on device `deviceId`. */
+export declare function withHiddenChart(value: HistoryPanelsValue, deviceId: number, chartId: string, hidden: boolean): HistoryPanelsValue;
+/** A copy of `value` with `panel` saved (replacing one with the same id). */
+export declare function withPanel(value: HistoryPanelsValue, panel: HistoryPanel): HistoryPanelsValue;
+export declare function withoutPanel(value: HistoryPanelsValue, panelId: string): HistoryPanelsValue;

package/dist/composites/device-history/history-window.d.ts

@@ -0,0 +1,31 @@
+/**
+* The time windows a history view offers, and the "previous period" a
+* comparison reads. Pure: the caller supplies `now`.
+*/
+export type HistoryWindowId = "24h" | "7d" | "30d" | "1y" | "custom";
+export declare const HISTORY_WINDOW_IDS: readonly ["24h", "7d", "30d", "1y", "custom"];
+export declare const HISTORY_WINDOW_MS: Readonly<Record<Exclude<HistoryWindowId, "custom">, number>>;
+export interface HistoryWindow {
+	readonly from: number;
+	readonly to: number;
+}
+export interface CustomWindow {
+	readonly from: number;
+	readonly to: number;
+}
+export declare function isHistoryWindowId(v: string | null | undefined): v is HistoryWindowId;
+/**
+* The window a preset means at `now`. `custom` without a valid range (from
+* before to) falls back to the last 24 hours rather than an empty window.
+*/
+export declare function resolveHistoryWindow(id: HistoryWindowId, now: number, custom?: CustomWindow | null): HistoryWindow;
+/** The period of the same length just before `w`, and the shift that lays it over `w`. */
+export declare function previousWindow(w: HistoryWindow): {
+	readonly window: HistoryWindow;
+	readonly shiftMs: number;
+};
+/** Encode a custom range for the URL: `<fromMs>-<toMs>`. */
+export declare function encodeCustomWindow(w: CustomWindow): string;
+export declare function decodeCustomWindow(raw: string | null | undefined): CustomWindow | null;
+/** Milliseconds a rollup bucket of a resolution covers (`1d` is nominal across DST). */
+export declare const RESOLUTION_BUCKET_MS: Readonly<Record<"5m" | "1h" | "1d", number>>;

package/dist/composites/device-history/index.d.ts

@@ -0,0 +1,14 @@
+/**
+* Device history views (D850, D896): the device History tab / Live Stats
+* last day (`DeviceHistoryView`) and the building blocks the cross-device
+* History page composes.
+*/
+export { DeviceHistoryView, humanizeName, type DeviceHistoryViewProps } from "./DeviceHistoryView";
+export { HistoryChart, booleanLabels, type HistoryChartProps } from "./HistoryChart";
+export { HistoryWindowBar, type HistoryWindowBarProps } from "./HistoryWindowBar";
+export { BOOLEAN_STATES, OCCUPANCY_KEY, chartKeys, energyBuckets, filterOccupancyLines, groupDeviceSeries, linePoints, occupancyFacets, occupancyLines, parseCapKey, parseProducerKey, shiftPoints, stateRow, type HistoryChartSpec, type HistorySection, type OccupancyFilter, type OccupancyScopeLine } from "./history-model";
+export { chunk, isRefusal, readHistory, type HistoryReader, type HistoryReadWindow } from "./history-reads";
+export { EMPTY_HISTORY_PANELS, HISTORY_PAGE_PATH, HISTORY_PANELS_NAMESPACE, HISTORY_SELECTION_MAX, decodeSeriesRef, encodeSeriesRef, historyPageHref, normalizeSelection, readHistoryPanels, seriesRefId, withHiddenChart, withPanel, withoutPanel, type HistoryPanel, type HistoryPanelsValue, type HistorySeriesRef, type HistorySubject } from "./history-selection";
+export { HISTORY_WINDOW_IDS, HISTORY_WINDOW_MS, RESOLUTION_BUCKET_MS, decodeCustomWindow, encodeCustomWindow, isHistoryWindowId, previousWindow, resolveHistoryWindow, type CustomWindow, type HistoryWindow, type HistoryWindowId } from "./history-window";
+export { anchorNow, readItemId, useDeviceSeriesList, useHistoryReader, useHistoryReads, type HistoryReads, type HistoryStage } from "./use-device-history";
+export { useHistoryPanels, type HistoryPanelsState } from "./use-history-panels";

package/dist/composites/device-history/use-device-history.d.ts

@@ -0,0 +1,37 @@
+import type { DeviceHistoryQueryManyEntry, DeviceHistoryQueryManyItem, DeviceHistorySeriesInfo } from "@camstack/types";
+import { type CapabilityPresence } from "../../hooks/use-capability-presence";
+import { type HistoryReader } from "./history-reads";
+import { type HistoryWindow } from "./history-window";
+/** How a stage of the view stands. */
+export type HistoryStage<T> = {
+	readonly status: "pending";
+} | {
+	readonly status: "error";
+	readonly error: string;
+} | {
+	readonly status: "ok";
+	readonly data: T;
+};
+/**
+* The instant a window ends at, rounded so the query key is stable between
+* renders and the view refreshes at a pace its width justifies.
+*/
+export declare function anchorNow(now: number, spanMs: number): number;
+/** The tRPC client as the two doors `readHistory` needs. */
+export declare function useHistoryReader(): HistoryReader;
+/** A device's series list, gated on device-history being present. */
+export declare function useDeviceSeriesList(deviceId: number): {
+	readonly presence: CapabilityPresence;
+	readonly list: HistoryStage<readonly DeviceHistorySeriesInfo[]>;
+};
+export interface HistoryReads {
+	/** Entry per item id (see {@link readItemId}). */
+	readonly current: ReadonlyMap<string, DeviceHistoryQueryManyEntry>;
+	/** The previous period, when comparing; shifted by `shiftMs` to overlay. */
+	readonly previous: ReadonlyMap<string, DeviceHistoryQueryManyEntry> | null;
+	readonly shiftMs: number;
+}
+/** Identity of a read item: subject + key (+ scope when narrowed). */
+export declare function readItemId(item: DeviceHistoryQueryManyItem): string;
+/** Read `items` over `window` (and the previous period when `compare`). */
+export declare function useHistoryReads(items: readonly DeviceHistoryQueryManyItem[], window: HistoryWindow, compare: boolean, enabled?: boolean): HistoryStage<HistoryReads>;

package/dist/composites/device-history/use-history-panels.d.ts

@@ -0,0 +1,10 @@
+import { type HistoryPanelsValue } from "./history-selection";
+export interface HistoryPanelsState {
+	/** `pending` until the row answered; `error` when the read failed (never "no panels"). */
+	readonly status: "pending" | "error" | "ok";
+	readonly value: HistoryPanelsValue;
+	/** False when the stored row could not be read: writing would destroy it. */
+	readonly writable: boolean;
+	readonly update: (change: (current: HistoryPanelsValue) => HistoryPanelsValue) => Promise<void>;
+}
+export declare function useHistoryPanels(): HistoryPanelsState;

package/dist/composites/index.d.ts

@@ -223,3 +223,5 @@ export * from "./device-picker/index.js";
 export * from "./unit-picker/index.js";
 export * from "./placeholder-field/index.js";
 export { type RetrainReviewBadgeKind, type RetrainReviewBadgeLook, type RetrainReviewBadgeProps, RetrainReviewBadge, retrainReviewBadgeLook } from "./training/retrain-review-badge";
+export * from "./charts/index.js";
+export * from "./device-history/index.js";

package/dist/composites/log-history-paging.d.ts

@@ -0,0 +1,62 @@
+/**
+* Pure paging logic for the server-served log history (D898).
+*
+* The server answers one TIME-BOUNDED slice per call: `done: false` with fewer
+* than `limit` entries means "the budget ran out, still searching". The client
+* keeps calling with `before: nextBefore` until it holds a full page, the
+* source says `done`, or the operator cancels. Kept free of React and tRPC so
+* the loop is unit-testable.
+*/
+export interface LogWireEntry {
+	readonly id?: string;
+	readonly timestamp: string;
+	readonly level: string;
+	readonly message: string;
+	readonly scope?: string;
+	readonly tags?: Record<string, string | undefined>;
+	readonly meta?: Record<string, unknown>;
+}
+export interface LogWirePage {
+	/** NEWEST FIRST. */
+	readonly entries: readonly LogWireEntry[];
+	readonly nextBefore: string | null;
+	readonly nextAfter: string | null;
+	readonly scannedBytes: number;
+	readonly done: boolean;
+	readonly cancelled?: boolean;
+	readonly source: string;
+}
+/** Fetches one slice older than `before` (undefined = the first page). */
+export type FetchLogSlice = (before: string | undefined, remaining: number, signal: AbortSignal) => Promise<LogWirePage>;
+export interface CollectedPage {
+	/** NEWEST FIRST, across every slice the loop made. */
+	readonly entries: readonly LogWireEntry[];
+	/** Cursor for the next older page; null when nothing older exists. */
+	readonly nextBefore: string | null;
+	readonly done: boolean;
+	readonly cancelled: boolean;
+	readonly scannedBytes: number;
+	readonly source: string | undefined;
+}
+export interface CollectPageOptions {
+	readonly fetchSlice: FetchLogSlice;
+	readonly limit: number;
+	readonly before?: string;
+	readonly signal: AbortSignal;
+	/** Called after every slice with the bytes scanned so far. */
+	readonly onProgress?: (scannedBytes: number) => void;
+}
+/**
+* Accumulate slices until `limit` entries, `done`, or an abort. An abort keeps
+* what was already collected and the cursor reached, so "Load older" resumes
+* where the scan stopped instead of starting again.
+*/
+export declare function collectPage(options: CollectPageOptions): Promise<CollectedPage>;
+/** Stable identity of an entry: the server id, else the legacy composite key. */
+export declare function logEntryKey(entry: LogWireEntry): string;
+/**
+* History (newest first, as paged) merged with live entries (arrival order),
+* deduped by key — a live entry wins (richer tags/meta) — and returned
+* chronologically, newest LAST. Ties keep insertion order.
+*/
+export declare function mergeLogEntries(history: readonly LogWireEntry[], live: readonly LogWireEntry[]): LogWireEntry[];

package/dist/composites/log-stream.d.ts

@@ -10,14 +10,8 @@
 */
 import { type JSX } from "react";
 import { type LiveBuffer } from "../hooks/use-live-buffer";
-interface LogEntry {
-	readonly timestamp: string;
-	readonly level: string;
-	readonly message: string;
-	readonly scope?: string;
-	readonly tags?: Record<string, string | undefined>;
-	readonly meta?: Record<string, unknown>;
-}
+import { type LogWireEntry } from "./log-history-paging";
+type LogEntry = LogWireEntry;
 export interface LogStreamProps {
 	/** Lock to a specific agent. When set, the agent selector is hidden. */
 	readonly agentId?: string;
@@ -65,7 +59,9 @@ export interface LogStreamProps {
 	readonly showDeviceChip?: boolean;
 	/** Show the filter bar with selectors. Set false for compact inline use. */
 	readonly showFilters?: boolean;
-	/** Initial number of historical entries to fetch (default: 100). */
+	/** Show the history source selector (default: follows `showFilters`). */
+	readonly showSourceSelect?: boolean;
+	/** Entries per history page (default: 100). */
 	readonly limit?: number;
 	/**
 	* Optional controlled live buffer. When provided, the stream reads
@@ -79,7 +75,7 @@ export interface LogStreamProps {
 	readonly onClose?: () => void;
 	readonly className?: string;
 }
-export declare function LogStream({ agentId: propsAgentId, addonId: propsAddonId, deviceId: propsDeviceId, containerDeviceId: propsContainerDeviceId, integrationId: propsIntegrationId, requestId: propsRequestId, level: initialLevel, maxHeight, showScope, showDeviceChip, showFilters, limit, liveBuffer: externalBuffer, onClose, className }: LogStreamProps): JSX.Element;
+export declare function LogStream({ agentId: propsAgentId, addonId: propsAddonId, deviceId: propsDeviceId, containerDeviceId: propsContainerDeviceId, integrationId: propsIntegrationId, requestId: propsRequestId, level: initialLevel, maxHeight, showScope, showDeviceChip, showFilters, showSourceSelect, limit, liveBuffer: externalBuffer, onClose, className }: LogStreamProps): JSX.Element;
 export interface FloatingLogStreamProps extends LogStreamProps {
 	/** Position: 'bottom' anchors to parent bottom, 'overlay' is absolute positioned. */
 	readonly position?: "bottom" | "overlay";

package/dist/generated/system-hooks.d.ts

@@ -487,6 +487,8 @@ export declare const useDeviceHistoryListNodeSeries: typeof trpc.deviceHistory.l
 export declare const useDeviceHistoryQuery: typeof trpc.deviceHistory.query.useQuery;
 /** Generated alias around `trpc.deviceHistory.queryNode.useQuery`. */
 export declare const useDeviceHistoryQueryNode: typeof trpc.deviceHistory.queryNode.useQuery;
+/** Generated alias around `trpc.deviceHistory.queryMany.useQuery`. */
+export declare const useDeviceHistoryQueryMany: typeof trpc.deviceHistory.queryMany.useQuery;
 /** Generated alias around `trpc.deviceHistory.declareSeries.useMutation`. */
 export declare const useDeviceHistoryDeclareSeries: typeof trpc.deviceHistory.declareSeries.useMutation;
 /** Generated alias around `trpc.deviceHistory.record.useMutation`. */

package/dist/hooks/use-log-history.d.ts

@@ -0,0 +1,26 @@
+import { type LogWireEntry } from "../composites/log-history-paging";
+export type LogHistoryLevel = "debug" | "info" | "warn" | "error";
+/** The filters the SERVER applies; everything but paging. */
+export interface LogHistoryQuery {
+	/** A log-destination addonId or `ring`; undefined = the server default. */
+	readonly source?: string;
+	readonly level: LogHistoryLevel;
+	readonly text?: string;
+	readonly tags?: Record<string, string | number>;
+}
+export type LogHistoryStatus = "idle" | "loading";
+export interface LogHistory {
+	/** Newest first, as paged. */
+	readonly entries: readonly LogWireEntry[];
+	readonly status: LogHistoryStatus;
+	/** True when nothing older exists ("Beginning of logs"). */
+	readonly done: boolean;
+	/** Bytes scanned by the scan in flight (0 until its first slice answers). */
+	readonly scannedBytes: number;
+	/** The source that answered (the server may fall back to `ring`). */
+	readonly source: string | undefined;
+	readonly error: string | null;
+	readonly loadOlder: () => void;
+	readonly cancel: () => void;
+}
+export declare function useLogHistory(query: LogHistoryQuery, limit: number): LogHistory;

package/dist/{icons-B1AFXUaZ.cjs → icons-BTux33dH.cjs}

@@ -7414,19 +7414,6 @@ var ChartGantt = require_createLucideIcon.createLucideIcon("chart-gantt", [
 * This source code is licensed under the ISC license.
 * See the LICENSE file in the root directory of this source tree.
 */
-var ChartLine = require_createLucideIcon.createLucideIcon("chart-line", [["path", {
-	d: "M3 3v16a2 2 0 0 0 2 2h16",
-	key: "c24i48"
-}], ["path", {
-	d: "m19 9-5 5-4-4-3 3",
-	key: "2osh9i"
-}]]);
-/**
-* @license lucide-react v0.576.0 - ISC
-*
-* This source code is licensed under the ISC license.
-* See the LICENSE file in the root directory of this source tree.
-*/
 var ChartNetwork = require_createLucideIcon.createLucideIcon("chart-network", [
 	["path", {
 		d: "m13.11 7.664 1.78 2.672",
@@ -18204,26 +18191,6 @@ var Highlighter = require_createLucideIcon.createLucideIcon("highlighter", [["pa
 * This source code is licensed under the ISC license.
 * See the LICENSE file in the root directory of this source tree.
 */
-var History = require_createLucideIcon.createLucideIcon("history", [
-	["path", {
-		d: "M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8",
-		key: "1357e3"
-	}],
-	["path", {
-		d: "M3 3v5h5",
-		key: "1xhq8a"
-	}],
-	["path", {
-		d: "M12 7v5l4 2",
-		key: "1fdv2h"
-	}]
-]);
-/**
-* @license lucide-react v0.576.0 - ISC
-*
-* This source code is licensed under the ISC license.
-* See the LICENSE file in the root directory of this source tree.
-*/
 var HopOff = require_createLucideIcon.createLucideIcon("hop-off", [
 	["path", {
 		d: "M10.82 16.12c1.69.6 3.91.79 5.18.85.28.01.53-.09.7-.27",
@@ -38164,7 +38131,7 @@ exports.ChartColumnDecreasing = ChartColumnDecreasing;
 exports.ChartColumnIncreasing = ChartColumnIncreasing;
 exports.ChartColumnStacked = ChartColumnStacked;
 exports.ChartGantt = ChartGantt;
-exports.ChartLine = ChartLine;
+exports.ChartLine = require_index.ChartLine;
 exports.ChartNetwork = ChartNetwork;
 exports.ChartNoAxesColumn = ChartNoAxesColumn;
 exports.ChartNoAxesColumnDecreasing = ChartNoAxesColumnDecreasing;
@@ -38662,7 +38629,7 @@ exports.Heater = require_index.Heater;
 exports.Helicopter = Helicopter;
 exports.Hexagon = require_mic_off.Hexagon;
 exports.Highlighter = Highlighter;
-exports.History = History;
+exports.History = require_index.History;
 exports.Hop = Hop;
 exports.HopOff = HopOff;
 exports.Hospital = Hospital;