@camstack/ui-library 1.2.256 → 1.2.258

package/dist/composites/device-item/preview.d.ts

@@ -1,23 +1,43 @@
-import { ReactNode } from 'react';
-import { UseDeviceProxyTrpc } from '../../hooks/use-device-proxy';
-import { DeviceItemDevice } from './helpers';
+/**
+* <DeviceItemPreview> — type-dispatched preview slot.
+*
+* Renders, in order:
+*   1. Status pills — battery %, charging plug, sleeping moon (when
+*      the device exposes a battery slice). These were previously in
+*      the Features cell; they belong here because they describe the
+*      preview-relevant state (a sleeping cam can't snapshot, a low
+*      battery cam may drop frames).
+*   2. Snapshot thumbnail — a small camera snapshot that expands into a
+*      portal-positioned enlarged preview on hover/focus (shared
+*      `HoverZoomImage`). The portal + flip-on-collision keep the preview
+*      from being clipped by the device-grid's overflow ancestors. Gated
+*      on `enabled` (camera + showSnapshot flag) AND device.online for the
+*      live snapshot fetch; offline/unfetched shows a placeholder box so
+*      the cell stays compact.
+*
+* The status-pills section renders for ANY battery-operated device,
+* camera or otherwise; the snapshot thumbnail stays gated on cameras.
+*/
+import { type ReactNode } from "react";
+import type { UseDeviceProxyTrpc } from "../../hooks/use-device-proxy";
+import type { DeviceItemDevice } from "./helpers";
 export interface DeviceItemPreviewProps {
-    readonly trpc: UseDeviceProxyTrpc;
-    readonly device: DeviceItemDevice;
-    readonly status: 'online' | 'offline' | 'disabled';
-    /**
-     * Render gate for the snapshot thumbnail (typically
-     * `flags.showSnapshot && isCamera` from the orchestrator). Even when
-     * `false`, the component still renders the status-pills row when
-     * `showStatusPills` is on.
-     */
-    readonly enabled: boolean;
-    /**
-     * When true, render the battery / charging / sleeping pills next to
-     * the snapshot thumbnail. Driven by table view (where the Preview cell
-     * is the natural home for status indicators); off in card view to keep
-     * the row narrow.
-     */
-    readonly showStatusPills?: boolean;
+	readonly trpc: UseDeviceProxyTrpc;
+	readonly device: DeviceItemDevice;
+	readonly status: "online" | "offline" | "disabled";
+	/**
+	* Render gate for the snapshot thumbnail (typically
+	* `flags.showSnapshot && isCamera` from the orchestrator). Even when
+	* `false`, the component still renders the status-pills row when
+	* `showStatusPills` is on.
+	*/
+	readonly enabled: boolean;
+	/**
+	* When true, render the battery / charging / sleeping pills next to
+	* the snapshot thumbnail. Driven by table view (where the Preview cell
+	* is the natural home for status indicators); off in card view to keep
+	* the row narrow.
+	*/
+	readonly showStatusPills?: boolean;
 }
-export declare function DeviceItemPreview({ trpc, device, status, enabled, showStatusPills, }: DeviceItemPreviewProps): ReactNode;
+export declare function DeviceItemPreview({ trpc, device, status, enabled, showStatusPills }: DeviceItemPreviewProps): ReactNode;

package/dist/composites/device-item/quick-detail-action.d.ts

@@ -1,6 +1,6 @@
-import { ReactNode } from 'react';
+import type { ReactNode } from "react";
 export interface DeviceQuickDetailActionProps {
-    readonly deviceId: number;
-    readonly className?: string;
+	readonly deviceId: number;
+	readonly className?: string;
 }
-export declare function DeviceQuickDetailAction({ deviceId, className, }: DeviceQuickDetailActionProps): ReactNode;
+export declare function DeviceQuickDetailAction({ deviceId, className }: DeviceQuickDetailActionProps): ReactNode;

package/dist/composites/device-item/reboot-quick-action.d.ts

