@camstack/types 1.1.20 → 1.1.21

package/dist/expression/evaluator.d.ts

@@ -0,0 +1,14 @@
+import { type ExpressionEvalHooks } from './builtins.js';
+import type { ExpressionNode, ExpressionValue } from './ast.js';
+export interface ExpressionEvalOptions {
+    readonly hooks?: ExpressionEvalHooks;
+    readonly maxSteps?: number;
+}
+/** Build a null-prototype scope from own-enumerable binding entries. Inherited
+ *  keys of the input (e.g. from a `{__proto__: {...}}` payload) are NOT copied,
+ *  so nothing smuggles in via the prototype chain. */
+export declare function createExpressionScope(bindings: Readonly<Record<string, ExpressionValue>>): Record<string, ExpressionValue>;
+/** Evaluate an AST node against a scope. Throws `ExpressionEvalError` on any
+ *  runtime failure (unknown identifier, type mismatch, non-finite result,
+ *  step-budget exhaustion). */
+export declare function evaluateAst(node: ExpressionNode, scope: Record<string, ExpressionValue>, opts?: ExpressionEvalOptions): ExpressionValue;

package/dist/expression/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Safe expression engine — public surface. A non-Turing-complete infix
+ * mini-language (tokenizer → Pratt parser → whitelisted-AST interpreter) with
+ * NO eval / new Function / node:vm, NO member access, NO loops/lambdas, and
+ * hard resource bounds. Powers the `expression` DeviceLinkSource kind.
+ *
+ * This is the module barrel; leaf files inside @camstack/types MUST import from
+ * the deep modules (e.g. `../expression/compile.js`), never through this file
+ * OR the root barrel (see biome-plugins/no-types-barrel-leaf-import.grit).
+ */
+export type { ExpressionValue, ExpressionNode, ExpressionLiteralNode, ExpressionIdentifierNode, ExpressionUnaryNode, ExpressionBinaryNode, ExpressionLogicalNode, ExpressionConditionalNode, ExpressionCallNode, ExpressionBinaryOperator, ExpressionLogicalOperator, ExpressionUnaryOperator, } from './ast.js';
+export { ExpressionParseError, ExpressionEvalError } from './errors.js';
+export { MAX_EXPRESSION_SOURCE_LENGTH, MAX_EXPRESSION_AST_NODES, MAX_EXPRESSION_EVAL_STEPS, MAX_EXPRESSION_BINDINGS, MAX_EXPRESSION_CALL_ARGS, EXPRESSION_COMPILE_CACHE_CAPACITY, EXPRESSION_IDENTIFIER_RE, RESERVED_BINDING_NAMES, } from './limits.js';
+export { tokenize } from './tokenizer.js';
+export type { Token, Punctuator, Keyword } from './tokenizer.js';
+export { parseExpression } from './parser.js';
+export type { ParsedExpression } from './parser.js';
+export { EXPRESSION_BUILTINS, EXPRESSION_BUILTIN_NAMES, } from './builtins.js';
+export type { ExpressionBuiltin, ExpressionEvalHooks } from './builtins.js';
+export { createExpressionScope, evaluateAst } from './evaluator.js';
+export type { ExpressionEvalOptions } from './evaluator.js';
+export { compileExpression, compileExpressionSafe } from './compile.js';
+export type { CompileResult } from './compile.js';
+export { EXPRESSION_INJECTED_NOW, toExpressionValue, validateExpressionSource, evaluateLinkExpression, } from './link-expression.js';
+export type { ExpressionSourceInput, EvaluateLinkExpressionResult, } from './link-expression.js';

