@camstack/types 1.1.20 → 1.1.21

package/dist/addon.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-BabrCASa.js");
+const require_sleep = require("./sleep-DaQgDq90.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
 exports.BaseAddon = require_sleep.BaseAddon;
 exports.DATAPLANE_SECRET_HEADER = require_sleep.DATAPLANE_SECRET_HEADER;

package/dist/addon.mjs

@@ -1,3 +1,3 @@
-import { A as ReadinessRegistry, C as asJsonObject, O as parseJsonUnknown, P as scopeKey, T as asString, a as adminUiCapability, b as DeviceType, gt as DisposerChain, ht as EventCategory, i as deviceOpsCapability, j as ReadinessTimeoutError, k as DATAPLANE_SECRET_HEADER, o as createDeviceProxy, ot as BaseAddon, p as expandCapMethods, st as normalizeAddonInitResult, t as sleep, ut as emitReadiness } from "./sleep-MHm--th-.mjs";
+import { A as ReadinessRegistry, C as asJsonObject, O as parseJsonUnknown, P as scopeKey, T as asString, a as adminUiCapability, b as DeviceType, gt as DisposerChain, ht as EventCategory, i as deviceOpsCapability, j as ReadinessTimeoutError, k as DATAPLANE_SECRET_HEADER, o as createDeviceProxy, ot as BaseAddon, p as expandCapMethods, st as normalizeAddonInitResult, t as sleep, ut as emitReadiness } from "./sleep-BO1nweKv.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 export { BaseAddon, DATAPLANE_SECRET_HEADER, DeviceType, DisposerChain, EventCategory, ReadinessRegistry, ReadinessTimeoutError, adminUiCapability, asJsonObject, asString, createDeviceProxy, deviceOpsCapability, emitReadiness, errMsg, expandCapMethods, normalizeAddonInitResult, parseJsonUnknown, scopeKey, sleep };

package/dist/capabilities/device-manager.cap.d.ts

@@ -19,12 +19,6 @@
 import { z } from 'zod';
 import { DeviceType } from '../device/device-type.js';
 import { StreamSourceEntrySchema } from './schemas/streaming-shared.js';
-/** Cap-wire shape of a DeviceLink — structurally mirrors `DeviceLink` in
- *  `device-management.ts`. Source is a union: a FIELD source copies a sibling
- *  accessory's status field (`kind` optional/absent for wire compat); a
- *  LITERAL source carries a per-device constant (no sibling is read); a
- *  GLOBAL source (P2e) copies ANY device's status field, addressed by the
- *  source device's full re-sync-stable `stableId`. */
 export declare const DeviceLinkSchema: z.ZodObject<{
     id: z.ZodString;
     source: z.ZodUnion<readonly [z.ZodObject<{
@@ -40,6 +34,23 @@ export declare const DeviceLinkSchema: z.ZodObject<{
         sourceStableId: z.ZodString;
         cap: z.ZodString;
         fieldPath: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"expression">;
+        expr: z.ZodString;
+        bindings: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodOptional<z.ZodLiteral<"field">>;
+            sourceKey: z.ZodString;
+            cap: z.ZodString;
+            fieldPath: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"literal">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"global">;
+            sourceStableId: z.ZodString;
+            cap: z.ZodString;
+            fieldPath: z.ZodString;
+        }, z.core.$strip>]>>;
     }, z.core.$strip>]>;
     target: z.ZodObject<{
         cap: z.ZodString;
@@ -59,6 +70,34 @@ export declare const DeviceLinkSchema: z.ZodObject<{
         clamp: z.ZodOptional<z.ZodReadonly<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
     }, z.core.$strip>], "kind">>;
 }, z.core.$strip>;
