@camstack/ui-library 1.2.256 → 1.2.258

package/dist/composites/data-table-pagination.d.ts

@@ -1,31 +1,31 @@
 /**
- * Client-side pagination for {@link DataTable} — pure, no React.
- *
- * The table sorts first and pages second, so page 1 always holds the first
- * rows of the CURRENT order. A page past the end (the rows shrank under it:
- * a filter narrowed, a revoke removed rows) clamps to the last page instead
- * of rendering an empty table with a pager that says "page 4 of 2".
- */
+* Client-side pagination for {@link DataTable} — pure, no React.
+*
+* The table sorts first and pages second, so page 1 always holds the first
+* rows of the CURRENT order. A page past the end (the rows shrank under it:
+* a filter narrowed, a revoke removed rows) clamps to the last page instead
+* of rendering an empty table with a pager that says "page 4 of 2".
+*/
 export interface DataTablePage<T> {
-    readonly pageRows: readonly T[];
-    /** 0-based page actually shown (after clamping). */
-    readonly page: number;
-    /** At least 1 — an empty table is one empty page. */
-    readonly pageCount: number;
-    /** 1-based index of the first row shown; 0 when there are none. */
-    readonly from: number;
-    /** 1-based index of the last row shown; 0 when there are none. */
-    readonly to: number;
-    readonly total: number;
+	readonly pageRows: readonly T[];
+	/** 0-based page actually shown (after clamping). */
+	readonly page: number;
+	/** At least 1 — an empty table is one empty page. */
+	readonly pageCount: number;
+	/** 1-based index of the first row shown; 0 when there are none. */
+	readonly from: number;
+	/** 1-based index of the last row shown; 0 when there are none. */
+	readonly to: number;
+	readonly total: number;
 }
 export declare function paginateRows<T>(rows: readonly T[], page: number, pageSize: number): DataTablePage<T>;
 /** Every visible string of the pager — this library carries no translations. */
 export interface DataTablePaginationLabels {
-    /** Accessible name of the pager's `<nav>` — say WHICH table. */
-    readonly navLabel: string;
-    readonly previous: string;
-    readonly next: string;
-    /** "1–25 of 167". Arguments are 1-based; `from`/`to` are 0 for no rows. */
-    readonly range: (from: number, to: number, total: number) => string;
+	/** Accessible name of the pager's `<nav>` — say WHICH table. */
+	readonly navLabel: string;
+	readonly previous: string;
+	readonly next: string;
+	/** "1–25 of 167". Arguments are 1-based; `from`/`to` are 0 for no rows. */
+	readonly range: (from: number, to: number, total: number) => string;
 }
 export declare const DEFAULT_PAGINATION_LABELS: DataTablePaginationLabels;

package/dist/composites/data-table-selection.d.ts

@@ -1,14 +1,14 @@
-import { DataColumn } from './data-table';
+import type { DataColumn } from "./data-table";
 export interface DataTableSelection<T> {
-    /** Selected row keys (`rowKey(row)`, stringified). Owned by the caller. */
-    readonly selected: ReadonlySet<string>;
-    readonly onChange: (next: ReadonlySet<string>) => void;
-    /** False = no checkbox for this row (e.g. the caller's own session). */
-    readonly isSelectable?: (row: T) => boolean;
-    /** Accessible name of a row's checkbox — name the row, not "select". */
-    readonly rowLabel: (row: T) => string;
-    /** Accessible name of the header checkbox. */
-    readonly pageLabel: string;
+	/** Selected row keys (`rowKey(row)`, stringified). Owned by the caller. */
+	readonly selected: ReadonlySet<string>;
+	readonly onChange: (next: ReadonlySet<string>) => void;
+	/** False = no checkbox for this row (e.g. the caller's own session). */
+	readonly isSelectable?: (row: T) => boolean;
+	/** Accessible name of a row's checkbox — name the row, not "select". */
+	readonly rowLabel: (row: T) => string;
+	/** Accessible name of the header checkbox. */
+	readonly pageLabel: string;
 }
 export declare const SELECTION_COLUMN_KEY = "__select";
 /** The selection column for the rows currently on screen. */