package/dist/expression/limits.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Resource-bound constants for the safe expression engine.
+ *
+ * Every bound is defense-in-depth: the grammar is non-Turing-complete (no
+ * loops, recursion, lambdas or member access — see `ast.ts`), so evaluation is
+ * O(nodeCount) by construction. These caps merely put a hard ceiling on the
+ * work a single author-supplied expression can request, so a hostile or
+ * accidental pathological string can never spend unbounded CPU/memory.
+ */
+/** Max source length (chars) — checked BEFORE tokenizing so a huge string is
+ *  rejected without allocation. */
+export declare const MAX_EXPRESSION_SOURCE_LENGTH = 2048;
+/** Max AST nodes — checked during parse; a deeply nested grouping that exceeds
+ *  this is rejected as "expression too complex". */
+export declare const MAX_EXPRESSION_AST_NODES = 256;
+/** Defense-in-depth walker step budget — one increment per node visit during
+ *  evaluation. The grammar guarantees O(nodeCount) walks, so this can only trip
+ *  on a crafted maximum-size AST. */
+export declare const MAX_EXPRESSION_EVAL_STEPS = 4096;
+/** Max named bindings on one `DeviceLinkExpressionSource`. */
+export declare const MAX_EXPRESSION_BINDINGS = 32;
+/** Max positional arguments to any builtin call. */
+export declare const MAX_EXPRESSION_CALL_ARGS = 16;
+/** LRU compile-cache capacity (parsed ASTs keyed by raw source string). */
+export declare const EXPRESSION_COMPILE_CACHE_CAPACITY = 256;
+/** A legal binding / identifier name. */
+export declare const EXPRESSION_IDENTIFIER_RE: RegExp;
+/** Binding names an author may NOT use: `now` is auto-injected; the literal
+ *  keywords lex as values, not identifiers, so binding to them is meaningless. */
+export declare const RESERVED_BINDING_NAMES: ReadonlySet<string>;

package/dist/expression/link-expression.d.ts

@@ -0,0 +1,44 @@
+import { type ExpressionEvalOptions } from './evaluator.js';
+import type { ExpressionValue } from './ast.js';
+/** The `now` epoch-ms binding is auto-injected into every evaluation and is a
+ *  reserved binding name (authors may not rebind it). */
+export declare const EXPRESSION_INJECTED_NOW = "now";
+/**
+ * Coerce an untrusted `getByPath` / mirror read to an `ExpressionValue`.
+ * Non-primitive values (objects, arrays, `undefined`, functions, bigint,
+ * symbol) and non-finite numbers become `undefined` so the caller can apply
+ * its binding-miss policy (→ `null`). `null` itself is a valid value.
+ */
+export declare function toExpressionValue(raw: unknown): ExpressionValue | undefined;
+/** Shape the author-time validator accepts (structural subset of a
+ *  `DeviceLinkExpressionSource`). */
+export interface ExpressionSourceInput {
+    readonly expr: string;
+    readonly bindings: Readonly<Record<string, unknown>>;
+}
+/**
+ * Author-time validation. Returns `null` when the source is valid, else a
+ * human-readable error message. Checks: the expression compiles; binding count
+ * is within `MAX_EXPRESSION_BINDINGS`; every binding name is a legal identifier,
+ * is not reserved (`now`/keywords) and does not shadow a builtin; and every
+ * FREE identifier of the AST is covered by a binding or the injected `now`.
+ */
+export declare function validateExpressionSource(src: ExpressionSourceInput): string | null;
+/** Result of a link-expression evaluation — `ok` carries the value, the error
+ *  branch carries a reason the async channel can log while the sync channel
+ *  silently skips. */
+export type EvaluateLinkExpressionResult = {
+    readonly ok: true;
+    readonly value: ExpressionValue;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+/**
+ * Shared read-path evaluation for BOTH resolver channels. Builds a null-proto
+ * scope from `bindingValues` plus the injected `now` (supplied by the caller
+ * for determinism/testability), compiles via the LRU, and evaluates. Any
+ * failure (parse or eval) returns `{ ok: false }` — the caller treats that as
+ * "skip this link".
+ */
+export declare function evaluateLinkExpression(expr: string, bindingValues: Readonly<Record<string, ExpressionValue>>, now: number, opts?: ExpressionEvalOptions): EvaluateLinkExpressionResult;

package/dist/expression/parser.d.ts

@@ -0,0 +1,12 @@
+import type { ExpressionNode } from './ast.js';
+export interface ParsedExpression {
+    readonly ast: ExpressionNode;
+    /** Free identifiers referenced by the expression (NOT callees). */
+    readonly identifiers: ReadonlySet<string>;
+    /** Builtin function names called by the expression. */
+    readonly callees: ReadonlySet<string>;
+    readonly nodeCount: number;
+}
+/** Tokenize + parse `source` into a validated `ParsedExpression`. Throws
+ *  `ExpressionParseError` on any lexical or grammatical failure. */
+export declare function parseExpression(source: string): ParsedExpression;

package/dist/expression/tokenizer.d.ts

@@ -0,0 +1,38 @@
+/** The fixed punctuator set of the language. */
+export type Punctuator = '(' | ')' | ',' | '?' | ':' | '+' | '-' | '*' | '/' | '%' | '!' | '<' | '<=' | '>' | '>=' | '==' | '!=' | '&&' | '||';
+/** The three value keywords. */
+export type Keyword = 'true' | 'false' | 'null';
+export interface NumberToken {
+    readonly type: 'number';
+    readonly value: number;
+    readonly pos: number;
+}
+export interface StringToken {
+    readonly type: 'string';
+    readonly value: string;
+    readonly pos: number;
+}
+export interface IdentifierToken {
+    readonly type: 'identifier';
+    readonly name: string;
+    readonly pos: number;
+}
+export interface KeywordToken {
+    readonly type: 'keyword';
+    readonly keyword: Keyword;
+    readonly pos: number;
+}
+export interface PunctToken {
+    readonly type: 'punct';
+    readonly punct: Punctuator;
+    readonly pos: number;
+}
+export interface EofToken {
+    readonly type: 'eof';
+    readonly pos: number;
+}
+export type Token = NumberToken | StringToken | IdentifierToken | KeywordToken | PunctToken | EofToken;
+/** Tokenize `source` into a flat token list ending with a single `eof` token.
+ *  Throws `ExpressionParseError` on any illegal character or unterminated
+ *  string. */
+export declare function tokenize(source: string): readonly Token[];

package/dist/generated/addon-api.d.ts

@@ -4109,6 +4109,23 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         sourceStableId: string;
                         cap: string;
                         fieldPath: string;
+                    } | {
+                        kind: "expression";
+                        expr: string;
+                        bindings: Record<string, {
+                            sourceKey: string;
+                            cap: string;
+                            fieldPath: string;
+                            kind?: "field" | undefined;
+                        } | {
+                            kind: "literal";
+                            value: string | number | boolean | null;
+                        } | {
+                            kind: "global";
+                            sourceStableId: string;
+                            cap: string;
+                            fieldPath: string;
+                        }>;
                     };
                     target: {
                         cap: string;
@@ -4129,6 +4146,17 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                     } | undefined;
                 }[] | undefined;
                 role?: string | null | undefined;
