@camstack/types 0.1.40 → 0.1.41

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

@@ -1,43 +1,249 @@
 import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
-import { DeviceType } from '../device/device-type.js';
-declare const SegmentSchema: z.ZodObject<{
-    id: z.ZodString;
-    startTs: z.ZodNumber;
-    endTs: z.ZodNumber;
-    durationSec: z.ZodNumber;
-    sizeBytes: z.ZodOptional<z.ZodNumber>;
+export declare const RecordingStatusSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    enabled: z.ZodBoolean;
+    activeMode: z.ZodEnum<{
+        off: "off";
+        continuous: "continuous";
+    }>;
+    nodeId: z.ZodString;
+    storageBytes: z.ZodNumber;
 }, z.core.$strip>;
+export type RecordingStatus = z.infer<typeof RecordingStatusSchema>;
+export declare const RecordingRangeSchema: z.ZodObject<{
+    profile: z.ZodString;
+    startMs: z.ZodNumber;
+    endMs: z.ZodNumber;
+}, z.core.$strip>;
+export declare const RecordingAvailabilitySchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    ranges: z.ZodArray<z.ZodObject<{
+        profile: z.ZodString;
+        startMs: z.ZodNumber;
+        endMs: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RecordingAvailability = z.infer<typeof RecordingAvailabilitySchema>;
+export declare const RecordingManifestSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    localMasterPath: z.ZodNullable<z.ZodString>;
+    playbackUrl: z.ZodNullable<z.ZodString>;
+    playbackEndpoints: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type RecordingManifest = z.infer<typeof RecordingManifestSchema>;
+/** Recording storage usage for one camera (bytes on disk across all its
+ *  profiles/subtrees/locations on this node). */
+export declare const RecordingDeviceUsageSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    usedBytes: z.ZodNumber;
+}, z.core.$strip>;
+export type RecordingDeviceUsage = z.infer<typeof RecordingDeviceUsageSchema>;
+/** Recording storage usage + capacity for one storage location. */
+export declare const RecordingLocationUsageSchema: z.ZodObject<{
+    locationId: z.ZodNullable<z.ZodString>;
+    usedBytes: z.ZodNumber;
+    availableBytes: z.ZodNullable<z.ZodNumber>;
+    totalBytes: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type RecordingLocationUsage = z.infer<typeof RecordingLocationUsageSchema>;
+/** Aggregate recordings storage usage for a node: global total + per-camera +
+ *  per-location used/available. Stat-based (accurate even for detached cameras),
+ *  computed on demand — not from the name-only playback index. */
+export declare const RecordingStorageUsageSchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    totalUsedBytes: z.ZodNumber;
+    devices: z.ZodArray<z.ZodObject<{
+        deviceId: z.ZodNumber;
+        usedBytes: z.ZodNumber;
+    }, z.core.$strip>>;
+    locations: z.ZodArray<z.ZodObject<{
+        locationId: z.ZodNullable<z.ZodString>;
+        usedBytes: z.ZodNumber;
+        availableBytes: z.ZodNullable<z.ZodNumber>;
+        totalBytes: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RecordingStorageUsage = z.infer<typeof RecordingStorageUsageSchema>;
 export declare const recordingCapability: {
     readonly name: "recording";
-    readonly scope: "device";
+    readonly scope: "system";
     readonly mode: "singleton";
-    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly exposesDeviceSettings: true;
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            deviceId: z.ZodNumber;
+            enabled: z.ZodBoolean;
+            activeMode: z.ZodEnum<{
+                off: "off";
+                continuous: "continuous";
+            }>;
+            nodeId: z.ZodString;
+            storageBytes: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "command-driven";
+    };
     readonly methods: {
-        readonly getSegments: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            deviceId: z.ZodNumber;
-            from: z.ZodOptional<z.ZodNumber>;
-            to: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            startTs: z.ZodNumber;
-            endTs: z.ZodNumber;
-            durationSec: z.ZodNumber;
-            sizeBytes: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
-        readonly getPlaybackUrl: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            deviceId: z.ZodNumber;
-            segmentId: z.ZodString;
-        }, z.core.$strip>, z.ZodNullable<z.ZodString>, import("./capability-definition.js").CapabilityMethodKind>;
-        readonly getThumbnailAt: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            deviceId: z.ZodNumber;
-            timestamp: z.ZodNumber;
-        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
-            base64: z.ZodString;
-            contentType: z.ZodString;
-        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getAvailability: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            fromMs: z.ZodNumber;
+            toMs: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            deviceId: z.ZodNumber;
+            ranges: z.ZodArray<z.ZodObject<{
+                profile: z.ZodString;
+                startMs: z.ZodNumber;
+                endMs: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, "query">;
+        readonly getPlaybackManifest: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            fromMs: z.ZodNumber;
+            toMs: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            deviceId: z.ZodNumber;
+            localMasterPath: z.ZodNullable<z.ZodString>;
+            playbackUrl: z.ZodNullable<z.ZodString>;
+            playbackEndpoints: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, "query">;
+        readonly getStorageUsage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+            nodeId: z.ZodString;
+            totalUsedBytes: z.ZodNumber;
+            devices: z.ZodArray<z.ZodObject<{
+                deviceId: z.ZodNumber;
+                usedBytes: z.ZodNumber;
+            }, z.core.$strip>>;
+            locations: z.ZodArray<z.ZodObject<{
+                locationId: z.ZodNullable<z.ZodString>;
+                usedBytes: z.ZodNumber;
+                availableBytes: z.ZodNullable<z.ZodNumber>;
+                totalBytes: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, "query">;
+        readonly getDeviceConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            enabled: z.ZodBoolean;
+            profiles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                high: "high";
+                mid: "mid";
+                low: "low";
+            }>>>;
+            segmentSeconds: z.ZodOptional<z.ZodNumber>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"always">;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"timeOfDay">;
+                    start: z.ZodString;
+                    end: z.ZodString;
+                    days: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                }, z.core.$strip>], "kind">;
+                mode: z.ZodEnum<{
+                    onMotion: "onMotion";
+                    continuous: "continuous";
+                    onAudioThreshold: "onAudioThreshold";
+                }>;
+                preBufferSec: z.ZodDefault<z.ZodNumber>;
+                postBufferSec: z.ZodDefault<z.ZodNumber>;
+                resetTimeoutOnNewEvent: z.ZodDefault<z.ZodBoolean>;
+                thresholdDbfs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            retention: z.ZodOptional<z.ZodObject<{
+                maxAgeDays: z.ZodOptional<z.ZodNumber>;
+                maxSizeGb: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, "query">;
+        readonly setDeviceConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            config: z.ZodObject<{
+                enabled: z.ZodBoolean;
+                profiles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    high: "high";
+                    mid: "mid";
+                    low: "low";
+                }>>>;
+                segmentSeconds: z.ZodOptional<z.ZodNumber>;
+                rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"always">;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"timeOfDay">;
+                        start: z.ZodString;
+                        end: z.ZodString;
+                        days: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                    }, z.core.$strip>], "kind">;
+                    mode: z.ZodEnum<{
+                        onMotion: "onMotion";
+                        continuous: "continuous";
+                        onAudioThreshold: "onAudioThreshold";
+                    }>;
+                    preBufferSec: z.ZodDefault<z.ZodNumber>;
+                    postBufferSec: z.ZodDefault<z.ZodNumber>;
+                    resetTimeoutOnNewEvent: z.ZodDefault<z.ZodBoolean>;
+                    thresholdDbfs: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>>;
+                retention: z.ZodOptional<z.ZodObject<{
+                    maxAgeDays: z.ZodOptional<z.ZodNumber>;
+                    maxSizeGb: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            enabled: z.ZodBoolean;
+            profiles: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                high: "high";
+                mid: "mid";
+                low: "low";
+            }>>>;
+            segmentSeconds: z.ZodOptional<z.ZodNumber>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"always">;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"timeOfDay">;
+                    start: z.ZodString;
+                    end: z.ZodString;
+                    days: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                }, z.core.$strip>], "kind">;
+                mode: z.ZodEnum<{
+                    onMotion: "onMotion";
+                    continuous: "continuous";
+                    onAudioThreshold: "onAudioThreshold";
+                }>;
+                preBufferSec: z.ZodDefault<z.ZodNumber>;
+                postBufferSec: z.ZodDefault<z.ZodNumber>;
+                resetTimeoutOnNewEvent: z.ZodDefault<z.ZodBoolean>;
+                thresholdDbfs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            retention: z.ZodOptional<z.ZodObject<{
+                maxAgeDays: z.ZodOptional<z.ZodNumber>;
+                maxSizeGb: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, "mutation">;
+        /** Re-scan this device's footage from disk (stat sizes) and reseed the
+         *  index, then return the fresh status. */
+        readonly rescanStorage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            deviceId: z.ZodNumber;
+            enabled: z.ZodBoolean;
+            activeMode: z.ZodEnum<{
+                off: "off";
+                continuous: "continuous";
+            }>;
+            nodeId: z.ZodString;
+            storageBytes: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
+        /** Apply this device's retention policy to footage now; returns the oldest
+         *  surviving footage start (the retention floor) or null if no footage. */
+        readonly pruneFootage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            floorMs: z.ZodNullable<z.ZodNumber>;
+            deletedBuckets: z.ZodNumber;
+            reclaimedBytes: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
     };
 };
 export type IRecordingProvider = InferProvider<typeof recordingCapability>;