@@ -1,9 +1,30 @@
-import { ReactNode } from 'react';
-import { UseDeviceProxyTrpc } from '../../hooks/use-device-proxy';
+/**
+* <RebootQuickAction> — a dedicated row-level reboot affordance.
+*
+* Replaces the old kebab-nested "Reboot device" item: reboot now has its
+* own icon button in the row, alongside the PTZ quick-action. Because
+* reboot is destructive and low-frequency, the button is NOT a one-click
+* action — clicking it opens a confirm modal (the shared `Dialog`
+* primitive, same surface `ConfirmActionButton` uses). The cap is only
+* invoked once the operator confirms.
+*
+* Cap-gating mirrors the former MoreActionsMenu exactly: render only when
+* the device proxy has resolved AND the `reboot` cap is bound. The caller
+* pre-gates on the `rebootable` feature; this atom self-gates on the live
+* cap binding, so a device that claims the feature without a bound
+* provider still renders nothing.
+*
+* The reboot call shows a busy/disabled state while in flight, closes the
+* modal on success, and surfaces errors inline at the dialog's bottom.
+* `stopPropagation` on the trigger keeps the row's navigate-to-detail
+* handler from firing.
+*/
+import { type ReactNode } from "react";
+import type { UseDeviceProxyTrpc } from "../../hooks/use-device-proxy";
 export interface RebootQuickActionProps {
-    readonly trpc: UseDeviceProxyTrpc;
-    readonly deviceId: number;
-    /** Device display name — woven into the confirm-modal body. */
-    readonly deviceName: string;
+	readonly trpc: UseDeviceProxyTrpc;
+	readonly deviceId: number;
+	/** Device display name — woven into the confirm-modal body. */
+	readonly deviceName: string;
 }
-export declare function RebootQuickAction({ trpc, deviceId, deviceName, }: RebootQuickActionProps): ReactNode;
+export declare function RebootQuickAction({ trpc, deviceId, deviceName }: RebootQuickActionProps): ReactNode;

package/dist/composites/device-item/role-display-defaults-context.d.ts

@@ -1,21 +1,37 @@
-import { RoleDisplayDefault } from '@camstack/types';
-import { ReactNode } from 'react';
+/**
+* Role display defaults — the operator's per-ROLE icon/unit/precision
+* (`deviceManager.getRoleDisplayDefaults`), published once at the top of a
+* surface and read by every row that draws a device.
+*
+* Why a context and not a hook per row: `deviceLeadIcon` is called in the row
+* header and in the accessory accordion, both of which render in tests and
+* in surfaces with no tRPC provider (a standalone `<DeviceItem>`). A generated
+* query hook throws outside its provider; a context degrades to "no defaults"
+* and the icon falls through to the built-in role glyph — which is exactly
+* what the resolution order says happens when there is no default.
+*
+* `RoleDisplayDefaultsFromServer` is the one component that calls the query
+* hook; mount it once inside `<trpc.Provider>` (the admin app does, in
+* `App.tsx`) and every list below it resolves the operator's role icon.
+*/
+import type { RoleDisplayDefault } from "@camstack/types";
+import { type ReactNode } from "react";
 /** `role string → default`. Absent role = no default. */
 export type RoleDisplayDefaults = Readonly<Record<string, RoleDisplayDefault>>;
 export interface RoleDisplayDefaultsProviderProps {
-    readonly value: RoleDisplayDefaults;
-    readonly children: ReactNode;
+	readonly value: RoleDisplayDefaults;
+	readonly children: ReactNode;
 }
-export declare function RoleDisplayDefaultsProvider({ value, children, }: RoleDisplayDefaultsProviderProps): ReactNode;
+export declare function RoleDisplayDefaultsProvider({ value, children }: RoleDisplayDefaultsProviderProps): ReactNode;
 /** The defaults published by the nearest provider — an empty record outside
- *  one, never `undefined`, so a caller can index it without a guard. */
+*  one, never `undefined`, so a caller can index it without a guard. */
 export declare function useRoleDisplayDefaults(): RoleDisplayDefaults;
 export interface RoleDisplayDefaultsFromServerProps {
-    readonly children: ReactNode;
+	readonly children: ReactNode;
 }
 /**
- * Reads the defaults from the hub and publishes them. Until the query lands
- * the children see no defaults — the built-in role glyph, which is what they
- * would see with no operator default at all, so nothing flashes wrong.
- */
-export declare function RoleDisplayDefaultsFromServer({ children, }: RoleDisplayDefaultsFromServerProps): ReactNode;
+* Reads the defaults from the hub and publishes them. Until the query lands
+* the children see no defaults — the built-in role glyph, which is what they
+* would see with no operator default at all, so nothing flashes wrong.
+*/
+export declare function RoleDisplayDefaultsFromServer({ children }: RoleDisplayDefaultsFromServerProps): ReactNode;