+                display?: {
+                    icon?: string | undefined;
+                    label?: string | undefined;
+                    unit?: string | undefined;
+                    precision?: number | undefined;
+                    hidden?: boolean | undefined;
+                    perCap?: Record<string, {
+                        unit?: string | undefined;
+                        precision?: number | undefined;
+                    }> | undefined;
+                } | undefined;
             } | null;
             meta: object;
         }>;
@@ -4219,6 +4247,23 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         sourceStableId: string;
                         cap: string;
                         fieldPath: string;
+                    } | {
+                        kind: "expression";
+                        expr: string;
+                        bindings: Record<string, {
+                            sourceKey: string;
+                            cap: string;
+                            fieldPath: string;
+                            kind?: "field" | undefined;
+                        } | {
+                            kind: "literal";
+                            value: string | number | boolean | null;
+                        } | {
+                            kind: "global";
+                            sourceStableId: string;
+                            cap: string;
+                            fieldPath: string;
+                        }>;
                     };
                     target: {
                         cap: string;
@@ -4242,6 +4287,50 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
             output: void;
             meta: object;
         }>;
+        setDisplay: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+                deviceId: number;
+                display: {
+                    icon?: string | undefined;
+                    label?: string | undefined;
+                    unit?: string | undefined;
+                    precision?: number | undefined;
+                    hidden?: boolean | undefined;
+                    perCap?: Record<string, {
+                        unit?: string | undefined;
+                        precision?: number | undefined;
+                    }> | undefined;
+                } | null;
+            };
+            output: void;
+            meta: object;
+        }>;
+        getRoleDisplayDefaults: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            };
+            output: {
+                defaults: Record<string, {
+                    unit?: string | undefined;
+                    precision?: number | undefined;
+                    icon?: string | undefined;
+                }>;
+            };
+            meta: object;
+        }>;
+        setRoleDisplayDefaults: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+                defaults: Record<string, {
+                    unit?: string | undefined;
+                    precision?: number | undefined;
+                    icon?: string | undefined;
+                }>;
+            };
+            output: void;
+            meta: object;
+        }>;
         getWireableFields: import("@trpc/server").TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
@@ -4398,6 +4487,23 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         sourceStableId: string;
                         cap: string;
                         fieldPath: string;