package/dist/composites/data-table.d.ts

@@ -1,124 +1,173 @@
-import { ReactNode } from 'react';
-import { TableMobileMode } from './data-table-layout';
-import { DataTablePaginationLabels } from './data-table-pagination';
-import { DataTableSelection } from './data-table-selection';
-import { TableSortState, TableSortValue } from './table-sort';
+/**
+* DataTable — shared responsive table for admin pages.
+*
+* Recipes baked in:
+*   - `overflow-x-auto` wrapper so narrow viewports don't clip the
+*     right edge (the rounded border survives the scroll).
+*   - `min-w-[Npx]` on the inner table so columns don't squash below
+*     readable width before the scroll kicks in.
+*   - `whitespace-nowrap` on headers — column titles never wrap to
+*     two lines (`AUTO-KILL` was the regression that triggered this).
+*   - Themed `bg-surface` + `border-border` so contrast works in both
+*     light and dark themes.
+*
+* Column model: caller supplies `columns: DataColumn<T>[]` and
+* `rows: T[]`. Each column declares `header`, optional `align`,
+* optional `nowrap`, and a `render(row) => ReactNode` that produces
+* the cell content.
+*
+*   <DataTable
+*     columns={[
+*       { key: 'username', header: 'Username', render: (u) => u.username },
+*       { key: 'role',     header: 'Role',     render: (u) => <RoleBadge .../> },
+*       { key: 'actions',  header: '',         align: 'right', render: (u) => <Actions .../> },
+*     ]}
+*     rows={users}
+*     minWidthPx={560}
+*   />
+*
+* If finer header markup is needed, pass `headerRender` instead of
+* `header` (e.g. for a sortable click affordance).
+*
+* ── Narrow viewports ──────────────────────────────────────────────────────
+* The table stays a table. The wrapper is `overflow-x-auto`, so a phone
+* scrolls the columns sideways INSIDE the table — the page body never moves
+* sideways, and the cells stay one line (`whitespace-nowrap`). That is the
+* default (`mobileMode="scroll"`). Cards are opt-in via `mobileMode="cards"`;
+* `auto` still applies the old column-count rule for a surface that wants it.
+* See `resolveTableLayout`.
+*
+* ── Scrolling the BODY, not the page ──────────────────────────────────────
+* `maxBodyHeight` caps the table and scrolls its rows INSIDE the container
+* with the column header pinned. It is ONE prop, not two, because "this list
+* scrolls internally" and "its header stays visible" are the same decision: a
+* capped table whose header scrolls away is a list of unlabelled cells.
+*
+* Use it wherever the row count is open-ended (rules, targets, delivery
+* history) so the page keeps its own header, filters and actions in view while
+* the operator moves through the rows.
+*/
+import { type ReactNode, type JSX } from "react";
+import { type TableMobileMode } from "./data-table-layout";
+import { type DataTablePaginationLabels } from "./data-table-pagination";
+import { type DataTableSelection } from "./data-table-selection";
+import { type TableSortState, type TableSortValue } from "./table-sort";
 export interface DataColumn<T> {
-    /** Stable key for React reconciliation + tests. */
-    readonly key: string;
-    /** Plain text header. Mutually exclusive with `headerRender`. */
-    readonly header?: string;
-    /** Custom header markup — overrides `header`. */
-    readonly headerRender?: () => ReactNode;
-    /** Cell horizontal alignment. Default: `left`. */
-    readonly align?: 'left' | 'right' | 'center';
-    /** Suppress text wrapping on header + cell. Default: `true` — a cell that
-     *  wraps is a row that has already lost its table. Pass `false` only for a
-     *  column whose value is meant to wrap (a description, a blob). */
-    readonly nowrap?: boolean;
-    /** Cell renderer. Receives the row value. */
-    readonly render: (row: T, rowIndex: number) => ReactNode;
-    /** Optional explicit Tailwind width class (e.g. `'w-24'`). */
-    readonly width?: string;
-    /**
-     * Opt this column into column sorting. Return the row's value for THIS
-     * column: a number for numeric columns (never a formatted string — "100"
-     * sorts before "9"), a string for text, and `null` when the row has no
-     * value, which always sorts last in both directions.
-     *
-     * Called once per row per comparison, so read a field; do not format.
-     *
-     * Omitting it is the correct answer for a composite cell (a list, an argv
-     * blob, an interactive control): see {@link DataColumn.notSortableReason}.
-     */
-    readonly sortValue?: (row: T) => TableSortValue;
-    /**
-     * Why this column has NO sort. Rendered as the header's `title` so the
-     * reason reaches the operator who wonders why one header clicks and the
-     * next does not.
-     *
-     * Only meaningful together with an absent `sortValue`. A column that cannot
-     * be ordered in a way that MEANS something must say so rather than offer an
-     * ordering that looks authoritative and is not.
-     */
-    readonly notSortableReason?: string;
+	/** Stable key for React reconciliation + tests. */
+	readonly key: string;
+	/** Plain text header. Mutually exclusive with `headerRender`. */
+	readonly header?: string;
+	/** Custom header markup — overrides `header`. */
+	readonly headerRender?: () => ReactNode;
+	/** Cell horizontal alignment. Default: `left`. */
+	readonly align?: "left" | "right" | "center";
+	/** Suppress text wrapping on header + cell. Default: `true` — a cell that
+	*  wraps is a row that has already lost its table. Pass `false` only for a
+	*  column whose value is meant to wrap (a description, a blob). */
+	readonly nowrap?: boolean;
+	/** Cell renderer. Receives the row value. */
+	readonly render: (row: T, rowIndex: number) => ReactNode;
+	/** Optional explicit Tailwind width class (e.g. `'w-24'`). */
+	readonly width?: string;
+	/**
+	* Opt this column into column sorting. Return the row's value for THIS
+	* column: a number for numeric columns (never a formatted string — "100"
+	* sorts before "9"), a string for text, and `null` when the row has no
+	* value, which always sorts last in both directions.
+	*
+	* Called once per row per comparison, so read a field; do not format.
+	*
+	* Omitting it is the correct answer for a composite cell (a list, an argv
+	* blob, an interactive control): see {@link DataColumn.notSortableReason}.
+	*/
+	readonly sortValue?: (row: T) => TableSortValue;
+	/**
+	* Why this column has NO sort. Rendered as the header's `title` so the
+	* reason reaches the operator who wonders why one header clicks and the
+	* next does not.
+	*
+	* Only meaningful together with an absent `sortValue`. A column that cannot
+	* be ordered in a way that MEANS something must say so rather than offer an
+	* ordering that looks authoritative and is not.
+	*/
+	readonly notSortableReason?: string;
 }
 export interface DataTableProps<T> {
-    readonly columns: readonly DataColumn<T>[];
-    readonly rows: readonly T[];
-    /** Stable key per row. Default: rowIndex (works for stable lists). */
-    readonly rowKey?: (row: T, rowIndex: number) => string | number;
-    /** Click handler attached to each row. Adds hover + cursor-pointer. */
-    readonly onRowClick?: (row: T, rowIndex: number) => void;
-    /** Min width in px for the inner table. Default: 480. */
-    readonly minWidthPx?: number;
-    /** Empty-state message. Default: hides the table when rows=[]. */
-    readonly emptyMessage?: string;
-    /** Additional className for the outer container. */
-    readonly className?: string;
-    /** Wrapper border style — set false to drop the rounded border (e.g. when the
-     *  table sits inside another bordered card). Default: `true`. */
-    readonly bordered?: boolean;
-    /** Per-row className resolver (e.g. status-coloured backgrounds). */
-    readonly rowClassName?: (row: T, rowIndex: number) => string | undefined;
-    /**
-     * Narrow-viewport rendering. Default `scroll` — the table stays a table and
-     * the wrapper scrolls sideways. Pass `cards` to force the card list,
-     * `auto` for the old column-count rule (`CARD_MODE_MIN_COLUMNS`).
-     */
-    readonly mobileMode?: TableMobileMode;
-    /**
-     * Tailwind `max-h-*` class capping the table. The rows then scroll INSIDE
-     * this container and the column header is pinned to its top; the page around
-     * it does not move. Absent (default) = the table is as tall as its rows and
-     * the page scrolls. Use {@link TABLE_SCROLL_MAX_H} unless a surface has a
-     * reason of its own.
-     */
-    readonly maxBodyHeight?: string;
-    /**
-     * Column sort the table opens with, e.g. `{ columnKey: 'cpu', dir: 'desc' }`.
-     * Must name a column that declares `sortValue`; a key that names no sortable
-     * column simply leaves the table in its incoming order.
-     *
-     * The state is owned INSIDE the table from here on — a header click moves it
-     * none → asc → desc → none. Pass this only to choose the opening order, not
-     * to drive the table from outside — that is {@link DataTableProps.sort}.
-     */
-    readonly defaultSort?: TableSortState;
-    /**
-     * CONTROLLED sort. Present (even `null`) = the owner holds the state: the
-     * table renders exactly this order and reports header clicks through
-     * `onSortChange` without moving on its own. Use it when the order must
-     * survive a remount or live in the URL. Absent = uncontrolled
-     * (`defaultSort`).
-     */
-    readonly sort?: TableSortState | null;
-    /** Every header click, with the next state (none → asc → desc → none). */
-    readonly onSortChange?: (next: TableSortState | null) => void;
-    /**
-     * Client-side pagination: show this many rows per page with a pager under
-     * the table. Sorting happens first, so page 1 holds the first rows of the
-     * current order. Absent = every row, no pager. The pager is drawn only when
-     * the rows do not fit on one page.
-     */
-    readonly pageSize?: number;
-    /** CONTROLLED 0-based page (with `onPageChange`). Absent = the table owns it. */
-    readonly page?: number;
-    readonly onPageChange?: (page: number) => void;
-    /** The pager's strings. Default: English. */
-    readonly paginationLabels?: DataTablePaginationLabels;
-    /**
-     * Row selection — a leading checkbox column (see `data-table-selection`).
-     * Needs `rowKey`: keys are what the caller's bulk action acts on.
-     */
-    readonly selection?: DataTableSelection<T>;
+	readonly columns: readonly DataColumn<T>[];
+	readonly rows: readonly T[];
+	/** Stable key per row. Default: rowIndex (works for stable lists). */
+	readonly rowKey?: (row: T, rowIndex: number) => string | number;
+	/** Click handler attached to each row. Adds hover + cursor-pointer. */
+	readonly onRowClick?: (row: T, rowIndex: number) => void;
+	/** Min width in px for the inner table. Default: 480. */
+	readonly minWidthPx?: number;
+	/** Empty-state message. Default: hides the table when rows=[]. */
+	readonly emptyMessage?: string;
+	/** Additional className for the outer container. */
+	readonly className?: string;
+	/** Wrapper border style — set false to drop the rounded border (e.g. when the
+	*  table sits inside another bordered card). Default: `true`. */
+	readonly bordered?: boolean;
+	/** Per-row className resolver (e.g. status-coloured backgrounds). */
+	readonly rowClassName?: (row: T, rowIndex: number) => string | undefined;
+	/**
+	* Narrow-viewport rendering. Default `scroll` — the table stays a table and
+	* the wrapper scrolls sideways. Pass `cards` to force the card list,
+	* `auto` for the old column-count rule (`CARD_MODE_MIN_COLUMNS`).
+	*/
+	readonly mobileMode?: TableMobileMode;
+	/**
+	* Tailwind `max-h-*` class capping the table. The rows then scroll INSIDE
+	* this container and the column header is pinned to its top; the page around
+	* it does not move. Absent (default) = the table is as tall as its rows and
+	* the page scrolls. Use {@link TABLE_SCROLL_MAX_H} unless a surface has a
+	* reason of its own.
+	*/
+	readonly maxBodyHeight?: string;
+	/**
+	* Column sort the table opens with, e.g. `{ columnKey: 'cpu', dir: 'desc' }`.
+	* Must name a column that declares `sortValue`; a key that names no sortable
+	* column simply leaves the table in its incoming order.
+	*
+	* The state is owned INSIDE the table from here on — a header click moves it
+	* none → asc → desc → none. Pass this only to choose the opening order, not
+	* to drive the table from outside — that is {@link DataTableProps.sort}.
+	*/
+	readonly defaultSort?: TableSortState;
+	/**
+	* CONTROLLED sort. Present (even `null`) = the owner holds the state: the
+	* table renders exactly this order and reports header clicks through
+	* `onSortChange` without moving on its own. Use it when the order must
+	* survive a remount or live in the URL. Absent = uncontrolled
+	* (`defaultSort`).
+	*/
+	readonly sort?: TableSortState | null;
+	/** Every header click, with the next state (none → asc → desc → none). */
+	readonly onSortChange?: (next: TableSortState | null) => void;
+	/**
+	* Client-side pagination: show this many rows per page with a pager under
+	* the table. Sorting happens first, so page 1 holds the first rows of the
+	* current order. Absent = every row, no pager. The pager is drawn only when
+	* the rows do not fit on one page.
+	*/
+	readonly pageSize?: number;
+	/** CONTROLLED 0-based page (with `onPageChange`). Absent = the table owns it. */
+	readonly page?: number;
+	readonly onPageChange?: (page: number) => void;
+	/** The pager's strings. Default: English. */
+	readonly paginationLabels?: DataTablePaginationLabels;
+	/**
+	* Row selection — a leading checkbox column (see `data-table-selection`).
+	* Needs `rowKey`: keys are what the caller's bulk action acts on.
+	*/
+	readonly selection?: DataTableSelection<T>;
 }
 /**
- * The default cap for an internally-scrolling table.
- *
- * `60vh` leaves the page header, its filters and its actions on screen at
- * every viewport while still showing ~10 rows — and it is a fraction, so it
- * does not need a breakpoint of its own.
- */
+* The default cap for an internally-scrolling table.
+*
+* `60vh` leaves the page header, its filters and its actions on screen at
+* every viewport while still showing ~10 rows — and it is a fraction, so it
+* does not need a breakpoint of its own.
+*/
 export declare const TABLE_SCROLL_MAX_H: "max-h-[60vh]";
