@camstack/types 0.1.39 → 0.1.41

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

@@ -142,6 +142,7 @@ declare const RunnerCameraConfigSchema: z.ZodObject<{
         }, z.core.$strip>>>;
         color: z.ZodDefault<z.ZodString>;
     }, z.core.$strip>>>>;
+    onboardMotionDrivesAnalyzer: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 /**
  * Per-device settings UI fields the runner cap owns. Co-located with
@@ -279,6 +280,7 @@ export declare const pipelineRunnerCapability: {
                 }, z.core.$strip>>>;
                 color: z.ZodDefault<z.ZodString>;
             }, z.core.$strip>>>>;
+            onboardMotionDrivesAnalyzer: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strip>, z.ZodObject<{
             success: z.ZodLiteral<true>;
         }, z.core.$strip>, "mutation">;
@@ -361,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. */
@@ -379,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/pipeline-runner.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline-runner.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/pipeline-runner.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAKlG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAY7D;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB;;;EAAkC,CAAA;AAC/D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE3D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB;;;GAA4B,CAAA;AAC5D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;iBAKlC,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6D5B,CAAA;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS,WAAW,EA2DnD,CAAA;AAEV;;;;GAIG;AACH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;iBAmBzB,CAAA;AAEF;;;;GAIG;AACH,QAAA,MAAM,wBAAwB;;;;;;iBAM5B,CAAA;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB;;;;;QAMjC,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAElE,sEAAsE;;;;;;QAEtE;;;;;;;;;;;;;;WAcG;;;;;;;;;;;;;;;;;;;;;QAQH,oEAAoE;;;;;;;;;;;;;;QAEpE,iEAAiE;;;;;;;;QAEjE,8DAA8D;;;;;;;;;;;;;;;;;;;;QAE9D,gDAAgD;;;;;;;;;;;;;;;;;;;QAEhD,4DAA4D;;;CASvB,CAAA;AAEzC,MAAM,MAAM,uBAAuB,GAAG,aAAa,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEpF,OAAO,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,CAAA"}
+{"version":3,"file":"pipeline-runner.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/pipeline-runner.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAKlG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAY7D;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB;;;EAAkC,CAAA;AAC/D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE3D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB;;;GAA4B,CAAA;AAC5D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;iBAKlC,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6E5B,CAAA;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS,WAAW,EAqEnD,CAAA;AAEV;;;;GAIG;AACH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;iBAmBzB,CAAA;AAEF;;;;GAIG;AACH,QAAA,MAAM,wBAAwB;;;;;;iBAM5B,CAAA;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB;;;;;QAMjC,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAElE,sEAAsE;;;;;;QAEtE;;;;;;;;;;;;;;WAcG;;;;;;;;;;;;;;;;;;;;;QAQH,oEAAoE;;;;;;;;;;;;;;QAEpE,iEAAiE;;;;;;;;QAEjE,8DAA8D;;;;;;;;;;;;;;;;;;;;QAE9D,gDAAgD;;;;;;;;;;;;;;;;;;;QAEhD,4DAA4D;;;CASvB,CAAA;AAEzC,MAAM,MAAM,uBAAuB,GAAG,aAAa,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEpF,OAAO,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,CAAA"}

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"}