-export { SegmentSchema };
 //# sourceMappingURL=recording.cap.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"recording.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/recording.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,aAAa;;;;;;iBAMjB,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBS,CAAA;AAEzC,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC1E,OAAO,EAAE,aAAa,EAAE,CAAA"}
+{"version":3,"file":"recording.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/recording.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAGlG,eAAO,MAAM,qBAAqB;;;;;;;;;iBAMhC,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,eAAO,MAAM,oBAAoB;;;;iBAI/B,CAAA;AACF,eAAO,MAAM,2BAA2B;;;;;;;iBAGtC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAE/E,eAAO,MAAM,uBAAuB;;;;;iBAelC,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE;iDACiD;AACjD,eAAO,MAAM,0BAA0B;;;iBAGrC,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E,mEAAmE;AACnE,eAAO,MAAM,4BAA4B;;;;;iBASvC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEjF;;kEAEkE;AAClE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;iBAKtC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAE/E,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAmC5B;mDAC2C;;;;;;;;;;;;;QAM3C;mFAC2E;;;;;;;;;CAWtC,CAAA;AAEzC,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

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

@@ -5,8 +5,8 @@ declare const RegisteredStreamSchema: z.ZodObject<{
     label: z.ZodOptional<z.ZodString>;
     codec: z.ZodString;
     type: z.ZodEnum<{
-        audio: "audio";
         video: "video";
+        audio: "audio";
     }>;
     sourceUrl: z.ZodString;
 }, z.core.$strip>;
@@ -28,8 +28,8 @@ export declare const restreamerCapability: {
                 label: z.ZodOptional<z.ZodString>;
                 codec: z.ZodString;
                 type: z.ZodEnum<{
-                    audio: "audio";
                     video: "video";
+                    audio: "audio";
                 }>;
                 sourceUrl: z.ZodString;
             }, z.core.$strip>>>;

package/dist/capabilities/schemas/orchestrator-metrics.d.ts

@@ -19,8 +19,8 @@ export declare const CameraMetricsSchema: z.ZodObject<{
     droppedFrames: z.ZodNumber;
     phase: z.ZodEnum<{
         idle: "idle";
-        watching: "watching";
         active: "active";
+        watching: "watching";
     }>;
 }, z.core.$strip>;
 export declare const CameraMetricsWithDeviceIdSchema: z.ZodObject<{
@@ -36,8 +36,8 @@ export declare const CameraMetricsWithDeviceIdSchema: z.ZodObject<{
     droppedFrames: z.ZodNumber;
     phase: z.ZodEnum<{
         idle: "idle";
-        watching: "watching";
         active: "active";
+        watching: "watching";
     }>;
     deviceId: z.ZodNumber;
 }, z.core.$strip>;

package/dist/capabilities/schemas/streaming-shared.d.ts

@@ -14,6 +14,7 @@ export declare const CamStreamKindSchema: z.ZodEnum<{
     "pull-http": "pull-http";
     "pull-rfc4571": "pull-rfc4571";
     "push-annexb": "push-annexb";
+    derived: "derived";
 }>;
 export type CamStreamKind = z.infer<typeof CamStreamKindSchema>;
 export declare const CamStreamResolutionSchema: z.ZodObject<{
@@ -29,6 +30,7 @@ export declare const CameraStreamSchema: z.ZodObject<{
         "pull-http": "pull-http";
         "pull-rfc4571": "pull-rfc4571";
         "push-annexb": "push-annexb";
+        derived: "derived";
     }>;
     url: z.ZodOptional<z.ZodString>;
     codec: z.ZodOptional<z.ZodString>;
@@ -76,6 +78,39 @@ export declare const ProfileSlotSchema: z.ZodObject<{
     errorMessage: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ProfileSlot = z.infer<typeof ProfileSlotSchema>;
+/** The canonical consumer-facing broker id for a device profile. */
+export declare function makeProfileBrokerId(deviceId: number, profile: CamProfile): string;
+/**
+ * The broker id keying a physical SOURCE stream: `${deviceId}/${camStreamId}`.
+ * This is the broker's internal source key (`brokerIdFor` in the manager) — a
+ * `camStreamId` like `native:main` — as opposed to the public profile alias
+ * {@link makeProfileBrokerId}. Used to resolve a source's restream endpoint
+ * (e.g. routing a transcode's ffmpeg input through the broker so it rides the
+ * single source dial instead of opening a second camera connection).
+ */
+export declare function makeSourceBrokerId(deviceId: number, camStreamId: string): string;
+/**
+ * Inverse of {@link makeProfileBrokerId}. Returns `null` when the string is
+ * not a canonical `${deviceId}/${profile}` id — e.g. a broker-internal
+ * cam-stream id (`5/native:main`), a derived/adaptive ref, or a malformed
+ * value. So a caller can safely distinguish "addresses a public profile"
+ * from "addresses something broker-internal".
+ */
+export declare function parseProfileBrokerId(brokerId: string): {
+    deviceId: number;
+    profile: CamProfile;
+} | null;
+/**
+ * The profile slots worth consuming/recording: ASSIGNED only
+ * (`sourceCamStreamId != null`), DEDUPED by physical source so the same
+ * camera encoder is never subscribed/recorded twice, ordered high→mid→low.
+ * Optionally scoped to one `deviceId`. Pure; never mutates the input.
+ *
+ * Recording `main` and `mid` when both point at the same `sourceCamStreamId`
+ * would dial the camera's internal stream twice for no benefit — this is the
+ * dedup that prevents that.
+ */
+export declare function selectAssignedProfileSlots(slots: readonly ProfileSlot[], deviceId?: number): ProfileSlot[];
 /**
  * Zod schema for StreamSourceEntry — the canonical stream descriptor
  * exposed by ICameraDevice.getStreamSources() and consumed by the broker.
@@ -114,8 +149,8 @@ export declare const StreamSourceSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const EncodedPacketSchema: z.ZodObject<{
     type: z.ZodEnum<{
-        audio: "audio";
         video: "video";
+        audio: "audio";
     }>;
     data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
     pts: z.ZodNumber;
@@ -281,4 +316,32 @@ export declare const BrokerStatsSchema: z.ZodObject<{
         supported: z.ZodBoolean;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
+/**
+ * Exporter-facing "profile restream" entry. Returned by
+ * `cameraStreams.getProfileRtspEntries` — one per ASSIGNED profile slot
+ * (high/mid/low). `brokerId` is the PROFILE-keyed broker id
+ * (`${deviceId}/${profile}`, e.g. `15/high`); its `url` is a broker
+ * RTSP restream that aliases the profile's assigned source broker, so
+ * every consumer dialling a profile converges on the same single pull.
+ * `codec`/`resolution` describe the assigned SOURCE camStream (for the
+ * `auto` resolution-closest pick). Distinct from `RtspRestreamEntry`
+ * (raw per-camStream, live-view only).
+ */
+export declare const ProfileRtspEntrySchema: z.ZodObject<{
+    profile: z.ZodEnum<{
+        high: "high";
+        mid: "mid";
+        low: "low";
+    }>;
+    brokerId: z.ZodString;
+    url: z.ZodString;
+    mutedUrl: z.ZodString;
+    enabled: z.ZodBoolean;
+    codec: z.ZodOptional<z.ZodString>;
+    resolution: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ProfileRtspEntry = z.infer<typeof ProfileRtspEntrySchema>;
 //# sourceMappingURL=streaming-shared.d.ts.map

package/dist/capabilities/schemas/streaming-shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"streaming-shared.d.ts","sourceRoot":"","sources":["../../../src/capabilities/schemas/streaming-shared.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAE7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAWvB,eAAO,MAAM,gBAAgB;;;;EAAiC,CAAA;AAC9D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,oDAAoD;AACpD,eAAO,MAAM,iBAAiB,iCAAkC,CAAA;AAiBhE,eAAO,MAAM,mBAAmB;;;;;;EAM9B,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,yBAAyB;;;iBAGpC,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;iBA2C7B,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAS7D,eAAO,MAAM,uBAAuB;;;;;;EAMlC,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;iBAY5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;iBAUlC,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;iBAM7B,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;iBAO9B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;iBAM7B,CAAA;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;iBAW5B,CAAA;AAaF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB;;;;;EAA2C,CAAA;AAC/E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;iBAYrC,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E;;;;GAIG;AACH,eAAO,MAAM,2BAA2B;;;iBAKtC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAE/E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB;;;;;iBAKlC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE3E;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B;;;iBAI1C,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAEvF,sDAAsD;AACtD,eAAO,MAAM,gCAAgC;;iBAG3C,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAA;AAEzF,eAAO,MAAM,kBAAkB;;;;;;EAAkE,CAAA;AAEjG,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuC5B,CAAA"}
+{"version":3,"file":"streaming-shared.d.ts","sourceRoot":"","sources":["../../../src/capabilities/schemas/streaming-shared.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Script-runner cap. Models HA `script.*` entities on
+ * `DeviceType.Script`. A Script is a pre-recorded action sequence
+ * that can be invoked imperatively — optionally with a variables
+ * map when the script declares input fields.
+ *
+ * Variable-support is signalled by `DeviceFeature.ScriptVariables`
+ * so the UI gates a "with parameters" form without a slice fetch.
+ */
+export declare const ScriptRunnerStatusSchema: z.ZodObject<{
+    isRunning: z.ZodBoolean;
+    lastRunAt: z.ZodNumber;
+    lastRunSuccess: z.ZodNullable<z.ZodBoolean>;
+    lastError: z.ZodNullable<z.ZodString>;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type ScriptRunnerStatus = z.infer<typeof ScriptRunnerStatusSchema>;
+export declare const scriptRunnerCapability: {
+    readonly name: "script-runner";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Script];
+    readonly methods: {
+        readonly run: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Cancel a running script. Provider rejects when the script
+         *  isn't currently running. */
+        readonly stop: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            isRunning: z.ZodBoolean;
+            lastRunAt: z.ZodNumber;
+            lastRunSuccess: z.ZodNullable<z.ZodBoolean>;
+            lastError: z.ZodNullable<z.ZodString>;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    /**
+     * Runtime-state slice — mirrored by the kernel. UI script tile reads
+     * `isRunning` to render a spinner during execution and surfaces
+     * `lastError` / `lastRunSuccess` in the recent-runs panel.
+     */
+    readonly runtimeState: z.ZodObject<{
+        isRunning: z.ZodBoolean;
+        lastRunAt: z.ZodNumber;
+        lastRunSuccess: z.ZodNullable<z.ZodBoolean>;
+        lastError: z.ZodNullable<z.ZodString>;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IScriptRunnerProvider = InferProvider<typeof scriptRunnerCapability>;
+//# sourceMappingURL=script-runner.cap.d.ts.map

package/dist/capabilities/script-runner.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"script-runner.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/script-runner.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;;;;;;;;GAQG;AAEH,eAAO,MAAM,wBAAwB;;;;;;iBAanC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,eAAO,MAAM,sBAAsB;;;;;;;;;;;QAkB/B;uCAC+B;;;;;;;;;;;;;;;IAWjC;;;;OAIG;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

package/dist/capabilities/settings-store.cap.d.ts

@@ -147,6 +147,31 @@ export declare const settingsStoreCapability: {
                 offset: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
         }, z.core.$strip>, z.ZodNumber, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Grouped counts per ((field-origin)/bucketSize) bucket, filtered. */
+        readonly histogram: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            field: z.ZodString;
+            bucketSize: z.ZodNumber;
+            origin: z.ZodNumber;
+            filter: z.ZodOptional<z.ZodObject<{
+                where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                whereIn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnknown>>>;
+                whereBetween: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodTuple<[z.ZodUnknown, z.ZodUnknown], null>>>;
+                orderBy: z.ZodOptional<z.ZodObject<{
+                    field: z.ZodString;
+                    direction: z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>;
+                }, z.core.$strip>>;
+                limit: z.ZodOptional<z.ZodNumber>;
+                offset: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            bucket: z.ZodNumber;
+            count: z.ZodNumber;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** Check if a collection is empty. */
         readonly isEmpty: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             namespace: z.ZodOptional<z.ZodString>;

package/dist/capabilities/settings-store.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"settings-store.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/settings-store.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;GAEG;AACH,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;iBAUrB,CAAA;AAEF,8CAA8C;AAC9C,QAAA,MAAM,oBAAoB;;;iBAGxB,CAAA;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,sBAAsB;;;;;;;;;;;;iBAM1B,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;;iBAIzB,CAAA;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,uBAAuB;;;;;QAKhC,mDAAmD;;;;;;QAMnD,mDAAmD;;;;;;;QAOnD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;QAMnD,2BAA2B;;;;;;;;;QAO3B,uCAAuC;;;;;;;QAOvC,iCAAiC;;;;;;QAOjC,0DAA0D;;;;;;;;;;;;;;;;;;;QAM1D,sCAAsC;;;;;QAMtC;;;;;;;;;;;;;;WAcG;;;;;;;;;;;;;;;;;;;;;;;;CAYkC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAElF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,2BAA2B,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAA;AAE/F,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,CAAA;AAEjG,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA"}
+{"version":3,"file":"settings-store.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/settings-store.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;GAEG;AACH,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;iBAUrB,CAAA;AAEF,8CAA8C;AAC9C,QAAA,MAAM,oBAAoB;;;iBAGxB,CAAA;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,sBAAsB;;;;;;;;;;;;iBAM1B,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;;iBAIzB,CAAA;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,uBAAuB;;;;;QAKhC,mDAAmD;;;;;;QAMnD,mDAAmD;;;;;;;QAOnD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;QAMnD,2BAA2B;;;;;;;;;QAO3B,uCAAuC;;;;;;;QAOvC,iCAAiC;;;;;;QAOjC,0DAA0D;;;;;;;;;;;;;;;;;;;QAM1D,uEAAuE;;;;;;;;;;;;;;;;;;;;;;;;;QAUvE,sCAAsC;;;;;QAMtC;;;;;;;;;;;;;;WAcG;;;;;;;;;;;;;;;;;;;;;;;;CAYkC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAElF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,2BAA2B,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAA;AAE/F,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,CAAA;AAEjG,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

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

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Smoke alarm sensor — boolean "is smoke currently detected" with
+ * timestamp of the last transition. Drives Home Assistant
+ * `binary_sensor` entries with `device_class: smoke`.
+ *
+ * Push-driven: a smoke event is critical, so the slice updates
+ * immediately on the upstream signal. Auto-clearing back to false is
+ * provider-controlled (some alarms latch until manually reset).
+ */
+export declare const SmokeStatusSchema: z.ZodObject<{
+    detected: z.ZodBoolean;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type SmokeStatus = z.infer<typeof SmokeStatusSchema>;
+export declare const smokeCapability: {
+    readonly name: "smoke";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Sensor];
+    readonly methods: {};
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            detected: z.ZodBoolean;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    readonly runtimeState: z.ZodObject<{
+        detected: z.ZodBoolean;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type ISmokeProvider = InferProvider<typeof smokeCapability>;
+//# sourceMappingURL=smoke.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smoke.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/smoke.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;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB;;;iBAI5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;CAYa,CAAA;AAEzC,MAAM,MAAM,cAAc,GAAG,aAAa,CAAC,OAAO,eAAe,CAAC,CAAA"}

package/dist/capabilities/snapshot-provider.cap.d.ts

@@ -3,7 +3,7 @@ import { type InferProvider } from './capability-definition.js';
 /**
  * snapshot-provider — collection of native snapshot implementations.
  *
- * Device provider addons (ONVIF, Frigate, Scrypted, etc.) register here
+ * Device provider addons (ONVIF, Frigate, etc.) register here
  * when they can capture frames through a protocol-native path (e.g.
  * ONVIF GetSnapshotUri, Frigate /api/<cam>/latest.jpg). The `snapshot`
  * singleton orchestrator iterates over the collection, asking each

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

@@ -47,6 +47,7 @@ declare const SnapshotStatusSchema: z.ZodObject<{
 export declare const snapshotCapability: {
     readonly name: "snapshot";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly kind: "wrapper";
     readonly defaultActive: true;

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

@@ -1 +1 @@
-{"version":3,"file":"snapshot.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/snapshot.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;AACH,QAAA,MAAM,mBAAmB;;;iBAGvB,CAAA;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH;;;;;GAKG;AACH,QAAA,MAAM,oBAAoB;;;;;iBASxB,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCU,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE5E,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,CAAA"}
+{"version":3,"file":"snapshot.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/snapshot.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;AACH,QAAA,MAAM,mBAAmB;;;iBAGvB,CAAA;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH;;;;;GAKG;AACH,QAAA,MAAM,oBAAoB;;;;;iBASxB,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCU,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE5E,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,CAAA"}