-export declare function DataTable<T>({ columns, rows, rowKey, onRowClick, minWidthPx, emptyMessage, className, bordered, rowClassName, mobileMode, maxBodyHeight, defaultSort, sort: sortProp, onSortChange, pageSize, page: pageProp, onPageChange, paginationLabels, selection, }: DataTableProps<T>): import("react").JSX.Element | null;
+export declare function DataTable<T>({ columns, rows, rowKey, onRowClick, minWidthPx, emptyMessage, className, bordered, rowClassName, mobileMode, maxBodyHeight, defaultSort, sort: sortProp, onSortChange, pageSize, page: pageProp, onPageChange, paginationLabels, selection }: DataTableProps<T>): JSX.Element | null;

package/dist/composites/detection-canvas.d.ts

@@ -1,29 +1,38 @@
-import { ReactNode } from 'react';
-import { ObjectDetection } from '@camstack/types';
-export type { ObjectDetection, ScoredLabel, DetectionBoundingBox } from '@camstack/types';
+/**
+* DetectionCanvas — renders an image with overlaid bounding boxes.
+*
+* Adapted to the Phase 6 detection output rework: consumes the new
+* `ObjectDetection` shape (flat at root, `bbox: {x,y,width,height}`,
+* `labels: ScoredLabel[]`, `parentId` for details). Details (face,
+* plate) are drawn as inner boxes correlated with their parent via
+* `parentId`.
+*/
+import { type JSX, type ReactNode } from "react";
+export type { ObjectDetection, ScoredLabel, DetectionBoundingBox } from "@camstack/types";
+import type { ObjectDetection } from "@camstack/types";
 /** Legacy alias kept so pre-rework consumers don't need a coordinated rename. */
 export type Detection = ObjectDetection;
 export interface DetectionCanvasProps {
-    /** Image source (data URL or regular URL) */
-    readonly src: string | null;
-    /** Image dimensions (used for bbox coordinate mapping) */
-    readonly imageWidth: number;
-    readonly imageHeight: number;
-    /** Detections to overlay — flat list (first-level + details). */
-    readonly detections?: readonly ObjectDetection[];
-    /** Custom class → hex color mapping (merged with defaults) */
-    readonly classColors?: Readonly<Record<string, string>>;
-    /** Aspect ratio CSS value (default: auto based on image dimensions) */
-    readonly aspectRatio?: string;
-    /** Additional CSS classes on the container */
-    readonly className?: string;
-    /** Placeholder content when no image is loaded */
-    readonly placeholder?: ReactNode;
-    /** Show confidence percentage in bbox labels */
-    readonly showConfidence?: boolean;
-    /** Minimum confidence to display (0-1, default: 0) */
-    readonly minConfidence?: number;
-    /** Border width for bboxes in px (default: 2) */
-    readonly borderWidth?: number;
+	/** Image source (data URL or regular URL) */
+	readonly src: string | null;
+	/** Image dimensions (used for bbox coordinate mapping) */
+	readonly imageWidth: number;
+	readonly imageHeight: number;
+	/** Detections to overlay — flat list (first-level + details). */
+	readonly detections?: readonly ObjectDetection[];
+	/** Custom class → hex color mapping (merged with defaults) */
+	readonly classColors?: Readonly<Record<string, string>>;
+	/** Aspect ratio CSS value (default: auto based on image dimensions) */
+	readonly aspectRatio?: string;
+	/** Additional CSS classes on the container */
+	readonly className?: string;
+	/** Placeholder content when no image is loaded */
+	readonly placeholder?: ReactNode;
+	/** Show confidence percentage in bbox labels */
+	readonly showConfidence?: boolean;
+	/** Minimum confidence to display (0-1, default: 0) */
+	readonly minConfidence?: number;
+	/** Border width for bboxes in px (default: 2) */
+	readonly borderWidth?: number;
 }