+/** Cap-wire shape of a per-cap display refinement — mirrors
+ *  `DeviceCapDisplayOverride` in `device-management.ts`. */
+export declare const DeviceCapDisplayOverrideSchema: z.ZodObject<{
+    unit: z.ZodOptional<z.ZodString>;
+    precision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** Cap-wire shape of an operator-authored per-device display override —
+ *  mirrors `DeviceDisplayOverride` in `device-management.ts`. `precision`
+ *  bounds mirror `numeric-sensor.cap.ts` (`int 0-10`). */
+export declare const DeviceDisplayOverrideSchema: z.ZodObject<{
+    icon: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    unit: z.ZodOptional<z.ZodString>;
+    precision: z.ZodOptional<z.ZodNumber>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    perCap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        unit: z.ZodOptional<z.ZodString>;
+        precision: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** Cap-wire shape of a per-role display default — mirrors `RoleDisplayDefault`
+ *  in `device-management.ts`. Keyed by `DeviceRole` string (role strings cross
+ *  the wire as plain strings everywhere else — cf. `DeviceInfoSchema.role`). */
+export declare const RoleDisplayDefaultSchema: z.ZodObject<{
+    unit: z.ZodOptional<z.ZodString>;
+    precision: z.ZodOptional<z.ZodNumber>;
+    icon: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 /**
  * Serializable projection of a live IDevice.
  * Returned by listAll, getDevice, getChildren.
@@ -110,6 +149,23 @@ export declare const DeviceInfoSchema: z.ZodObject<{
             sourceStableId: z.ZodString;
             cap: z.ZodString;
             fieldPath: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"expression">;
+            expr: z.ZodString;
+            bindings: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodOptional<z.ZodLiteral<"field">>;
+                sourceKey: z.ZodString;
+                cap: z.ZodString;
+                fieldPath: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"literal">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"global">;
+                sourceStableId: z.ZodString;
+                cap: z.ZodString;
+                fieldPath: z.ZodString;
+            }, z.core.$strip>]>>;
         }, z.core.$strip>]>;
         target: z.ZodObject<{
             cap: z.ZodString;
@@ -129,6 +185,17 @@ export declare const DeviceInfoSchema: z.ZodObject<{
             clamp: z.ZodOptional<z.ZodReadonly<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
         }, z.core.$strip>], "kind">>;
     }, z.core.$strip>>>>;
+    display: z.ZodOptional<z.ZodObject<{
+        icon: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        unit: z.ZodOptional<z.ZodString>;
+        precision: z.ZodOptional<z.ZodNumber>;
+        hidden: z.ZodOptional<z.ZodBoolean>;
+        perCap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            unit: z.ZodOptional<z.ZodString>;
+            precision: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const ConfigEntrySchema: z.ZodObject<{
     key: z.ZodString;
@@ -191,6 +258,23 @@ export declare const DeviceMetaSchema: z.ZodObject<{
             sourceStableId: z.ZodString;
             cap: z.ZodString;
             fieldPath: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"expression">;
+            expr: z.ZodString;
+            bindings: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodOptional<z.ZodLiteral<"field">>;
+                sourceKey: z.ZodString;
+                cap: z.ZodString;
+                fieldPath: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"literal">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"global">;
+                sourceStableId: z.ZodString;
+                cap: z.ZodString;
+                fieldPath: z.ZodString;
+            }, z.core.$strip>]>>;
         }, z.core.$strip>]>;
         target: z.ZodObject<{
             cap: z.ZodString;
@@ -211,6 +295,17 @@ export declare const DeviceMetaSchema: z.ZodObject<{
         }, z.core.$strip>], "kind">>;
     }, z.core.$strip>>>>;
     role: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    display: z.ZodOptional<z.ZodObject<{
+        icon: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        unit: z.ZodOptional<z.ZodString>;
+        precision: z.ZodOptional<z.ZodNumber>;
+        hidden: z.ZodOptional<z.ZodBoolean>;
+        perCap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            unit: z.ZodOptional<z.ZodString>;
+            precision: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const DeviceRegisterPayloadSchema: z.ZodObject<{
     addonId: z.ZodString;
@@ -325,6 +420,23 @@ export declare const deviceManagerCapability: {
                     sourceStableId: z.ZodString;
                     cap: z.ZodString;
                     fieldPath: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"expression">;
+                    expr: z.ZodString;
+                    bindings: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                        kind: z.ZodOptional<z.ZodLiteral<"field">>;
+                        sourceKey: z.ZodString;
+                        cap: z.ZodString;
+                        fieldPath: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"literal">;
+                        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"global">;
+                        sourceStableId: z.ZodString;
+                        cap: z.ZodString;
+                        fieldPath: z.ZodString;
+                    }, z.core.$strip>]>>;
                 }, z.core.$strip>]>;
                 target: z.ZodObject<{
                     cap: z.ZodString;
@@ -345,6 +457,17 @@ export declare const deviceManagerCapability: {
                 }, z.core.$strip>], "kind">>;
             }, z.core.$strip>>>>;
             role: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            display: z.ZodOptional<z.ZodObject<{
+                icon: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                unit: z.ZodOptional<z.ZodString>;
+                precision: z.ZodOptional<z.ZodNumber>;
+                hidden: z.ZodOptional<z.ZodBoolean>;
+                perCap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    unit: z.ZodOptional<z.ZodString>;
+                    precision: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** Update the operator-edited display name. Persists to the meta
          *  row + emits `EventCategory.DeviceMetaChanged`. */
@@ -425,6 +548,23 @@ export declare const deviceManagerCapability: {
                     sourceStableId: z.ZodString;
                     cap: z.ZodString;
                     fieldPath: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"expression">;
+                    expr: z.ZodString;
+                    bindings: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                        kind: z.ZodOptional<z.ZodLiteral<"field">>;
+                        sourceKey: z.ZodString;
+                        cap: z.ZodString;
+                        fieldPath: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"literal">;
+                        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"global">;
+                        sourceStableId: z.ZodString;
+                        cap: z.ZodString;
+                        fieldPath: z.ZodString;
+                    }, z.core.$strip>]>>;
                 }, z.core.$strip>]>;
                 target: z.ZodObject<{
                     cap: z.ZodString;
@@ -445,6 +585,45 @@ export declare const deviceManagerCapability: {
                 }, z.core.$strip>], "kind">>;
             }, z.core.$strip>>>;
         }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Set (or clear) the per-device display override on the meta row. Mirrors