+                    } | {
+                        kind: "expression";
+                        expr: string;
+                        bindings: Record<string, {
+                            sourceKey: string;
+                            cap: string;
+                            fieldPath: string;
+                            kind?: "field" | undefined;
+                        } | {
+                            kind: "literal";
+                            value: string | number | boolean | null;
+                        } | {
+                            kind: "global";
+                            sourceStableId: string;
+                            cap: string;
+                            fieldPath: string;
+                        }>;
                     };
                     target: {
                         cap: string;
@@ -4417,6 +4523,17 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         clamp?: readonly [number, number] | undefined;
                     } | undefined;
                 }[] | undefined;
+                display?: {
+                    icon?: string | undefined;
+                    label?: string | undefined;
+                    unit?: string | undefined;
+                    precision?: number | undefined;
+                    hidden?: boolean | undefined;
+                    perCap?: Record<string, {
+                        unit?: string | undefined;
+                        precision?: number | undefined;
+                    }> | undefined;
+                } | undefined;
             }[];
             meta: object;
         }>;
@@ -4471,6 +4588,23 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         sourceStableId: string;
                         cap: string;
                         fieldPath: string;
+                    } | {
+                        kind: "expression";
+                        expr: string;
+                        bindings: Record<string, {
+                            sourceKey: string;
+                            cap: string;
+                            fieldPath: string;
+                            kind?: "field" | undefined;
+                        } | {
+                            kind: "literal";
+                            value: string | number | boolean | null;
+                        } | {
+                            kind: "global";
+                            sourceStableId: string;
+                            cap: string;
+                            fieldPath: string;
+                        }>;
                     };
                     target: {
                         cap: string;
@@ -4490,6 +4624,17 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         clamp?: readonly [number, number] | undefined;
                     } | undefined;
                 }[] | undefined;
+                display?: {
+                    icon?: string | undefined;
+                    label?: string | undefined;
+                    unit?: string | undefined;
+                    precision?: number | undefined;
+                    hidden?: boolean | undefined;
+                    perCap?: Record<string, {
+                        unit?: string | undefined;
+                        precision?: number | undefined;
+                    }> | undefined;
+                } | undefined;
             } | null;
             meta: object;
         }>;
@@ -4544,6 +4689,23 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         sourceStableId: string;
                         cap: string;
                         fieldPath: string;
+                    } | {
+                        kind: "expression";
+                        expr: string;
+                        bindings: Record<string, {
+                            sourceKey: string;
+                            cap: string;
+                            fieldPath: string;
+                            kind?: "field" | undefined;
+                        } | {
+                            kind: "literal";
+                            value: string | number | boolean | null;
+                        } | {
+                            kind: "global";
+                            sourceStableId: string;
+                            cap: string;
+                            fieldPath: string;
+                        }>;
                     };
                     target: {
                         cap: string;
@@ -4563,6 +4725,17 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         clamp?: readonly [number, number] | undefined;
                     } | undefined;
                 }[] | undefined;
+                display?: {
+                    icon?: string | undefined;
+                    label?: string | undefined;
+                    unit?: string | undefined;
+                    precision?: number | undefined;
+                    hidden?: boolean | undefined;
+                    perCap?: Record<string, {
+                        unit?: string | undefined;
+                        precision?: number | undefined;
+                    }> | undefined;
+                } | undefined;
             }[];
             meta: object;
         }>;
@@ -18184,6 +18357,23 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         sourceStableId: string;
                         cap: string;
                         fieldPath: string;
+                    } | {
+                        kind: "expression";
+                        expr: string;
+                        bindings: Record<string, {
+                            sourceKey: string;
+                            cap: string;
+                            fieldPath: string;
+                            kind?: "field" | undefined;
+                        } | {
+                            kind: "literal";
+                            value: string | number | boolean | null;
+                        } | {
+                            kind: "global";
+                            sourceStableId: string;
+                            cap: string;
+                            fieldPath: string;
+                        }>;
                     };
                     target: {
                         cap: string;
@@ -18204,6 +18394,17 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                     } | undefined;
                 }[] | undefined;
                 role?: string | null | undefined;
+                display?: {
+                    icon?: string | undefined;
+                    label?: string | undefined;
+                    unit?: string | undefined;
+                    precision?: number | undefined;
+                    hidden?: boolean | undefined;
+                    perCap?: Record<string, {
+                        unit?: string | undefined;
+                        precision?: number | undefined;
+                    }> | undefined;
+                } | undefined;
             } | null;
             meta: object;
         }>;