-export declare function DetectionCanvas({ src, imageWidth, imageHeight, detections, classColors, aspectRatio, className, placeholder, showConfidence, minConfidence, borderWidth, }: DetectionCanvasProps): import("react").JSX.Element;
+export declare function DetectionCanvas({ src, imageWidth, imageHeight, detections, classColors, aspectRatio, className, placeholder, showConfidence, minConfidence, borderWidth }: DetectionCanvasProps): JSX.Element;

package/dist/composites/detection-colors.d.ts

@@ -1,14 +1,14 @@
 /**
- * Fixed colors for known detection classes — derived from the taxonomy
- * (every detection/motion kind) plus the UI-only face/plate classes. Kept as
- * a named export for back-compat with existing consumers.
- */
+* Fixed colors for known detection classes — derived from the taxonomy
+* (every detection/motion kind) plus the UI-only face/plate classes. Kept as
+* a named export for back-compat with existing consumers.
+*/
 export declare const CLASS_COLORS: Readonly<Record<string, string>>;
 /** Primary/default color when nothing else matches */
-export declare const DEFAULT_COLOR = "#22ff55";
+export declare const DEFAULT_COLOR: string;
 /**
- * Get the color for a detection class name.
- * Resolves: custom override → taxonomy/UI-only fixed color → deterministic
- * hash-based color for unknown classes.
- */
+* Get the color for a detection class name.
+* Resolves: custom override → taxonomy/UI-only fixed color → deterministic
+* hash-based color for unknown classes.
+*/
 export declare function getClassColor(className: string, customColors?: Readonly<Record<string, string>>): string;