+         *  `setChildLayout` persistence; `null` clears the override entirely. The
+         *  override unit(s) are normalized (`normalizeUnit`) at write so the render
+         *  path's `UNIT_TABLE` lookups always hit canonical spellings. Persisted,
+         *  projected, and preserved across re-register/restore. Idempotent. */
+        readonly setDisplay: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            display: z.ZodNullable<z.ZodObject<{
+                icon: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                unit: z.ZodOptional<z.ZodString>;
+                precision: z.ZodOptional<z.ZodNumber>;
+                hidden: z.ZodOptional<z.ZodBoolean>;
+                perCap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    unit: z.ZodOptional<z.ZodString>;
+                    precision: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Read the operator-authored per-role display defaults (unit/precision/
+         *  icon), keyed by `DeviceRole` string. Empty record when none set. */
+        readonly getRoleDisplayDefaults: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+            defaults: z.ZodRecord<z.ZodString, z.ZodObject<{
+                unit: z.ZodOptional<z.ZodString>;
+                precision: z.ZodOptional<z.ZodNumber>;
+                icon: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, "query">;
+        /** Replace the per-role display defaults whole-record (full replace — the
+         *  caller sends the complete map). Override unit(s) are normalized at write.
+         *  Not per-device, so nothing is emitted; the UI invalidates its own query
+         *  on mutate. */
+        readonly setRoleDisplayDefaults: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            defaults: z.ZodRecord<z.ZodString, z.ZodObject<{
+                unit: z.ZodOptional<z.ZodString>;
+                precision: z.ZodOptional<z.ZodNumber>;
+                icon: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
         /** List the wireable status-schema fields per cap bound to a device.
          *  Powers the Wiring tab's field pickers. Caps without a status schema are
          *  omitted. Item-array caps (`status.itemArray`, e.g. consumables) also
@@ -603,6 +782,23 @@ export declare const deviceManagerCapability: {
                     sourceStableId: z.ZodString;
                     cap: z.ZodString;
                     fieldPath: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"expression">;
+                    expr: z.ZodString;
+                    bindings: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                        kind: z.ZodOptional<z.ZodLiteral<"field">>;
+                        sourceKey: z.ZodString;
+                        cap: z.ZodString;
+                        fieldPath: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"literal">;
+                        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"global">;
+                        sourceStableId: z.ZodString;
+                        cap: z.ZodString;
+                        fieldPath: z.ZodString;
+                    }, z.core.$strip>]>>;
                 }, z.core.$strip>]>;
                 target: z.ZodObject<{
                     cap: z.ZodString;
@@ -622,6 +818,17 @@ export declare const deviceManagerCapability: {
                     clamp: z.ZodOptional<z.ZodReadonly<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
                 }, z.core.$strip>], "kind">>;
             }, z.core.$strip>>>>;
+            display: z.ZodOptional<z.ZodObject<{
+                icon: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                unit: z.ZodOptional<z.ZodString>;
+                precision: z.ZodOptional<z.ZodNumber>;
+                hidden: z.ZodOptional<z.ZodBoolean>;
+                perCap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    unit: z.ZodOptional<z.ZodString>;
+                    precision: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** Get a single device by numeric deviceId. */
         readonly getDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
@@ -672,6 +879,23 @@ export declare const deviceManagerCapability: {
                     sourceStableId: z.ZodString;
                     cap: z.ZodString;
                     fieldPath: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"expression">;
+                    expr: z.ZodString;
+                    bindings: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                        kind: z.ZodOptional<z.ZodLiteral<"field">>;
+                        sourceKey: z.ZodString;
+                        cap: z.ZodString;
+                        fieldPath: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"literal">;
+                        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"global">;
+                        sourceStableId: z.ZodString;
+                        cap: z.ZodString;
+                        fieldPath: z.ZodString;
+                    }, z.core.$strip>]>>;
                 }, z.core.$strip>]>;
                 target: z.ZodObject<{
                     cap: z.ZodString;
@@ -691,6 +915,17 @@ export declare const deviceManagerCapability: {
                     clamp: z.ZodOptional<z.ZodReadonly<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
                 }, z.core.$strip>], "kind">>;
             }, z.core.$strip>>>>;