package/dist/composites/device-item/status-dot.d.ts

@@ -1,9 +1,27 @@
-import { ReactNode } from 'react';
-export type StatusDotStatus = 'online' | 'offline' | 'disabled' | 'recording-continuous' | 'recording-events';
+/**
+* Status indicator dot — parity with the viewer's camera status dot.
+* Pure-render atom; no fetches, no internal state (the row resolves the
+* recording-aware status and passes it in).
+*
+* Colour by fixed priority (the row resolves which one applies):
+*   • disabled              → black (+ ring so it stays visible) — soft-disabled.
+*   • offline               → grey — not disabled, not reachable.
+*   • recording-continuous  → red  — online + always-on recording.
+*   • recording-events      → blue — online + on-motion recording.
+*   • online                → green — online, recording off.
+*
+* The "alive" states (online + recording) pulse; offline + disabled are static.
+*
+* When `status === 'offline'` and a `lastChangedAt` (ms epoch of the last
+* online→offline transition) is supplied, the hover tooltip is enriched to
+* "Offline · last seen Xm ago".
+*/
+import type { ReactNode } from "react";
+export type StatusDotStatus = "online" | "offline" | "disabled" | "recording-continuous" | "recording-events";
 export interface StatusDotProps {
-    readonly status: StatusDotStatus;
-    /** Ms epoch of the last online→offline transition. Only used to enrich
-     *  the tooltip when `status === 'offline'`. */
-    readonly lastChangedAt?: number | null;
+	readonly status: StatusDotStatus;
+	/** Ms epoch of the last online→offline transition. Only used to enrich
+	*  the tooltip when `status === 'offline'`. */
+	readonly lastChangedAt?: number | null;
 }
 export declare function StatusDot({ status, lastChangedAt }: StatusDotProps): ReactNode;

package/dist/composites/device-list/batch-actions-bar.d.ts

@@ -1,15 +1,26 @@
-import { ReactNode } from 'react';
+/**
+* <DeviceBatchActionsBar> — responsive wrapper around <DeviceBatchToolbar>.
+*
+* Surfaces the available bulk actions once devices are selected:
+*   - L2+ (`sm` and up): the toolbar renders inline as a row of buttons.
+*   - L1 (`< sm`): a compact "Actions · N" trigger opens a popover that
+*     hosts the SAME <DeviceBatchToolbar>, so the action logic (inline
+*     delete-confirm, clear) is reused verbatim — never forked.
+*
+* Renders nothing while the selection is empty (delegated to the toolbar).
+*/
+import { type ReactNode } from "react";
 export interface DeviceBatchActionsBarProps {
-    readonly selectedIds: ReadonlySet<number>;
-    readonly onClear: () => void;
-    readonly remove: (input: {
-        deviceId: number;
-    }) => void;
-    readonly disable: (input: {
-        deviceId: number;
-    }) => void;
-    readonly enable: (input: {
-        deviceId: number;
-    }) => void;
+	readonly selectedIds: ReadonlySet<number>;
+	readonly onClear: () => void;
+	readonly remove: (input: {
+		deviceId: number;
+	}) => void;
+	readonly disable: (input: {
+		deviceId: number;
+	}) => void;
+	readonly enable: (input: {
+		deviceId: number;
+	}) => void;
 }
 export declare function DeviceBatchActionsBar(props: DeviceBatchActionsBarProps): ReactNode;

package/dist/composites/device-list/batch-toolbar.d.ts