@@ -18294,6 +18495,23 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         sourceStableId: string;
                         cap: string;
                         fieldPath: string;
+                    } | {
+                        kind: "expression";
+                        expr: string;
+                        bindings: Record<string, {
+                            sourceKey: string;
+                            cap: string;
+                            fieldPath: string;
+                            kind?: "field" | undefined;
+                        } | {
+                            kind: "literal";
+                            value: string | number | boolean | null;
+                        } | {
+                            kind: "global";
+                            sourceStableId: string;
+                            cap: string;
+                            fieldPath: string;
+                        }>;
                     };
                     target: {
                         cap: string;
@@ -18317,6 +18535,50 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
             output: void;
             meta: object;
         }>;
+        setDisplay: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+                deviceId: number;
+                display: {
+                    icon?: string | undefined;
+                    label?: string | undefined;
+                    unit?: string | undefined;
+                    precision?: number | undefined;
+                    hidden?: boolean | undefined;
+                    perCap?: Record<string, {
+                        unit?: string | undefined;
+                        precision?: number | undefined;
+                    }> | undefined;
+                } | null;
+            };
+            output: void;
+            meta: object;
+        }>;
+        getRoleDisplayDefaults: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            };
+            output: {
+                defaults: Record<string, {
+                    unit?: string | undefined;
+                    precision?: number | undefined;
+                    icon?: string | undefined;
+                }>;
+            };
+            meta: object;
+        }>;
+        setRoleDisplayDefaults: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+                defaults: Record<string, {
+                    unit?: string | undefined;
+                    precision?: number | undefined;
+                    icon?: string | undefined;
+                }>;
+            };
+            output: void;
+            meta: object;
+        }>;
         getWireableFields: import("@trpc/server").TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
@@ -18473,6 +18735,23 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         sourceStableId: string;
                         cap: string;
                         fieldPath: string;
+                    } | {
+                        kind: "expression";
+                        expr: string;
+                        bindings: Record<string, {
+                            sourceKey: string;
+                            cap: string;
+                            fieldPath: string;
+                            kind?: "field" | undefined;
+                        } | {
+                            kind: "literal";
+                            value: string | number | boolean | null;
+                        } | {
+                            kind: "global";
+                            sourceStableId: string;
+                            cap: string;
+                            fieldPath: string;
+                        }>;
                     };
                     target: {
                         cap: string;
@@ -18492,6 +18771,17 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         clamp?: readonly [number, number] | undefined;
                     } | undefined;
                 }[] | undefined;
+                display?: {
+                    icon?: string | undefined;
+                    label?: string | undefined;
+                    unit?: string | undefined;
+                    precision?: number | undefined;
+                    hidden?: boolean | undefined;
+                    perCap?: Record<string, {
+                        unit?: string | undefined;
+                        precision?: number | undefined;
+                    }> | undefined;
+                } | undefined;
             }[];
             meta: object;
         }>;
@@ -18546,6 +18836,23 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         sourceStableId: string;
                         cap: string;
                         fieldPath: string;
+                    } | {
+                        kind: "expression";
+                        expr: string;
+                        bindings: Record<string, {
+                            sourceKey: string;
+                            cap: string;
+                            fieldPath: string;
+                            kind?: "field" | undefined;
+                        } | {
+                            kind: "literal";
+                            value: string | number | boolean | null;
+                        } | {
+                            kind: "global";
+                            sourceStableId: string;
+                            cap: string;
+                            fieldPath: string;
+                        }>;
                     };
                     target: {
                         cap: string;
@@ -18565,6 +18872,17 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         clamp?: readonly [number, number] | undefined;
                     } | undefined;
                 }[] | undefined;
+                display?: {
+                    icon?: string | undefined;
+                    label?: string | undefined;
+                    unit?: string | undefined;
+                    precision?: number | undefined;
+                    hidden?: boolean | undefined;
+                    perCap?: Record<string, {
+                        unit?: string | undefined;
+                        precision?: number | undefined;
+                    }> | undefined;
+                } | undefined;
             } | null;
             meta: object;
         }>;
@@ -18619,6 +18937,23 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         sourceStableId: string;
                         cap: string;
                         fieldPath: string;