+            display: z.ZodOptional<z.ZodObject<{
+                icon: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                unit: z.ZodOptional<z.ZodString>;
+                precision: z.ZodOptional<z.ZodNumber>;
+                hidden: z.ZodOptional<z.ZodBoolean>;
+                perCap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    unit: z.ZodOptional<z.ZodString>;
+                    precision: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** List children of a parent device (by parent numeric id). */
         readonly getChildren: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
@@ -741,6 +976,23 @@ export declare const deviceManagerCapability: {
                     sourceStableId: z.ZodString;
                     cap: z.ZodString;
                     fieldPath: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"expression">;
+                    expr: z.ZodString;
+                    bindings: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                        kind: z.ZodOptional<z.ZodLiteral<"field">>;
+                        sourceKey: z.ZodString;
+                        cap: z.ZodString;
+                        fieldPath: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"literal">;
+                        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"global">;
+                        sourceStableId: z.ZodString;
+                        cap: z.ZodString;
+                        fieldPath: z.ZodString;
+                    }, z.core.$strip>]>>;
                 }, z.core.$strip>]>;
                 target: z.ZodObject<{
                     cap: z.ZodString;
@@ -760,6 +1012,17 @@ export declare const deviceManagerCapability: {
                     clamp: z.ZodOptional<z.ZodReadonly<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
                 }, z.core.$strip>], "kind">>;
             }, z.core.$strip>>>>;