@@ -1,15 +1,15 @@
-import { ReactNode } from 'react';
+import { type ReactNode } from "react";
 export interface DeviceBatchToolbarProps {
-    readonly selectedIds: ReadonlySet<number>;
-    readonly onClear: () => void;
-    readonly remove: (input: {
-        deviceId: number;
-    }) => void;
-    readonly disable: (input: {
-        deviceId: number;
-    }) => void;
-    readonly enable: (input: {
-        deviceId: number;
-    }) => void;
+	readonly selectedIds: ReadonlySet<number>;
+	readonly onClear: () => void;
+	readonly remove: (input: {
+		deviceId: number;
+	}) => void;
+	readonly disable: (input: {
+		deviceId: number;
+	}) => void;
+	readonly enable: (input: {
+		deviceId: number;
+	}) => void;
 }
-export declare function DeviceBatchToolbar({ selectedIds, onClear, remove, disable, enable, }: DeviceBatchToolbarProps): ReactNode;
+export declare function DeviceBatchToolbar({ selectedIds, onClear, remove, disable, enable }: DeviceBatchToolbarProps): ReactNode;

package/dist/composites/device-list/columns.d.ts

@@ -1,128 +1,128 @@
 /**
- * Device-mode column model: a fixed catalog, a per-context subset matrix,
- * a responsive priority, and a priority-derived breakpoint mapping. Each
- * consumer declares its `TableContext`; the table renders only the columns
- * that context enables, in catalog order, hiding the optional ones as the
- * viewport narrows.
- *
- * The catalog is intentionally device-mode only. Generic-mode (integration
- * rows) keeps its own `DeviceListColumn[]` defs — reconciled in a later phase.
- *
- * ── Responsive convention (single source of truth) ────────────────────────
- *   LOWER priority number = MORE important = hidden at a NARROWER width (kept
- *   longest). So as the viewport shrinks the HIGHEST-priority-number column
- *   drops first.
- *
- *     name           (0) — never hidden; pinned left from `md` up (see
- *                          `NAME_COLUMN_PIN_CLASS`), scrolls below it
- *     previewActions (1) — never hidden; carries the live control + status dot
- *     icon           (2) — integration badge; rendered INSIDE the name cell,
- *                          not a standalone column, so it has no breakpoint
- *     features       (3) — optional; hidden below `md` (kept longer)
- *     type           (4) — optional; hidden below `lg`
- *     manufacturer   (5) — optional; hidden below `xl` (drops FIRST,
- *                          wide-screen-only hardware/identity column)
- *
- *   `COLUMN_BREAKPOINT_CLASS` derives ONE Tailwind visibility class per id and
- *   is the single source used by BOTH the `<th>` and the `<td>`, so a hidden
- *   column folds header + cell in lock-step. The drop order is therefore:
- *   `manufacturer` first (below `xl`), then `type` (below `lg`), then
- *   `features` (below `md`) — matching the priority numbers above.
- */
+* Device-mode column model: a fixed catalog, a per-context subset matrix,
+* a responsive priority, and a priority-derived breakpoint mapping. Each
+* consumer declares its `TableContext`; the table renders only the columns
+* that context enables, in catalog order, hiding the optional ones as the
+* viewport narrows.
+*
+* The catalog is intentionally device-mode only. Generic-mode (integration
+* rows) keeps its own `DeviceListColumn[]` defs — reconciled in a later phase.
+*
+* ── Responsive convention (single source of truth) ────────────────────────
+*   LOWER priority number = MORE important = hidden at a NARROWER width (kept
+*   longest). So as the viewport shrinks the HIGHEST-priority-number column
+*   drops first.
+*
+*     name           (0) — never hidden; pinned left from `md` up (see
+*                          `NAME_COLUMN_PIN_CLASS`), scrolls below it
+*     previewActions (1) — never hidden; carries the live control + status dot
+*     icon           (2) — integration badge; rendered INSIDE the name cell,
+*                          not a standalone column, so it has no breakpoint
+*     features       (3) — optional; hidden below `md` (kept longer)
+*     type           (4) — optional; hidden below `lg`
+*     manufacturer   (5) — optional; hidden below `xl` (drops FIRST,
+*                          wide-screen-only hardware/identity column)
+*
+*   `COLUMN_BREAKPOINT_CLASS` derives ONE Tailwind visibility class per id and
+*   is the single source used by BOTH the `<th>` and the `<td>`, so a hidden
+*   column folds header + cell in lock-step. The drop order is therefore:
+*   `manufacturer` first (below `xl`), then `type` (below `lg`), then
+*   `features` (below `md`) — matching the priority numbers above.
+*/
 /** Fixed device-mode column catalog, in render order. `name` is always first.
- *  `manufacturer` sits after `type` — a wide-screen-only hardware/identity
- *  column (manufacturer · model, full metadata in a tooltip). */
+*  `manufacturer` sits after `type` — a wide-screen-only hardware/identity
+*  column (manufacturer · model, full metadata in a tooltip). */
 export declare const DEVICE_COLUMNS: readonly ["name", "icon", "type", "manufacturer", "features", "previewActions"];
 export type DeviceColumnId = (typeof DEVICE_COLUMNS)[number];
 /**
- * The places a device table is rendered; each declares its column subset.
- *
- * Device-detail CHILDREN are deliberately NOT a table context: they render as
- * a stack of `<DeviceItem variant="minimal">` cards (see `ChildrenList`), not
- * through this table, so no `device-children` context exists.
- */
-export type TableContext = 'devices' | 'integration-detail';
+* The places a device table is rendered; each declares its column subset.
+*
+* Device-detail CHILDREN are deliberately NOT a table context: they render as
+* a stack of `<DeviceItem variant="minimal">` cards (see `ChildrenList`), not
+* through this table, so no `device-children` context exists.
+*/
+export type TableContext = "devices" | "integration-detail";
 export declare function columnsForContext(ctx: TableContext): readonly DeviceColumnId[];
 /**
- * Lower number = higher priority (kept longest as width shrinks). `name` = 0
- * (never dropped); `previewActions` = 1 (always visible). The optional
- * columns drop in REVERSE priority order as width shrinks — highest number
- * (`type`) hides first, then `features`. `icon` is a name-cell badge, not a
- * standalone column. See `COLUMN_BREAKPOINT_CLASS` for the derived classes.
- */
+* Lower number = higher priority (kept longest as width shrinks). `name` = 0
+* (never dropped); `previewActions` = 1 (always visible). The optional
+* columns drop in REVERSE priority order as width shrinks — highest number
+* (`type`) hides first, then `features`. `icon` is a name-cell badge, not a
+* standalone column. See `COLUMN_BREAKPOINT_CLASS` for the derived classes.
+*/
 export declare const COLUMN_PRIORITY: Record<DeviceColumnId, number>;
 /**
- * Priority-derived Tailwind visibility class per column. Used by BOTH the
- * `<th>` and the `<td>` (single source → header + cell stay in lock-step).
- *
- *   - `name` / `previewActions`: empty string — never hidden (always visible).
- *   - `icon`: empty string — rendered inside the name cell, no standalone cell.
- *   - `features`: `hidden md:table-cell` — visible from `md` up (kept longer).
- *   - `type`: `hidden lg:table-cell` — visible only from `lg` up.
- *   - `manufacturer`: `hidden xl:table-cell` — visible only from `xl` up (drops
- *     first).
- *
- * Drop order as the viewport narrows therefore follows the priority numbers:
- * `manufacturer` (5) disappears below `xl`, then `type` (4) below `lg`, then
- * `features` (3) below `md`.
- */
+* Priority-derived Tailwind visibility class per column. Used by BOTH the
+* `<th>` and the `<td>` (single source → header + cell stay in lock-step).
+*
+*   - `name` / `previewActions`: empty string — never hidden (always visible).
+*   - `icon`: empty string — rendered inside the name cell, no standalone cell.
+*   - `features`: `hidden md:table-cell` — visible from `md` up (kept longer).
+*   - `type`: `hidden lg:table-cell` — visible only from `lg` up.
+*   - `manufacturer`: `hidden xl:table-cell` — visible only from `xl` up (drops
+*     first).
+*
+* Drop order as the viewport narrows therefore follows the priority numbers:
+* `manufacturer` (5) disappears below `xl`, then `type` (4) below `lg`, then
+* `features` (3) below `md`.
+*/
 export declare const COLUMN_BREAKPOINT_CLASS: Record<DeviceColumnId, string>;
 /**
- * ── The NAME column pin ───────────────────────────────────────────────────
- *
- * A sticky first column earns its keep only where the remaining columns still
- * fit BESIDE it. Read the drop order above: below `md` every optional column
- * is already folded away, so the table is NAME + Preview and there is nothing
- * left to scroll under the pin — the pinned column simply holds its width
- * permanently and pushes Preview off the right edge. On a phone the viewport
- * is narrower than the pinned column alone, which is the reported defect:
- * "il nome alla sinistra è fixed, dovrebbe scorrere naturalmente." [the name on the left is fixed, it should scroll naturally.]
- *
- * So the pin starts at `md`, the same width at which `features` returns and a
- * column exists to scroll under it. Below `md` the name column scrolls with
- * everything else.
- */
+* ── The NAME column pin ───────────────────────────────────────────────────
+*
+* A sticky first column earns its keep only where the remaining columns still
+* fit BESIDE it. Read the drop order above: below `md` every optional column
+* is already folded away, so the table is NAME + Preview and there is nothing
+* left to scroll under the pin — the pinned column simply holds its width
+* permanently and pushes Preview off the right edge. On a phone the viewport
+* is narrower than the pinned column alone, which is the reported defect:
+* "il nome alla sinistra è fixed, dovrebbe scorrere naturalmente." [the name on the left is fixed, it should scroll naturally.]
+*
+* So the pin starts at `md`, the same width at which `features` returns and a
+* column exists to scroll under it. Below `md` the name column scrolls with
+* everything else.
+*/
 export declare const NAME_COLUMN_PIN_BREAKPOINT: "md";
 /** Pin classes for the NAME `<th>`/`<td>` — never unconditional. */
 export declare const NAME_COLUMN_PIN_CLASS: "md:sticky md:left-0 md:z-[1]";
 /**
- * ── The NAME never truncates below the pin breakpoint ─────────────────────
- *
- * Fitting NAME + Preview inside a phone viewport was the wrong trade: every
- * camera collapsed to "Videocamera ve…" / "Videocamera co…", which is not a
- * shortened name, it is NO name — the rows became indistinguishable and the
- * one thing the operator opened the page to read was the part that got cut.
- *
- * So below `md` the name is rendered in FULL on one line and the table is
- * allowed to grow past the viewport; the wrapper's existing `overflow-x-auto`
- * (ONE scroll context for the whole body, so every column stays aligned with
- * its header) carries the overflow. From `md` up nothing changes: the width
- * cap, the ellipsis and the pin all return, because names already fit there.
- *
- * Same breakpoint as the pin, deliberately — the pin exists only where other
- * columns still fit beside NAME, which is exactly the width at which NAME no
- * longer needs the whole viewport.
- */
+* ── The NAME never truncates below the pin breakpoint ─────────────────────
+*
+* Fitting NAME + Preview inside a phone viewport was the wrong trade: every
+* camera collapsed to "Videocamera ve…" / "Videocamera co…", which is not a
+* shortened name, it is NO name — the rows became indistinguishable and the
+* one thing the operator opened the page to read was the part that got cut.
+*
+* So below `md` the name is rendered in FULL on one line and the table is
+* allowed to grow past the viewport; the wrapper's existing `overflow-x-auto`
+* (ONE scroll context for the whole body, so every column stays aligned with
+* its header) carries the overflow. From `md` up nothing changes: the width
+* cap, the ellipsis and the pin all return, because names already fit there.
+*
+* Same breakpoint as the pin, deliberately — the pin exists only where other
+* columns still fit beside NAME, which is exactly the width at which NAME no
+* longer needs the whole viewport.
+*/
 export declare const NAME_COLUMN_TRUNCATE_BREAKPOINT: "md";
 /**
- * NAME column width — a desktop concession, never unconditional ([D43]).
- * Below `md` the column carries no width at all, so it sizes to the name and
- * widens the table; the roomier capped desktop width returns with the pin.
- */
+* NAME column width — a desktop concession, never unconditional ([D43]).
+* Below `md` the column carries no width at all, so it sizes to the name and
+* widens the table; the roomier capped desktop width returns with the pin.
+*/
 export declare const NAME_COLUMN_WIDTH_CLASS: "md:w-64 md:max-w-[16rem]";
 /**
- * The name TEXT inside a table row. `whitespace-nowrap` keeps it on one line
- * at every width; `md:truncate` adds the overflow-hidden + ellipsis pair from
- * `md` up. Below `md` there is no ellipsis and no clip — the full string is
- * laid out, and it is the name that sizes the column.
- *
- * Measured (Chromium, 390px viewport, a 288px name in a 388px table): the two
- * things that were cutting it are exactly this `truncate` and the width cap
- * above. The `min-w-0` / `overflow-hidden` on the cell and on the header's
- * flex chain are INERT below `md` — an uncapped table cell sizes to its
- * content's min-content width regardless — so they are deliberately left
- * unconditional: they cost nothing here and they keep clipping (rather than
- * overlapping the Preview column) as the failure mode if anything ever does
- * force this column narrow.
- */
+* The name TEXT inside a table row. `whitespace-nowrap` keeps it on one line
+* at every width; `md:truncate` adds the overflow-hidden + ellipsis pair from
+* `md` up. Below `md` there is no ellipsis and no clip — the full string is
+* laid out, and it is the name that sizes the column.
+*
+* Measured (Chromium, 390px viewport, a 288px name in a 388px table): the two
+* things that were cutting it are exactly this `truncate` and the width cap
+* above. The `min-w-0` / `overflow-hidden` on the cell and on the header's
+* flex chain are INERT below `md` — an uncapped table cell sizes to its
+* content's min-content width regardless — so they are deliberately left
+* unconditional: they cost nothing here and they keep clipping (rather than
+* overlapping the Preview column) as the failure mode if anything ever does
+* force this column narrow.
+*/
 export declare const NAME_TEXT_CLASS: "whitespace-nowrap md:truncate";