package/dist/composites/detection-overlay.d.ts

@@ -1,34 +1,35 @@
-import { DeviceDetections } from '../hooks/use-device-detections';
-import { StationaryOverlayBox } from '@camstack/types';
+import type { DeviceDetections } from "../hooks/use-device-detections";
+import type { StationaryOverlayBox } from "@camstack/types";
+import { type JSX } from "react";
 export interface DetectionOverlayProps {
-    readonly detections: DeviceDetections;
-    readonly showMotionZones?: boolean;
-    readonly showMotionRaw?: boolean;
-    readonly showDetections?: boolean;
-    /**
-     * Draw subjects the tracker calls MOVING (and the ones it has not judged
-     * yet — an unclassified track is not a still one, and hiding it would make a
-     * new subject invisible for its first frames).
-     */
-    readonly showMoving?: boolean;
-    /**
-     * Draw the CENSUS — the parked objects the registry holds.
-     *
-     * This layer does not come from the detection stream, and cannot. When the
-     * evidence ledger promotes a parked object the tracker is told to forget it,
-     * so it stops being a detection at all; it lives on the occupancy snapshot.
-     * The switch therefore governs {@link stationaryObjects}, not a filter over
-     * `detections` — which is what it used to be, and why it appeared to do
-     * nothing.
-     */
-    readonly showStationary?: boolean;
-    /**
-     * The census, normalised, from the occupancy snapshot
-     * (`zoneAnalytics.getCurrentSnapshot().stationaryObjects`). Absent means the
-     * caller has not fetched it — which is NOT the same as "nothing is parked",
-     * so the layer simply draws nothing rather than claiming an empty lot.
-     */
-    readonly stationaryObjects?: readonly StationaryOverlayBox[];
-    readonly showPhaseIndicator?: boolean;
+	readonly detections: DeviceDetections;
+	readonly showMotionZones?: boolean;
+	readonly showMotionRaw?: boolean;
+	readonly showDetections?: boolean;
+	/**
+	* Draw subjects the tracker calls MOVING (and the ones it has not judged
+	* yet — an unclassified track is not a still one, and hiding it would make a
+	* new subject invisible for its first frames).
+	*/
+	readonly showMoving?: boolean;
+	/**
+	* Draw the CENSUS — the parked objects the registry holds.
+	*
+	* This layer does not come from the detection stream, and cannot. When the
+	* evidence ledger promotes a parked object the tracker is told to forget it,
+	* so it stops being a detection at all; it lives on the occupancy snapshot.
+	* The switch therefore governs {@link stationaryObjects}, not a filter over
+	* `detections` — which is what it used to be, and why it appeared to do
+	* nothing.
+	*/
+	readonly showStationary?: boolean;
+	/**
+	* The census, normalised, from the occupancy snapshot
+	* (`zoneAnalytics.getCurrentSnapshot().stationaryObjects`). Absent means the
+	* caller has not fetched it — which is NOT the same as "nothing is parked",
+	* so the layer simply draws nothing rather than claiming an empty lot.
+	*/
+	readonly stationaryObjects?: readonly StationaryOverlayBox[];
+	readonly showPhaseIndicator?: boolean;
 }