+            display: z.ZodOptional<z.ZodObject<{
+                icon: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                unit: z.ZodOptional<z.ZodString>;
+                precision: z.ZodOptional<z.ZodNumber>;
+                hidden: z.ZodOptional<z.ZodBoolean>;
+                perCap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    unit: z.ZodOptional<z.ZodString>;
+                    precision: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** Get stream sources for a camera device. */
         readonly getStreamSources: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{

package/dist/capabilities/pipeline-orchestrator.cap.d.ts

@@ -459,7 +459,10 @@ export declare const pipelineOrchestratorCapability: {
     readonly methods: {
         /**
          * Pin a camera's pipeline to a specific agent (L1 affinity).
-         * The orchestrator re-evaluates the assignment immediately.
+         * The orchestrator re-evaluates the assignment immediately and persists
+         * the pin under the canonical `pipelineNodeId` device-store key (the
+         * legacy `preferredAgent` key is nulled on write and kept only as a
+         * read-only fallback for stores written before the unification).
          */
         readonly assignPipeline: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
@@ -469,8 +472,9 @@ export declare const pipelineOrchestratorCapability: {
         }, z.core.$strip>, "mutation">;
         /**
          * Clear a camera's pipeline pin and let the auto-balancer re-pick
-         * the optimal agent. The orchestrator persists `preferredAgent=null`
-         * (and `pipelineNodeId='auto'`), then re-runs the balancer with the
+         * the optimal agent. The orchestrator persists the canonical
+         * `pipelineNodeId='auto'` (and nulls the legacy `preferredAgent`),
+         * then re-runs the balancer with the
          * cached `RunnerCameraConfig` and migrates only when the chosen
          * node differs. The camera stays in `getPipelineAssignments()` —
          * just with `pinned=false`. If no runner is currently available

package/dist/device/device-management.d.ts

@@ -1,6 +1,6 @@
 import type { z } from 'zod';
-import type { DeviceType } from './device-type.js';
 import type { IDevice } from './device.js';
+import type { DeviceType } from './device-type.js';
 import type { SourceInfo } from './source-info.js';
 export interface DeviceManualCreation {
     getChildCreationSchema(type: DeviceType): z.ZodObject<z.core.$ZodLooseShape>;
@@ -127,7 +127,22 @@ export interface DeviceLinkGlobalSource {
     readonly cap: string;
     readonly fieldPath: string;
 }
-export type DeviceLinkSource = DeviceLinkFieldSource | DeviceLinkLiteralSource | DeviceLinkGlobalSource;
+/** The source kinds a single expression BINDING may use — a sibling FIELD, a
+ *  per-device LITERAL, or a GLOBAL device field. Never another expression:
+ *  bindings do not nest, so an expression cannot reference another expression. */
+export type DeviceLinkExpressionBinding = DeviceLinkFieldSource | DeviceLinkLiteralSource | DeviceLinkGlobalSource;
+/** Expression source (Stage X): compute the target field from N named source
+ *  bindings via a safe, non-Turing-complete infix expression (see
+ *  `packages/types/src/expression/`). Each binding resolves to an
+ *  `ExpressionValue` and is exposed to the expression under its record key.
+ *  `now` (epoch ms) is auto-injected and is a reserved binding name. The
+ *  evaluated result flows through `transform` exactly like a scalar source. */
+export interface DeviceLinkExpressionSource {
+    readonly kind: 'expression';
+    readonly expr: string;
+    readonly bindings: Readonly<Record<string, DeviceLinkExpressionBinding>>;
+}
+export type DeviceLinkSource = DeviceLinkFieldSource | DeviceLinkLiteralSource | DeviceLinkGlobalSource | DeviceLinkExpressionSource;
 /** The target field a link writes: a dot-path into the target cap's status. */
 export interface DeviceLinkTarget {
     readonly cap: string;
@@ -156,6 +171,42 @@ export interface DeviceLink {
     readonly transform?: DeviceLinkTransform;
 }
 export type DeviceLinks = readonly DeviceLink[];
+/** Per-cap display refinement inside a `DeviceDisplayOverride` — unit/precision
+ *  only (icon/label/hidden are device-level). Keyed by cap name for devices
+ *  carrying several numeric caps (e.g. power-meter). */
+export interface DeviceCapDisplayOverride {
+    readonly unit?: string;
+    readonly precision?: number;
+}
+/** Operator-authored per-device display override. Rides the `DeviceMeta`
+ *  lifecycle (persist/preserve/project/pre-seed) — deliberately NOT a new
+ *  cap/store. All fields optional; an empty object is equivalent to absent.
+ *  `unit` triggers render-time conversion when same-dimension as the live
+ *  slice unit (storage stays in source units); `precision` applies AFTER
+ *  conversion; `hidden` removes the device from list surfaces (distinct from
+ *  the HA-only accessories-cap `hiddenChildIds` mechanism). */
+export interface DeviceDisplayOverride {
+    /** Key into ui-library's display icon registry. */
+    readonly icon?: string;
+    /** Overrides the `DEVICE_ROLE_META` label (NOT the device name). */
+    readonly label?: string;
+    /** Canonical spelling (`normalizeUnit` applied at write). */
+    readonly unit?: string;
+    /** Int 0-10, same contract as the slice `precision` field. */
+    readonly precision?: number;
+    readonly hidden?: boolean;
+    readonly perCap?: Readonly<Record<string, DeviceCapDisplayOverride>>;
+}
+/** Operator-authored per-role display default (unit/precision/icon), keyed by
+ *  `DeviceRole` string. Resolution merges these UNDER any per-device
+ *  `DeviceDisplayOverride`. Stored whole-record (full replace) in the
+ *  device-manager addon store's `roleDisplayDefaults` key — NOT on any device's
+ *  meta row. */
+export interface RoleDisplayDefault {
+    readonly unit?: string;
+    readonly precision?: number;
+    readonly icon?: string;
+}
 export interface DeviceMeta {
     readonly id: number;
     readonly stableId: string;
@@ -207,6 +258,12 @@ export interface DeviceMeta {
      *  cap field). Same create/persist/project/restore lifecycle as `childLayout`.
      *  Absent ⇒ no links. Overlaid onto the target cap's `getStatus` at read time. */
     readonly deviceLinks?: DeviceLinks;
+    /** Operator-authored per-device display override (icon/label/unit/precision/
+     *  hidden). Same create/persist/project/restore lifecycle as `deviceLinks`.
+     *  Absent ⇒ no override; the renderer falls back to role default → live slice
+     *  → canonical unit. Applied at RENDER time only — storage stays in source
+     *  units. */
+    readonly display?: DeviceDisplayOverride;
 }
 /**
  * Initial meta a provider supplies on `onCreateDevice`. Differs
@@ -237,6 +294,8 @@ export interface InitialDeviceMeta {
     readonly childLayout?: ChildLayout;
     /** Cross-device field wirings set at create. Mirrors `DeviceMeta.deviceLinks`. */
     readonly deviceLinks?: DeviceLinks;
+    /** Per-device display override set at create. Mirrors `DeviceMeta.display`. */
+    readonly display?: DeviceDisplayOverride;
 }
 /**
  * Single-call payload returned by `BaseDeviceProvider.onCreateDevice`.

package/dist/device/index.d.ts

@@ -11,7 +11,7 @@ export type { IDevice } from './device.js';
 export { DEVICE_PROFILES, BATTERY_DEVICE_PROFILE, deviceMatchesProfile, resolveDeviceProfile, } from './device-profile.js';
 export type { DeviceProfile, DeviceProfileMatch, DeviceProfileDefaults, PipelinePhaseMode, } from './device-profile.js';
 export type { ICameraDevice, StreamSourceEntry } from './camera-device.js';
-export type { DeviceManualCreation, DeviceDiscovery, DiscoveredDevice, SavedDevice, DeviceMeta, InitialDeviceMeta, CreateDeviceSpec, ChildLayout, ChildLayoutEntry, DeviceLinkFieldSource, DeviceLinkLiteralSource, DeviceLinkGlobalSource, DeviceLinkSource, DeviceLinkTarget, DeviceLinkTransform, DeviceLink, DeviceLinks, } from './device-management.js';
+export type { DeviceManualCreation, DeviceDiscovery, DiscoveredDevice, SavedDevice, DeviceMeta, InitialDeviceMeta, CreateDeviceSpec, ChildLayout, ChildLayoutEntry, DeviceLinkFieldSource, DeviceLinkLiteralSource, DeviceLinkGlobalSource, DeviceLinkExpressionBinding, DeviceLinkExpressionSource, DeviceLinkSource, DeviceLinkTarget, DeviceLinkTransform, DeviceLink, DeviceLinks, } from './device-management.js';
 export { zodEntriesToConfigUI } from './zod-to-config-ui.js';
 export type { DeviceConfigEntry } from './zod-to-config-ui.js';
 export { createRuntimeStateBridge } from './runtime-state-helpers.js';

package/dist/expression/ast.d.ts

@@ -0,0 +1,56 @@
+/**
+ * AST for the safe expression mini-language.
+ *
+ * SECURITY BY CONSTRUCTION (spec §4 rule 3): there is deliberately NO member
+ * node, NO index node, NO assignment node and NO lambda/function node in this
+ * union. `a.b`, `a["b"]`, `a = b` and `() => …` are therefore UNREPRESENTABLE —
+ * `__proto__` / `constructor` / `prototype` traversal is impossible at the type
+ * level, not by a runtime denylist. `ExpressionCallNode.callee` is a plain
+ * string (a builtin name), never a node, so a computed call like `(min)(1)` is
+ * unparseable.
+ *
+ * The value domain is the four JSON primitives — no objects, arrays or
+ * functions ever flow through the evaluator.
+ */
+/** The only value types the engine produces or consumes. */
+export type ExpressionValue = number | string | boolean | null;
+export type ExpressionBinaryOperator = '+' | '-' | '*' | '/' | '%' | '==' | '!=' | '<' | '<=' | '>' | '>=';
+export type ExpressionLogicalOperator = '&&' | '||';
+export type ExpressionUnaryOperator = '-' | '!';
+export interface ExpressionLiteralNode {
+    readonly kind: 'literal';
+    readonly value: ExpressionValue;
+}
+export interface ExpressionIdentifierNode {
+    readonly kind: 'identifier';
+    readonly name: string;
+}
+export interface ExpressionUnaryNode {
+    readonly kind: 'unary';
+    readonly op: ExpressionUnaryOperator;
+    readonly operand: ExpressionNode;
+}
+export interface ExpressionBinaryNode {
+    readonly kind: 'binary';
+    readonly op: ExpressionBinaryOperator;
+    readonly left: ExpressionNode;
+    readonly right: ExpressionNode;
+}
+export interface ExpressionLogicalNode {
+    readonly kind: 'logical';
+    readonly op: ExpressionLogicalOperator;
+    readonly left: ExpressionNode;
+    readonly right: ExpressionNode;
+}
+export interface ExpressionConditionalNode {
+    readonly kind: 'conditional';
+    readonly test: ExpressionNode;
+    readonly consequent: ExpressionNode;
+    readonly alternate: ExpressionNode;
+}
+export interface ExpressionCallNode {
+    readonly kind: 'call';
+    readonly callee: string;
+    readonly args: readonly ExpressionNode[];
+}
+export type ExpressionNode = ExpressionLiteralNode | ExpressionIdentifierNode | ExpressionUnaryNode | ExpressionBinaryNode | ExpressionLogicalNode | ExpressionConditionalNode | ExpressionCallNode;

package/dist/expression/builtins.d.ts

@@ -0,0 +1,19 @@
+import type { ExpressionValue } from './ast.js';
+/** Optional runtime hooks the evaluator threads through to builtins. Stage U
+ *  installs the real unit-conversion table here; absent → the `convert` stub. */
+export interface ExpressionEvalHooks {
+    /** Convert `value` from unit `from` to unit `to`; `null` when the pair is
+     *  not convertible. Absent hook → `convert` uses its identity-only stub. */
+    readonly convert?: (value: number, from: string, to: string) => number | null;
+}
+export interface ExpressionBuiltin {
+    readonly minArgs: number;
+    /** `Number.POSITIVE_INFINITY` for variadic builtins. */
+    readonly maxArgs: number;
+    readonly apply: (args: readonly ExpressionValue[], hooks: ExpressionEvalHooks) => ExpressionValue;
+}
+/** Frozen, null-prototype builtin table. */
+export declare const EXPRESSION_BUILTINS: Readonly<Record<string, ExpressionBuiltin>>;
+/** The set of valid builtin names — used by the parser to reject unknown
+ *  callees at parse time (immediate author feedback). */
+export declare const EXPRESSION_BUILTIN_NAMES: ReadonlySet<string>;

package/dist/expression/compile.d.ts

@@ -0,0 +1,17 @@
+import { type ParsedExpression } from './parser.js';
+export type CompileResult = {
+    readonly ok: true;
+    readonly parsed: ParsedExpression;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+/** Compile `source` to a `ParsedExpression`, throwing `ExpressionParseError`
+ *  on failure. LRU/negative-cached. */
+export declare function compileExpression(source: string): ParsedExpression;
+/** Compile `source`, returning a discriminated result instead of throwing.
+ *  Used by read paths that must degrade rather than raise. LRU/negative-cached. */
+export declare function compileExpressionSafe(source: string): CompileResult;
+/** Test-only: clear the module-level cache. Not part of the public engine
+ *  surface — used to make cache-behaviour assertions deterministic. */
+export declare function __clearExpressionCompileCache(): void;

package/dist/expression/errors.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Error types for the safe expression engine. Two distinct classes so callers
+ * can tell a compile-time (grammar) failure from a runtime (evaluation)
+ * failure — both are non-fatal to the host: read paths degrade to "skip link".
+ */
+/** Thrown by the tokenizer / parser. Carries a 0-based source `position` when
+ *  the failure is anchored to a character (author-facing inline feedback). */
+export declare class ExpressionParseError extends Error {
+    readonly position?: number;
+    constructor(message: string, position?: number);
+}
+/** Thrown by the evaluator (unknown identifier, type mismatch, non-finite
+ *  result, unknown builtin, step-budget exceeded). */
+export declare class ExpressionEvalError extends Error {
+    constructor(message: string);
+}