+                    } | {
+                        kind: "expression";
+                        expr: string;
+                        bindings: Record<string, {
+                            sourceKey: string;
+                            cap: string;
+                            fieldPath: string;
+                            kind?: "field" | undefined;
+                        } | {
+                            kind: "literal";
+                            value: string | number | boolean | null;
+                        } | {
+                            kind: "global";
+                            sourceStableId: string;
+                            cap: string;
+                            fieldPath: string;
+                        }>;
                     };
                     target: {
                         cap: string;
@@ -18638,6 +18973,17 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
                         clamp?: readonly [number, number] | undefined;
                     } | undefined;
                 }[] | undefined;
+                display?: {
+                    icon?: string | undefined;
+                    label?: string | undefined;
+                    unit?: string | undefined;
+                    precision?: number | undefined;
+                    hidden?: boolean | undefined;
+                    perCap?: Record<string, {
+                        unit?: string | undefined;
+                        precision?: number | undefined;
+                    }> | undefined;
+                } | undefined;
             }[];
             meta: object;
         }>;

package/dist/generated/device-proxy.d.ts

@@ -254,7 +254,7 @@ export interface DeviceProxy {
     readonly cameraPipelineConfig: Pick<InferDeviceProxyCap<typeof cameraPipelineConfigCapability>, 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
     readonly deviceAdoption: Pick<InferDeviceProxyCap<typeof deviceAdoptionCapability>, 'getStatus'>;
     readonly deviceExport: Pick<InferDeviceProxyCap<typeof deviceExportCapability>, 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
-    readonly deviceManager: Pick<InferDeviceProxyCap<typeof deviceManagerCapability>, 'loadConfig' | 'loadRuntimeState' | 'loadMeta' | 'setName' | 'setLocation' | 'setType' | 'setIntegrationId' | 'setLinkDeviceId' | 'setPrimaryChildEntityId' | 'setChildLayout' | 'setDeviceLinks' | 'getWireableFields' | 'setRole' | 'applyInitialMeta' | 'setMetadata' | 'setDisabled' | 'getDevice' | 'getStreamSources' | 'getConfigSchema' | 'getSettingsSchema' | 'updateConfig' | 'enable' | 'disable' | 'remove' | 'getStreamProfileMap' | 'setStreamProfileMap' | 'probeStreams' | 'getBindings' | 'getAllBindings' | 'setWrapperActive' | 'getDeviceSettingsAggregate' | 'getDeviceLiveInfoAggregate' | 'getDeviceAggregate' | 'runDeviceAction' | 'updateDeviceField' | 'updateDeviceFieldsBatch' | 'testField' | 'getDeviceStatusAggregate'>;
+    readonly deviceManager: Pick<InferDeviceProxyCap<typeof deviceManagerCapability>, 'loadConfig' | 'loadRuntimeState' | 'loadMeta' | 'setName' | 'setLocation' | 'setType' | 'setIntegrationId' | 'setLinkDeviceId' | 'setPrimaryChildEntityId' | 'setChildLayout' | 'setDeviceLinks' | 'setDisplay' | 'getWireableFields' | 'setRole' | 'applyInitialMeta' | 'setMetadata' | 'setDisabled' | 'getDevice' | 'getStreamSources' | 'getConfigSchema' | 'getSettingsSchema' | 'updateConfig' | 'enable' | 'disable' | 'remove' | 'getStreamProfileMap' | 'setStreamProfileMap' | 'probeStreams' | 'getBindings' | 'getAllBindings' | 'setWrapperActive' | 'getDeviceSettingsAggregate' | 'getDeviceLiveInfoAggregate' | 'getDeviceAggregate' | 'runDeviceAction' | 'updateDeviceField' | 'updateDeviceFieldsBatch' | 'testField' | 'getDeviceStatusAggregate'>;
     readonly deviceState: Pick<InferDeviceProxyCap<typeof deviceStateCapability>, 'getSnapshot' | 'getCapSlice' | 'setCapSlice'>;
     readonly faceGallery: Pick<InferDeviceProxyCap<typeof faceGalleryCapability>, 'getFaceByTrack'>;
     readonly networkQuality: Pick<InferDeviceProxyCap<typeof networkQualityCapability>, 'getDeviceStats' | 'reportClientStats'>;

package/dist/generated/method-access-map.d.ts

@@ -6,7 +6,7 @@
  * scope+access check inside `protectedProcedure` (see
  * `server/backend/src/api/trpc/trpc.middleware.ts`).
  *
- * Coverage: 724 method paths across 110 capabilities.
+ * Coverage: 727 method paths across 110 capabilities.
  */
 import type { CapabilityMethodAccess } from '../capabilities/capability-definition.js';
 export interface MethodAccessRecord {