package/dist/composites/device-list/device-integration.d.ts

@@ -1,69 +1,59 @@
 /**
- * resolveDeviceIntegration — the ONE answer to "which integration does this
- * device belong to".
- *
- * A device row carries two different ids:
- *  - `integrationId` — the integration that CREATED it (`IntegrationWithState.id`).
- *  - `addonId` — the addon that owns and SERVES it.
- *
- * They can differ. A composed device (D659) is created under the "Blocks"
- * integration (`int_0024`, whose own `addonId` is `core-blocks`) but is
- * served by the `composer` addon, so its row reads `addonId: 'composer'`.
- * Resolving by `addonId` put it under no integration at all: the Devices
- * filter, the Integration page's list, the device header and the orphan box
- * each asked the question their own way, and every one of them got it wrong.
- *
- * The rule:
- *  1. `integrationId` present ⇒ it is authoritative. The device belongs to
- *     the integration with that `id`, or — when no registered integration has
- *     it — to none (orphan), WHATEVER its `addonId` says.
- *  2. No `integrationId` (legacy rows) ⇒ the `addonId` IS the integration
- *     link: the device belongs to the first integration whose `addonId`
- *     matches, or is orphan when none does.
- *  3. A row that names neither is `unlinked` — it points at nothing, so it
- *     cannot be orphaned by a missing integration.
- *
- * And the load-bearing case: `integrations === null | undefined` means the
- * integrations query has NOT ANSWERED. That is `unknown`, never `orphan` —
- * an unanswered list is not an empty one (D315), and classifying against it
- * branded every device orphan for seconds on a slow server (2026-08-18).
- */
+* resolveDeviceIntegration — the ONE answer to "which integration does this
+* device belong to".
+*
+* A device row carries two different ids:
+*  - `integrationId` — the integration that CREATED it (`IntegrationWithState.id`).
+*  - `addonId` — the addon that owns and SERVES it.
+*
+* They can differ. A composed device (D659) is created under the "Blocks"
+* integration (`int_0024`, whose own `addonId` is `core-blocks`) but is
+* served by the `composer` addon, so its row reads `addonId: 'composer'`.
+* Resolving by `addonId` put it under no integration at all: the Devices
+* filter, the Integration page's list, the device header and the orphan box
+* each asked the question their own way, and every one of them got it wrong.
+*
+* The rule:
+*  1. `integrationId` present ⇒ it is authoritative. The device belongs to
+*     the integration with that `id`, or — when no registered integration has
+*     it — to none (orphan), WHATEVER its `addonId` says.
+*  2. No `integrationId` (legacy rows) ⇒ the `addonId` IS the integration
+*     link: the device belongs to the first integration whose `addonId`
+*     matches, or is orphan when none does.
+*  3. A row that names neither is `unlinked` — it points at nothing, so it
+*     cannot be orphaned by a missing integration.
+*
+* And the load-bearing case: `integrations === null | undefined` means the
+* integrations query has NOT ANSWERED. That is `unknown`, never `orphan` —
+* an unanswered list is not an empty one (D315), and classifying against it
+* branded every device orphan for seconds on a slow server (2026-08-18).
+*/
 /** The two fields of a device row the rule reads. */
 export interface DeviceIntegrationLink {
-    readonly addonId?: string | null;
-    readonly integrationId?: string | null;
+	readonly addonId?: string | null;
+	readonly integrationId?: string | null;
 }
 /** The two fields of an `integrations.list` row the rule reads. */
 export interface DeviceIntegrationRef {
-    readonly id: string;
-    readonly addonId: string;
+	readonly id: string;
+	readonly addonId: string;
 }
