@camstack/types 0.1.40 → 0.1.42

package/dist/capabilities/numeric-sensor.cap.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Generic numeric sensor — last-resort fallback when no typed numeric
+ * cap fits (HA `sensor` whose `device_class` we don't have a typed cap
+ * for: water flow, distance, weight, frequency, signal strength, …).
+ *
+ * The `unit` and `precision` fields carry the live display metadata that
+ * the upstream source provides with each state push (HA
+ * `attributes.unit_of_measurement` / `attributes.suggested_display_precision`).
+ * The UI reads them directly from the slice — they are the single source
+ * of truth for generic numeric rendering and do NOT live on `sourceInfo`.
+ *
+ * Prefer the typed alternatives (`temperature-sensor`, `humidity-sensor`,
+ * `ambient-light-sensor`, `pressure-sensor`, `power-meter`,
+ * `air-quality-sensor`, `battery`) when the metric matches — export
+ * adapters render those with the right service / category. Generic
+ * numeric values land here.
+ */
+export declare const NumericSensorStatusSchema: z.ZodObject<{
+    value: z.ZodNumber;
+    unit: z.ZodOptional<z.ZodString>;
+    precision: z.ZodOptional<z.ZodNumber>;
+    lastFetchedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type NumericSensorStatus = z.infer<typeof NumericSensorStatusSchema>;
+export declare const numericSensorCapability: {
+    readonly name: "numeric-sensor";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Sensor];
+    readonly methods: {};
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            value: z.ZodNumber;
+            unit: z.ZodOptional<z.ZodString>;
+            precision: z.ZodOptional<z.ZodNumber>;
+            lastFetchedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    readonly runtimeState: z.ZodObject<{
+        value: z.ZodNumber;
+        unit: z.ZodOptional<z.ZodString>;
+        precision: z.ZodOptional<z.ZodNumber>;
+        lastFetchedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type INumericSensorProvider = InferProvider<typeof numericSensorCapability>;
+//# sourceMappingURL=numeric-sensor.cap.d.ts.map

package/dist/capabilities/numeric-sensor.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric-sensor.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/numeric-sensor.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,yBAAyB;;;;;iBAYpC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;CAYK,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}

package/dist/capabilities/osd.cap.d.ts

@@ -102,6 +102,7 @@ declare const OsdOverlayPatchSchema: z.ZodObject<{
 export declare const osdCapability: {
     readonly name: "osd";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly deviceTypes: readonly [DeviceType.Camera];
     readonly methods: {

package/dist/capabilities/osd.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"osd.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/osd.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;GAMG;AAEH,eAAO,MAAM,kBAAkB;;;;EAA6C,CAAA;AAC5E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE/D,eAAO,MAAM,eAAe;;;;;;;;EAI1B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEzD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgB3B,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAE1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEvD,QAAA,MAAM,qBAAqB;;;;;;;;;;;;iBAIf,CAAA;AAEZ,eAAO,MAAM,aAAa;;;;;;QAMtB;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDkC,CAAA;AAEzC,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC,OAAO,aAAa,CAAC,CAAA;AAC9D,OAAO,EAAE,qBAAqB,EAAE,CAAA"}
+{"version":3,"file":"osd.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/osd.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;GAMG;AAEH,eAAO,MAAM,kBAAkB;;;;EAA6C,CAAA;AAC5E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE/D,eAAO,MAAM,eAAe;;;;;;;;EAI1B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEzD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgB3B,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAE1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEvD,QAAA,MAAM,qBAAqB;;;;;;;;;;;;iBAIf,CAAA;AAEZ,eAAO,MAAM,aAAa;;;;;;;QAOtB;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDkC,CAAA;AAEzC,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC,OAAO,aAAa,CAAC,CAAA;AAC9D,OAAO,EAAE,qBAAqB,EAAE,CAAA"}

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

@@ -87,7 +87,7 @@ export type Track = z.infer<typeof TrackSchema>;
 declare const MotionEventSchema: z.ZodObject<{
     kind: z.ZodLiteral<"motion">;
     regionCount: z.ZodNumber;
-    regions: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    regions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
         bbox: z.ZodObject<{
             x: z.ZodNumber;
             y: z.ZodNumber;
@@ -96,9 +96,10 @@ declare const MotionEventSchema: z.ZodObject<{
         }, z.core.$strip>;
         pixelCount: z.ZodNumber;
         intensity: z.ZodNumber;
-    }, z.core.$strip>>>;
-    frameWidth: z.ZodNumber;
-    frameHeight: z.ZodNumber;
+    }, z.core.$strip>>>>;
+    frameWidth: z.ZodOptional<z.ZodNumber>;
+    frameHeight: z.ZodOptional<z.ZodNumber>;
+    mediaUrl: z.ZodOptional<z.ZodString>;
     id: z.ZodString;
     deviceId: z.ZodNumber;
     timestamp: z.ZodNumber;
@@ -106,25 +107,26 @@ declare const MotionEventSchema: z.ZodObject<{
 export type MotionEvent = z.infer<typeof MotionEventSchema>;
 declare const ObjectEventSchema: z.ZodObject<{
     kind: z.ZodLiteral<"object">;
-    trackId: z.ZodString;
+    trackId: z.ZodOptional<z.ZodString>;
     className: z.ZodString;
     label: z.ZodOptional<z.ZodString>;
-    confidence: z.ZodNumber;
-    bbox: z.ZodObject<{
+    confidence: z.ZodOptional<z.ZodNumber>;
+    bbox: z.ZodOptional<z.ZodObject<{
         x: z.ZodNumber;
         y: z.ZodNumber;
         w: z.ZodNumber;
         h: z.ZodNumber;
-    }, z.core.$strip>;
-    zones: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-    state: z.ZodEnum<{
+    }, z.core.$strip>>;
+    zones: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    state: z.ZodOptional<z.ZodEnum<{
         moving: "moving";
         left: "left";
         idle: "idle";
         new: "new";
         entered: "entered";
-    }>;
+    }>>;
     mediaKey: z.ZodOptional<z.ZodString>;
+    mediaUrl: z.ZodOptional<z.ZodString>;
     id: z.ZodString;
     deviceId: z.ZodNumber;
     timestamp: z.ZodNumber;
@@ -139,6 +141,7 @@ declare const AudioEventSchema: z.ZodObject<{
         originalClass: z.ZodOptional<z.ZodString>;
         score: z.ZodNumber;
     }, z.core.$strip>>;
+    mediaUrl: z.ZodOptional<z.ZodString>;
     id: z.ZodString;
     deviceId: z.ZodNumber;
     timestamp: z.ZodNumber;
@@ -337,10 +340,14 @@ export declare const pipelineAnalyticsCapability: {
             since: z.ZodOptional<z.ZodNumber>;
             until: z.ZodOptional<z.ZodNumber>;
             limit: z.ZodDefault<z.ZodNumber>;
+            projection: z.ZodOptional<z.ZodEnum<{
+                full: "full";
+                slim: "slim";
+            }>>;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             kind: z.ZodLiteral<"motion">;
             regionCount: z.ZodNumber;
-            regions: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            regions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
                 bbox: z.ZodObject<{
                     x: z.ZodNumber;
                     y: z.ZodNumber;
@@ -349,9 +356,10 @@ export declare const pipelineAnalyticsCapability: {
                 }, z.core.$strip>;
                 pixelCount: z.ZodNumber;
                 intensity: z.ZodNumber;
-            }, z.core.$strip>>>;
-            frameWidth: z.ZodNumber;
-            frameHeight: z.ZodNumber;
+            }, z.core.$strip>>>>;
+            frameWidth: z.ZodOptional<z.ZodNumber>;
+            frameHeight: z.ZodOptional<z.ZodNumber>;
+            mediaUrl: z.ZodOptional<z.ZodString>;
             id: z.ZodString;
             deviceId: z.ZodNumber;
             timestamp: z.ZodNumber;
@@ -361,28 +369,33 @@ export declare const pipelineAnalyticsCapability: {
             since: z.ZodOptional<z.ZodNumber>;
             until: z.ZodOptional<z.ZodNumber>;
             limit: z.ZodDefault<z.ZodNumber>;
+            projection: z.ZodOptional<z.ZodEnum<{
+                full: "full";
+                slim: "slim";
+            }>>;
             classFilter: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             kind: z.ZodLiteral<"object">;
-            trackId: z.ZodString;
+            trackId: z.ZodOptional<z.ZodString>;
             className: z.ZodString;
             label: z.ZodOptional<z.ZodString>;
-            confidence: z.ZodNumber;
-            bbox: z.ZodObject<{
+            confidence: z.ZodOptional<z.ZodNumber>;
+            bbox: z.ZodOptional<z.ZodObject<{
                 x: z.ZodNumber;
                 y: z.ZodNumber;
                 w: z.ZodNumber;
                 h: z.ZodNumber;
-            }, z.core.$strip>;
-            zones: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-            state: z.ZodEnum<{
+            }, z.core.$strip>>;
+            zones: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            state: z.ZodOptional<z.ZodEnum<{
                 moving: "moving";
                 left: "left";
                 idle: "idle";
                 new: "new";
                 entered: "entered";
-            }>;
+            }>>;
             mediaKey: z.ZodOptional<z.ZodString>;
+            mediaUrl: z.ZodOptional<z.ZodString>;
             id: z.ZodString;
             deviceId: z.ZodNumber;
             timestamp: z.ZodNumber;
@@ -392,6 +405,10 @@ export declare const pipelineAnalyticsCapability: {
             since: z.ZodOptional<z.ZodNumber>;
             until: z.ZodOptional<z.ZodNumber>;
             limit: z.ZodDefault<z.ZodNumber>;
+            projection: z.ZodOptional<z.ZodEnum<{
+                full: "full";
+                slim: "slim";
+            }>>;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             kind: z.ZodLiteral<"audio">;
             rms: z.ZodNumber;
@@ -401,10 +418,40 @@ export declare const pipelineAnalyticsCapability: {
                 originalClass: z.ZodOptional<z.ZodString>;
                 score: z.ZodNumber;
             }, z.core.$strip>>;
+            mediaUrl: z.ZodOptional<z.ZodString>;
             id: z.ZodString;
             deviceId: z.ZodNumber;
             timestamp: z.ZodNumber;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Server-side bucketed event counts for the 24-hour timeline.
+         *  Returns one entry per non-empty bucket; empty buckets are omitted. */
+        readonly getEventDensity: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            since: z.ZodNumber;
+            until: z.ZodNumber;
+            bucketMs: z.ZodNumber;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            bucketStart: z.ZodNumber;
+            motion: z.ZodNumber;
+            object: z.ZodNumber;
+            audio: z.ZodNumber;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Delete all events (motion + object + audio) for the given device
+         * that are older than `cutoffMs` (exclusive), and delete their
+         * thumbnails in lockstep. Returns per-kind deleted counts.
+         *
+         * Called by Phase B3 recorder orchestration to keep event history
+         * aligned with available footage.
+         */
+        readonly pruneEventsBefore: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            cutoffMs: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            motion: z.ZodNumber;
+            object: z.ZodNumber;
+            audio: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
         readonly getEventMedia: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             eventId: z.ZodString;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{

package/dist/capabilities/pipeline-analytics.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline-analytics.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/pipeline-analytics.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAGrD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,QAAA,MAAM,gBAAgB;;;;;;EAAuD,CAAA;AAC7E,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,QAAA,MAAM,eAAe;;;;EAAwC,CAAA;AAC7D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAkBvD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBf,CAAA;AACF,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAc/C,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;iBAWrB,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;iBAYrB,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,QAAA,MAAM,gBAAgB;;;;;;;;;;;;iBAUpB,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAIzD,QAAA,MAAM,eAAe;;;;;;;;;;iBAMnB,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AA6BvD,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;iBAO1B,CAAA;AAIF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkBpC;;6CAEqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAyCrC;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAUH,+CAA+C;;;;;;;;QAQ/C,wDAAwD;;;;;;;;;QASxD,kEAAkE;;;;;;;;;;;;;;CAU7B,CAAA;AAEzC,MAAM,MAAM,0BAA0B,GAAG,aAAa,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAE1F,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,sBAAsB,GACvB,CAAA"}
+{"version":3,"file":"pipeline-analytics.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/pipeline-analytics.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAGrD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,QAAA,MAAM,gBAAgB;;;;;;EAAuD,CAAA;AAC7E,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,QAAA,MAAM,eAAe;;;;EAAwC,CAAA;AAC7D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAkBvD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBf,CAAA;AACF,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAc/C,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;iBAgBrB,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBrB,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;iBAYpB,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAIzD,QAAA,MAAM,eAAe;;;;;;;;;;iBAMnB,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAkCvD,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;iBAO1B,CAAA;AAIF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkBpC;;6CAEqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA+BrC;iFACyE;;;;;;;;;;;;QAiBzE;;;;;;;WAOG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkBH;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAUH,+CAA+C;;;;;;;;QAQ/C,wDAAwD;;;;;;;;;QASxD,kEAAkE;;;;;;;;;;;;;;CAU7B,CAAA;AAEzC,MAAM,MAAM,0BAA0B,GAAG,aAAa,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAE1F,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,sBAAsB,GACvB,CAAA"}

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

@@ -715,8 +715,8 @@ export declare const pipelineExecutorCapability: {
          * calls. Single root step + uniform model assumed; trees with crop
          * children fall back to sequential execution.
          *
-         * Used by `scripts/bench-scrypted-style.mts` to mirror Scrypted's
-         * `detectObjects(media, {batch})` semantics for fair comparison.
+         * Used by `scripts/bench-batch-style.mts` for batch benchmarking —
+         * N frames in one call to amortise per-call IPC overhead.
          */
         readonly runPipelineBatch: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             engine: z.ZodOptional<z.ZodObject<{

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

@@ -308,8 +308,8 @@ export declare const pipelineOrchestratorCapability: {
             droppedFrames: z.ZodNumber;
             phase: z.ZodEnum<{
                 idle: "idle";
-                watching: "watching";
                 active: "active";
+                watching: "watching";
             }>;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** Read the capability binding map for one node. Empty record = no overrides (first-registered wins). */

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

@@ -363,8 +363,8 @@ export declare const pipelineRunnerCapability: {
             droppedFrames: z.ZodNumber;
             phase: z.ZodEnum<{
                 idle: "idle";
-                watching: "watching";
                 active: "active";
+                watching: "watching";
             }>;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** All per-camera metrics in one round-trip. */
@@ -381,8 +381,8 @@ export declare const pipelineRunnerCapability: {
             droppedFrames: z.ZodNumber;
             phase: z.ZodEnum<{
                 idle: "idle";
-                watching: "watching";
                 active: "active";
+                watching: "watching";
             }>;
             deviceId: z.ZodNumber;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;

package/dist/capabilities/platform-probe.cap.d.ts

@@ -108,6 +108,19 @@ declare const HardwareEncodersSchema: z.ZodObject<{
     probedAt: z.ZodNumber;
 }, z.core.$strip>;
 export type HardwareEncoders = z.infer<typeof HardwareEncodersSchema>;
+/**
+ * Decode-side companion to {@link HardwareEncodersSchema}: the `-hwaccel`
+ * methods the configured ffmpeg binary actually supports (parsed from
+ * `ffmpeg -hwaccels`). Used to gate decode-hwaccel attempts so the transcode
+ * egress never spends a spawn on a backend this build cannot offer. Per-stream
+ * decode fragility (e.g. VideoToolbox HEVC) is still handled by the egress's
+ * software fallback — this only filters out wholly-unsupported backends.
+ */
+declare const HardwareDecodeAccelsSchema: z.ZodObject<{
+    methods: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    probedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type HardwareDecodeAccels = z.infer<typeof HardwareDecodeAccelsSchema>;
 export declare const platformProbeCapability: {
     readonly name: "platform-probe";
     readonly scope: "system";
@@ -380,6 +393,18 @@ export declare const platformProbeCapability: {
             }>;
             probedAt: z.ZodNumber;
         }, z.core.$strip>, "mutation">;
+        /**
+         * Decode-side hw-accel probe — the `-hwaccel` methods the configured ffmpeg
+         * binary supports (via `ffmpeg -hwaccels`). Cached after first call.
+         */
+        readonly getHardwareDecodeAccels: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            methods: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            probedAt: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly refreshHardwareDecodeAccels: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            methods: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            probedAt: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
     };
 };
 export type IPlatformProbeProvider = InferProvider<typeof platformProbeCapability>;

package/dist/capabilities/platform-probe.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"platform-probe.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/platform-probe.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAgBlG,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;EAa3B,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM9B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK1B,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AA0DrE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAehC;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQkC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}
+{"version":3,"file":"platform-probe.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/platform-probe.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAgBlG,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;EAa3B,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM9B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK1B,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE;;;;;;;GAOG;AACH,QAAA,MAAM,0BAA0B;;;iBAG9B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AA0D7E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAehC;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAOH;;;WAGG;;;;;;;;;;CAQkC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}

package/dist/capabilities/power-meter.cap.d.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Multi-metric electrical meter. One slice can carry any combination
+ * of instantaneous power (W), cumulative energy (kWh), voltage (V),
+ * and current (A) — all fields optional so a single-metric source
+ * (HA `sensor` with `device_class: power`) populates only what it
+ * has and aggregators (energy dashboards, billing exports) compose
+ * across providers without needing one cap per metric.
+ *
+ * Trade-off acknowledged: a HomeKit export that wants to surface
+ * "power" and "energy" as separate services has to crack open the
+ * slice and emit two characteristics from one cap. Worth it to avoid
+ * exploding the cap catalog with `power-w` / `energy-kwh` /
+ * `voltage-v` / `current-a` quartets that always travel together
+ * in real-world devices.
+ */
+export declare const PowerMeterStatusSchema: z.ZodObject<{
+    watts: z.ZodOptional<z.ZodNumber>;
+    kwhTotal: z.ZodOptional<z.ZodNumber>;
+    volts: z.ZodOptional<z.ZodNumber>;
+    amps: z.ZodOptional<z.ZodNumber>;
+    va: z.ZodOptional<z.ZodNumber>;
+    powerFactor: z.ZodOptional<z.ZodNumber>;
+    lastFetchedAt: z.ZodNumber;
+    unit: z.ZodOptional<z.ZodString>;
+    precision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PowerMeterStatus = z.infer<typeof PowerMeterStatusSchema>;
+export declare const powerMeterCapability: {
+    readonly name: "power-meter";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Sensor];
+    readonly methods: {};
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            watts: z.ZodOptional<z.ZodNumber>;
+            kwhTotal: z.ZodOptional<z.ZodNumber>;
+            volts: z.ZodOptional<z.ZodNumber>;
+            amps: z.ZodOptional<z.ZodNumber>;
+            va: z.ZodOptional<z.ZodNumber>;
+            powerFactor: z.ZodOptional<z.ZodNumber>;
+            lastFetchedAt: z.ZodNumber;
+            unit: z.ZodOptional<z.ZodString>;
+            precision: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    readonly runtimeState: z.ZodObject<{
+        watts: z.ZodOptional<z.ZodNumber>;
+        kwhTotal: z.ZodOptional<z.ZodNumber>;
+        volts: z.ZodOptional<z.ZodNumber>;
+        amps: z.ZodOptional<z.ZodNumber>;
+        va: z.ZodOptional<z.ZodNumber>;
+        powerFactor: z.ZodOptional<z.ZodNumber>;
+        lastFetchedAt: z.ZodNumber;
+        unit: z.ZodOptional<z.ZodString>;
+        precision: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+};
+export type IPowerMeterProvider = InferProvider<typeof powerMeterCapability>;
+//# sourceMappingURL=power-meter.cap.d.ts.map

package/dist/capabilities/power-meter.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"power-meter.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/power-meter.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;iBA0BjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYQ,CAAA;AAEzC,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/dist/capabilities/presence.cap.d.ts

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Presence cap. Models HA `person.*` and `device_tracker.*` entities
+ * on `DeviceType.Presence`. Read-only — no setters: presence is
+ * derived from upstream signals (mobile-app location, router DHCP
+ * lease, Bluetooth beacon, manual zone change) and pushed into the
+ * slice.
+ *
+ * `state` follows HA's canonical values — `home` / `not_home` /
+ * `<zone-name>` for any other named zone. The zone name is freeform
+ * because users define arbitrary zones (`work`, `gym`, `school`).
+ *
+ * GPS coordinates are nullable — tracker types without location
+ * (Bluetooth scanner, MQTT presence) omit them. The presence of
+ * GPS data is signaled by `DeviceFeature.PresenceGps` for fast
+ * UI map-pin rendering.
+ */
+declare const GpsLocationSchema: z.ZodObject<{
+    latitude: z.ZodNumber;
+    longitude: z.ZodNumber;
+    accuracyMeters: z.ZodNumber;
+}, z.core.$strip>;
+export type GpsLocation = z.infer<typeof GpsLocationSchema>;
+export declare const PresenceStatusSchema: z.ZodObject<{
+    state: z.ZodString;
+    location: z.ZodNullable<z.ZodString>;
+    gps: z.ZodNullable<z.ZodObject<{
+        latitude: z.ZodNumber;
+        longitude: z.ZodNumber;
+        accuracyMeters: z.ZodNumber;
+    }, z.core.$strip>>;
+    batteryPercent: z.ZodNullable<z.ZodNumber>;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type PresenceStatus = z.infer<typeof PresenceStatusSchema>;
+export declare const presenceCapability: {
+    readonly name: "presence";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Presence];
+    readonly methods: {};
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            state: z.ZodString;
+            location: z.ZodNullable<z.ZodString>;
+            gps: z.ZodNullable<z.ZodObject<{
+                latitude: z.ZodNumber;
+                longitude: z.ZodNumber;
+                accuracyMeters: z.ZodNumber;
+            }, z.core.$strip>>;
+            batteryPercent: z.ZodNullable<z.ZodNumber>;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    /**
+     * Runtime-state slice — mirrored by the kernel. UI presence card
+     * reads `state` + `location` for the text label; iff `gps !== null`
+     * the map pin is rendered (use `DeviceFeature.PresenceGps` for the
+     * pre-fetch fast-path check).
+     */
+    readonly runtimeState: z.ZodObject<{
+        state: z.ZodString;
+        location: z.ZodNullable<z.ZodString>;
+        gps: z.ZodNullable<z.ZodObject<{
+            latitude: z.ZodNumber;
+            longitude: z.ZodNumber;
+            accuracyMeters: z.ZodNumber;
+        }, z.core.$strip>>;
+        batteryPercent: z.ZodNullable<z.ZodNumber>;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IPresenceProvider = InferProvider<typeof presenceCapability>;
+export {};
+//# sourceMappingURL=presence.cap.d.ts.map

package/dist/capabilities/presence.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presence.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/presence.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;;;GAeG;AAEH,QAAA,MAAM,iBAAiB;;;;iBAOrB,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,oBAAoB;;;;;;;;;;iBAa/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;IAW7B;;;;;OAKG;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/capabilities/pressure-sensor.cap.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Atmospheric pressure reading in hectopascals. Drives Home Assistant
+ * `sensor` entries with `device_class: pressure`.
+ *
+ * Unit normalisation: hPa. The canonical display unit (`hPa`) is a
+ * descriptor constant in the UI (ROLE_DESCRIPTOR), not stored in
+ * `sourceInfo`.
+ */
+export declare const PressureSensorStatusSchema: z.ZodObject<{
+    hpa: z.ZodNumber;
+    lastFetchedAt: z.ZodNumber;
+    unit: z.ZodOptional<z.ZodString>;
+    precision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PressureSensorStatus = z.infer<typeof PressureSensorStatusSchema>;
+export declare const pressureSensorCapability: {
+    readonly name: "pressure-sensor";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Sensor];
+    readonly methods: {};
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            hpa: z.ZodNumber;
+            lastFetchedAt: z.ZodNumber;
+            unit: z.ZodOptional<z.ZodString>;
+            precision: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    readonly runtimeState: z.ZodObject<{
+        hpa: z.ZodNumber;
+        lastFetchedAt: z.ZodNumber;
+        unit: z.ZodOptional<z.ZodString>;
+        precision: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+};
+export type IPressureSensorProvider = InferProvider<typeof pressureSensorCapability>;
+//# sourceMappingURL=pressure-sensor.cap.d.ts.map

package/dist/capabilities/pressure-sensor.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pressure-sensor.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/pressure-sensor.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B;;;;;iBAcrC,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;CAYI,CAAA;AAEzC,MAAM,MAAM,uBAAuB,GAAG,aAAa,CAAC,OAAO,wBAAwB,CAAC,CAAA"}

package/dist/capabilities/privacy-mask.cap.d.ts

@@ -106,6 +106,7 @@ export type PrivacyMaskPatch = z.infer<typeof PrivacyMaskPatchSchema>;
 export declare const privacyMaskCapability: {
     readonly name: "privacy-mask";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly deviceTypes: readonly [DeviceType.Camera];
     readonly deviceConfig: {

package/dist/capabilities/privacy-mask.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"privacy-mask.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/privacy-mask.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AACxG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAQrD;;;;;;;GAOG;AAEH,oEAAoE;AACpE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;2BAGjC,CAAA;AAEF,kCAAkC;AAClC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;iBAMlC,CAAA;AAEF,oEAAoE;AACpE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;iBAKlC,CAAA;AAEF,+BAA+B;AAC/B,eAAO,MAAM,wBAAwB;;;;;;;;;;;;iBAOnC,CAAA;AAEF,6CAA6C;AAC7C,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;iBAGjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACvE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACvE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBO,CAAA;AAEzC,MAAM,MAAM,oBAAoB,GAAG,mBAAmB,CAAC,OAAO,qBAAqB,CAAC,CAAA"}
+{"version":3,"file":"privacy-mask.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/privacy-mask.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AACxG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAQrD;;;;;;;GAOG;AAEH,oEAAoE;AACpE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;2BAGjC,CAAA;AAEF,kCAAkC;AAClC,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;iBAMlC,CAAA;AAEF,oEAAoE;AACpE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;iBAKlC,CAAA;AAEF,+BAA+B;AAC/B,eAAO,MAAM,wBAAwB;;;;;;;;;;;;iBAOnC,CAAA;AAEF,6CAA6C;AAC7C,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;iBAGjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACvE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACvE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBO,CAAA;AAEzC,MAAM,MAAM,oBAAoB,GAAG,mBAAmB,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

package/dist/capabilities/ptz-autotrack.cap.d.ts

@@ -64,6 +64,7 @@ export type PtzAutotrackRuntimeState = z.infer<typeof PtzAutotrackRuntimeStateSc
 export declare const ptzAutotrackCapability: {
     readonly name: "ptz-autotrack";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly deviceTypes: readonly [DeviceType.Camera];
     readonly deviceConfig: {

package/dist/capabilities/ptz-autotrack.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ptz-autotrack.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/ptz-autotrack.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAwCrD,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,8BAA8B;;;iBAGzC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAErF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;iBAkBnC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;iBAGzC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAErF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;QAS/B;;;;WAIG;;;;;;;;;;;;;;;;QAKH;;;;WAIG;;;;;QAMH;;;;;;WAMG;;;;;;;;QAKH;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoBL;;;;;;;OAOG;;;;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA"}
+{"version":3,"file":"ptz-autotrack.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/ptz-autotrack.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAwCrD,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,8BAA8B;;;iBAGzC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAErF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;iBAkBnC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;iBAGzC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAErF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;QAU/B;;;;WAIG;;;;;;;;;;;;;;;;QAKH;;;;WAIG;;;;;QAMH;;;;;;WAMG;;;;;;;;QAKH;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoBL;;;;;;;OAOG;;;;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

package/dist/capabilities/ptz.cap.d.ts

@@ -37,6 +37,7 @@ declare const PtzOptionsSchema: z.ZodObject<{
 export declare const ptzCapability: {
     readonly name: "ptz";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly deviceTypes: readonly [DeviceType.Camera];
     readonly deviceConfig: {

package/dist/capabilities/ptz.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ptz.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/ptz.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD,QAAA,MAAM,eAAe;;;iBAAiD,CAAA;AACtE,QAAA,MAAM,iBAAiB;;;;iBAAoE,CAAA;AAC3F,QAAA,MAAM,oBAAoB;;;;;iBAKxB,CAAA;AAEF;;2DAE2D;AAC3D,QAAA,MAAM,eAAe;;;;;iBAAuD,CAAA;AAE5E,8DAA8D;AAC9D,QAAA,MAAM,gBAAgB;;;;;;;iBAUpB,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoDtB;;;;;WAKG;;;;;;;;QAKH;mDAC2C;;;;;;;;;;;;;;;CAWN,CAAA;AAEzC,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC,OAAO,aAAa,CAAC,CAAA;AAC9D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACzD,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AACvD,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,eAAe,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,CAAA"}
+{"version":3,"file":"ptz.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/ptz.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD,QAAA,MAAM,eAAe;;;iBAAiD,CAAA;AACtE,QAAA,MAAM,iBAAiB;;;;iBAAoE,CAAA;AAC3F,QAAA,MAAM,oBAAoB;;;;;iBAKxB,CAAA;AAEF;;2DAE2D;AAC3D,QAAA,MAAM,eAAe;;;;;iBAAuD,CAAA;AAE5E,8DAA8D;AAC9D,QAAA,MAAM,gBAAgB;;;;;;;iBAUpB,CAAA;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAqDtB;;;;;WAKG;;;;;;;;QAKH;mDAC2C;;;;;;;;;;;;;;;CAWN,CAAA;AAEzC,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC,OAAO,aAAa,CAAC,CAAA;AAC9D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACzD,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AACvD,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,eAAe,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,CAAA"}

package/dist/capabilities/reboot.cap.d.ts

@@ -18,6 +18,7 @@ import { DeviceType } from '../device/device-type.js';
 export declare const rebootCapability: {
     readonly name: "reboot";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly deviceTypes: readonly [DeviceType.Camera, DeviceType.Sensor, DeviceType.Switch];
     readonly methods: {

package/dist/capabilities/reboot.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reboot.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/reboot.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;CAYY,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA"}
+{"version":3,"file":"reboot.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/reboot.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;CAaY,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA"}