-export declare function DetectionOverlay({ detections: { motion, motionRaw, detection, phase }, showMotionZones, showMotionRaw, showDetections, showMoving, showStationary, stationaryObjects, showPhaseIndicator, }: DetectionOverlayProps): import("react").JSX.Element | null;
+export declare function DetectionOverlay({ detections: { motion, motionRaw, detection, phase }, showMotionZones, showMotionRaw, showDetections, showMoving, showStationary, stationaryObjects, showPhaseIndicator }: DetectionOverlayProps): JSX.Element | null;

package/dist/composites/detection-result-tree.d.ts

@@ -1,11 +1,24 @@
-import { ObjectDetection } from '@camstack/types';
+/**
+* DetectionResultTree — displays detection results as a hierarchical tree.
+*
+* Adapted to the Phase 6 output rework: the tree consumes flat
+* `ObjectDetection[]` and correlates details (face / plate) with
+* their parents via `parentId`. First-level entries are top-level
+* nodes; their details render as indented children. Each node shows:
+*   - bbox (rectangle)
+*   - macroClass + score badge
+*   - `labels[]` (ScoredLabel — own + inherited)
+*   - `debug.alternateLabels` (top-N per source) when present
+*/
+import { type JSX } from "react";
+import type { ObjectDetection } from "@camstack/types";
 export interface DetectionResultTreeProps {
-    readonly detections: readonly ObjectDetection[];
-    readonly classColors?: Readonly<Record<string, string>>;
-    readonly className?: string;
-    /** Set of detection ids that are hidden */
-    readonly hiddenKeys?: ReadonlySet<string>;
-    /** Callback when a detection's visibility is toggled */
-    readonly onToggleVisibility?: (key: string, visible: boolean) => void;
+	readonly detections: readonly ObjectDetection[];
+	readonly classColors?: Readonly<Record<string, string>>;
+	readonly className?: string;
+	/** Set of detection ids that are hidden */
+	readonly hiddenKeys?: ReadonlySet<string>;
+	/** Callback when a detection's visibility is toggled */
+	readonly onToggleVisibility?: (key: string, visible: boolean) => void;
 }