-export type DeviceIntegrationResolution<I extends DeviceIntegrationRef = DeviceIntegrationRef> = 
-/** The device belongs to this registered integration. */
-{
-    readonly kind: 'resolved';
-    readonly integration: I;
-}
-/** The device names an integration link that no registered integration answers. */
- | {
-    readonly kind: 'orphan';
-}
-/** The device names no link at all (no `integrationId`, empty `addonId`). */
- | {
-    readonly kind: 'unlinked';
-}
-/** The integrations query has not answered yet — nothing can be said. */
- | {
-    readonly kind: 'unknown';
+export type DeviceIntegrationResolution<I extends DeviceIntegrationRef = DeviceIntegrationRef> = {
+	readonly kind: "resolved";
+	readonly integration: I;
+} | {
+	readonly kind: "orphan";
+} | {
+	readonly kind: "unlinked";
+} | {
+	readonly kind: "unknown";
 };
 export type DeviceIntegrationResolver<I extends DeviceIntegrationRef = DeviceIntegrationRef> = (device: DeviceIntegrationLink) => DeviceIntegrationResolution<I>;
-export declare function resolveDeviceIntegration<I extends DeviceIntegrationRef>(device: DeviceIntegrationLink, 
-/** The `integrations.list` answer, or `null`/`undefined` while unanswered. */
-integrations: readonly I[] | null | undefined): DeviceIntegrationResolution<I>;
+export declare function resolveDeviceIntegration<I extends DeviceIntegrationRef>(device: DeviceIntegrationLink, integrations: readonly I[] | null | undefined): DeviceIntegrationResolution<I>;
 /**
- * The rule itself, prepared once over a list for per-row use on a large
- * fleet (two map lookups per row, not two scans). `resolveDeviceIntegration`
- * is this, applied to one device; `<DeviceList integrationOf>` takes the
- * returned resolver.
- */
+* The rule itself, prepared once over a list for per-row use on a large
+* fleet (two map lookups per row, not two scans). `resolveDeviceIntegration`
+* is this, applied to one device; `<DeviceList integrationOf>` takes the
+* returned resolver.
+*/
 export declare function deviceIntegrationResolver<I extends DeviceIntegrationRef>(integrations: readonly I[] | null | undefined): DeviceIntegrationResolver<I>;