@camstack/ui-library 1.1.42 → 1.1.44

package/dist/composites/camera-stream-player.d.ts

@@ -168,7 +168,7 @@ export interface CameraStreamPlayerProps {
      * Main/High (incl. 4K) source pass through with NO transcode — the only
      * path that lets iOS decode High. The caller closes over the target.
      */
-    handleOffer?: (sdpOffer: string, sessionId?: string) => Promise<ClientOfferResult>;
+    handleOffer?: (sdpOffer: string, sessionId?: string, hints?: ClientStreamHints) => Promise<ClientOfferResult>;
     /**
      * Fetch the browser-side ICE servers (STUN + TURN) for client-offer mode.
      * Called BEFORE the offer is built so a remote/CGNAT viewer can gather a
@@ -205,7 +205,7 @@ export interface CameraStreamPlayerProps {
      * the server-chosen downgrade target instead. Required (alongside
      * `getSessionState`) for adaptive re-offer to run.
      */
-    reoffer?: (sessionId: string, sdpOffer: string, target: PlayerWebrtcTarget) => Promise<ClientOfferResult>;
+    reoffer?: (sessionId: string, sdpOffer: string, target: PlayerWebrtcTarget, hints?: ClientStreamHints) => Promise<ClientOfferResult>;
     /**
      * Optional poster image (snapshot data-URL) shown by the <video> before
      * the FIRST-EVER frame is decoded. Only a cold-start fallback — once a

package/dist/composites/device-controls/control-registry.d.ts

@@ -17,8 +17,16 @@ export interface DeviceTypeControl {
     readonly HeroCard: (p: DeviceControlProps) => ReactNode;
 }
 /**
- * Exhaustive record over DeviceType. Omitting a member causes a
- * TypeScript build error (same pattern as DEVICE_TYPE_ACTIONS).
+ * Exhaustive record over DeviceType, DERIVED from the shared decision
+ * (`DEVICE_TYPE_CONTROL_KIND`) composed with the web `CONTROL_KIND_COMPONENTS`
+ * binding — so the type→control mapping can never diverge from the single
+ * source in `@camstack/types`. Preserved as a public export for consumers/tests
+ * that index it by `DeviceType`.
+ *
+ * The `Object.fromEntries` result is a `{ [k: string]: DeviceTypeControl }`;
+ * `Object.values(DeviceType)` (a string enum) yields exactly the enum's members,
+ * so the record is fully populated — the assertion narrows that documented
+ * enum-record projection boundary.
  */
 export declare const DEVICE_TYPE_CONTROL: Record<DeviceType, DeviceTypeControl>;
 /**
@@ -53,9 +61,10 @@ export declare const CONTROL_FILLS: Record<DeviceType, boolean>;
  */
 export type ControlPlacement = 'right' | 'center' | 'table';
 /**
- * Runtime-string-safe lookup: a device row's `type` crosses the wire
- * as a plain string, so an unrecognised value resolves to null instead
- * of indexing the registry with an unverified key.
+ * Runtime-string-safe lookup: a device row's `type` crosses the wire as a plain
+ * string. The type→control-kind DECISION is single-sourced in `@camstack/types`
+ * (`resolveDeviceControlKind`, null for an unrecognised type); this maps the
+ * resolved kind onto the web components.
  */
 export declare function resolveDeviceControl(type: string): DeviceTypeControl | null;
 /**

package/dist/composites/device-step-matrix.d.ts

@@ -0,0 +1,33 @@
+import { StepTreeNode } from './step-tree-master';
+import { AgentColumn, CellState } from './pipeline-matrix-shared';
+export type { AgentColumn, CellState } from './pipeline-matrix-shared';
+/**
+ * Per-camera gate state for a step (node-independent). `zone-driven` steps
+ * (package-detection) sit OUTSIDE the gate — a badge, never a switch.
+ */
+export type StepGate = {
+    readonly kind: 'gate';
+    readonly effectiveOn: boolean;
+    readonly defaultOn: boolean;
+    readonly explicit: boolean;
+} | {
+    readonly kind: 'zone-driven';
+};
+export interface DeviceStepMatrixProps {
+    readonly tree: readonly StepTreeNode[];
+    readonly agents: readonly AgentColumn[];
+    readonly gateFor: (addonId: string) => StepGate;
+    readonly getCellState: (addonId: string, agentNodeId: string) => CellState;
+    readonly onCellClick: (addonId: string, agentNodeId: string) => void;
+    readonly selectedCell: {
+        readonly addonId: string;
+        readonly agentNodeId: string;
+    } | null;
+    /** `next: null` resets the gate to the catalog default (inherit). */
+    readonly onSetGate: (addonId: string, next: boolean | null) => void;
+    readonly gateBusy?: boolean;
+    /** Single-node fallback (B): which node the one column shows. */
+    readonly fallbackNodeId: string | null;
+    readonly onFallbackNodeChange: (nodeId: string) => void;
+}
+export declare function DeviceStepMatrix({ tree, agents, gateFor, getCellState, onCellClick, selectedCell, onSetGate, gateBusy, fallbackNodeId, onFallbackNodeChange, }: DeviceStepMatrixProps): import("react").JSX.Element;

package/dist/composites/index.d.ts

@@ -9,6 +9,9 @@ export { AgentStepEditor } from './agent-step-editor';
 export type { AgentStepEditorProps, EditorMode } from './agent-step-editor';
 export { PipelineTreeMatrix } from './pipeline-tree-matrix';
 export type { PipelineTreeMatrixProps, AgentColumn, CellState } from './pipeline-tree-matrix';
+export { DeviceStepMatrix } from './device-step-matrix';
+export type { DeviceStepMatrixProps, StepGate } from './device-step-matrix';
+export { shouldUseSingleNode } from './pipeline-matrix-shared';
 export { NodePicker } from './node-picker';
 export type { NodePickerProps } from './node-picker';
 export * from './status-badge';

package/dist/composites/pipeline-matrix-shared.d.ts

@@ -0,0 +1,69 @@
+import { ReactNode } from 'react';
+import { PipelineSlot } from '@camstack/types';
+import { StepTreeNode } from './step-tree-master';
+export interface AgentColumn {
+    readonly agentNodeId: string;
+    readonly engineLabel: string;
+}
+/**
+ * A single (step, node) cell's rendered state.
+ *   - `enabled`  — the node runs a model for this step (chip + optional `ovr`).
+ *   - `disabled` — cluster-default off (used by the per-node matrix only).
+ *   - `skip`     — #33: gated ON for the camera but this node has no compatible
+ *                  model — a visible amber status, never silent.
+ *   - `na`       — not applicable on this node.
+ */
+export type CellState = {
+    readonly kind: 'enabled';
+    readonly modelId: string;
+    readonly overridden?: boolean;
+} | {
+    readonly kind: 'disabled';
+    readonly overridden?: boolean;
+} | {
+    readonly kind: 'na';
+} | {
+    readonly kind: 'skip';
+};
+/**
+ * Fixed column geometry (rem). Both matrices use CSS-grid STATIC track widths
+ * so a cell's content (a status chip, a long model id) can never resize a
+ * column or shift its neighbours — content truncates WITHIN the fixed track.
+ * This kills the "table dances when the last column's status changes" jitter.
+ */
+export declare const AGENT_COL_REM = 13;
+export declare const REM_PX = 16;
+export declare const AGENT_COL_PX: number;
+export interface FlatRow {
+    readonly node: StepTreeNode;
+    readonly depth: number;
+}
+export declare function flattenTree(nodes: readonly StepTreeNode[]): readonly FlatRow[];
+/**
+ * Layout decision for the responsive A↔B switch. Pure so it can be unit-tested
+ * in isolation from the DOM.
+ *
+ * Returns `true` (single-node fallback) when there is MORE than one node but
+ * the container is too narrow to show the step column plus at least TWO node
+ * columns side by side. An unmeasured container (`width <= 0`) defaults to the
+ * wide matrix so there is no first-paint flash into the fallback.
+ */
+export declare function shouldUseSingleNode(width: number, nodeCount: number, stepColPx: number, agentColPx?: number): boolean;
+export declare function SlotHeading({ slot }: {
+    readonly slot: PipelineSlot;
+}): import("react").JSX.Element;
+export declare function ClassChips({ inputs, outputs, }: {
+    readonly inputs: readonly string[];
+    readonly outputs: readonly string[];
+}): import("react").JSX.Element | null;
+/** Step label (slot heading + addon name + class chips), shared by both views. */
+export declare function StepLabel({ node }: {
+    readonly node: StepTreeNode;
+}): import("react").JSX.Element;
+/**
+ * Cell content. Width-stable: the status dot is `shrink-0` (reserved space) and
+ * the model id truncates inside a `min-w-0` flex row, so a longer model id never
+ * widens the cell — it ellipsises instead.
+ */
+export declare function renderCellContent(state: CellState): ReactNode;
+export declare function cellButtonClass(state: CellState, isSelected: boolean, extra?: string): string;

package/dist/composites/pipeline-tree-matrix.d.ts

@@ -1,18 +1,6 @@
 import { StepTreeNode } from './step-tree-master';
-export interface AgentColumn {
-    readonly agentNodeId: string;
-    readonly engineLabel: string;
-}
-export type CellState = {
-    readonly kind: 'enabled';
-    readonly modelId: string;
-    readonly overridden?: boolean;
-} | {
-    readonly kind: 'disabled';
-    readonly overridden?: boolean;
-} | {
-    readonly kind: 'na';
-};
+import { AgentColumn, CellState } from './pipeline-matrix-shared';
+export type { AgentColumn, CellState } from './pipeline-matrix-shared';
 export interface PipelineTreeMatrixProps {
     readonly tree: readonly StepTreeNode[];
     readonly agents: readonly AgentColumn[];

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

@@ -43,8 +43,6 @@ export declare const useAddonsListFrameworkPackages: typeof trpc.addons.listFram
 export declare const useAddonsListCapabilityProviders: typeof trpc.addons.listCapabilityProviders.useQuery;
 /** Generated alias around `trpc.addons.setCapabilityProviderEnabled.useMutation`. */
 export declare const useAddonsSetCapabilityProviderEnabled: typeof trpc.addons.setCapabilityProviderEnabled.useMutation;
-/** Generated alias around `trpc.addons.updateFrameworkPackage.useMutation`. */
-export declare const useAddonsUpdateFrameworkPackage: typeof trpc.addons.updateFrameworkPackage.useMutation;
 /** Generated alias around `trpc.addons.getVersions.useQuery`. */
 export declare const useAddonsGetVersions: typeof trpc.addons.getVersions.useQuery;
 /** Generated alias around `trpc.addons.restartAddon.useMutation`. */

package/dist/hooks/use-device-webrtc.d.ts

@@ -65,6 +65,7 @@ export interface UseDeviceWebrtcTrpc {
             target: WebrtcTarget;
             sdpOffer: string;
             sessionId?: string;
+            hints?: ClientStreamHints;
         }, {
             sessionId: string;
             sdpAnswer: string;
@@ -160,7 +161,7 @@ export interface DeviceWebrtcResult {
      * H.264 decode caps in the offer, so a Main/High (incl. 4K) source passes
      * through with no transcode — the only path that lets iOS decode High.
      */
-    readonly handleOffer: (target: WebrtcTarget, sdpOffer: string, sessionId?: string) => Promise<ClientOfferResult>;
+    readonly handleOffer: (target: WebrtcTarget, sdpOffer: string, sessionId?: string, hints?: ClientStreamHints) => Promise<ClientOfferResult>;
     /**
      * Fetch the browser-side ICE servers (STUN + TURN from the `turn-provider`
      * cap). Needed for client-offer mode, where the PeerConnection must be