-export declare function DetectionResultTree({ detections, classColors, className, hiddenKeys, onToggleVisibility, }: DetectionResultTreeProps): import("react").JSX.Element;
+export declare function DetectionResultTree({ detections, classColors, className, hiddenKeys, onToggleVisibility }: DetectionResultTreeProps): JSX.Element | null;

package/dist/composites/dev-shell.d.ts

@@ -1,20 +1,21 @@
-import { ReactNode } from 'react';
-import { TRPCClient } from '@trpc/client';
-import { AppRouter } from '@camstack/types';
-import { UseThemeModeReturn } from '../theme/types';
+import { type JSX } from "react";
+import type { ReactNode } from "react";
+import { type TRPCClient } from "@trpc/client";
+import type { AppRouter } from "@camstack/types";
+import type { UseThemeModeReturn } from "../theme/types";
 export interface DevShellProps {
-    children: (props: {
-        trpc: TRPCClient<AppRouter>;
-        theme: UseThemeModeReturn;
-    }) => ReactNode;
-    serverUrl?: string;
-    title?: string;
+	children: (props: {
+		trpc: TRPCClient<AppRouter>;
+		theme: UseThemeModeReturn;
+	}) => ReactNode;
+	serverUrl?: string;
+	title?: string;
 }
 interface DevShellContextValue {
-    trpc: TRPCClient<AppRouter>;
-    token: string;
-    logout: () => void;
+	trpc: TRPCClient<AppRouter>;
+	token: string;
+	logout: () => void;
 }
 export declare function useDevShell(): DevShellContextValue;
-export declare function DevShell({ children, serverUrl, title }: DevShellProps): import("react").JSX.Element;
+export declare function DevShell({ children, serverUrl, title }: DevShellProps): JSX.Element | null;
 export {};