@camstack/types 0.1.14 → 0.1.15

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

@@ -0,0 +1,44 @@
+/** Shared Zod schemas for the runtime pipeline orchestrator metrics. */
+import { z } from 'zod';
+export declare const OrchestratorMetricsSchema: z.ZodObject<{
+    activeCameras: z.ZodNumber;
+    throttledCameras: z.ZodNumber;
+    avgInferenceTimeMs: z.ZodNumber;
+    queueDepth: z.ZodNumber;
+}, z.core.$strip>;
+export declare const CameraMetricsSchema: z.ZodObject<{
+    detectionMode: z.ZodEnum<{
+        disabled: "disabled";
+        "always-on": "always-on";
+        "on-motion": "on-motion";
+    }>;
+    configuredFps: z.ZodNumber;
+    actualFps: z.ZodNumber;
+    queueDepth: z.ZodNumber;
+    avgInferenceTimeMs: z.ZodNumber;
+    droppedFrames: z.ZodNumber;
+    phase: z.ZodEnum<{
+        idle: "idle";
+        watching: "watching";
+        active: "active";
+    }>;
+}, z.core.$strip>;
+export declare const CameraMetricsWithDeviceIdSchema: z.ZodObject<{
+    detectionMode: z.ZodEnum<{
+        disabled: "disabled";
+        "always-on": "always-on";
+        "on-motion": "on-motion";
+    }>;
+    configuredFps: z.ZodNumber;
+    actualFps: z.ZodNumber;
+    queueDepth: z.ZodNumber;
+    avgInferenceTimeMs: z.ZodNumber;
+    droppedFrames: z.ZodNumber;
+    phase: z.ZodEnum<{
+        idle: "idle";
+        watching: "watching";
+        active: "active";
+    }>;
+    deviceId: z.ZodNumber;
+}, z.core.$strip>;
+//# sourceMappingURL=orchestrator-metrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-metrics.d.ts","sourceRoot":"","sources":["../../../src/capabilities/schemas/orchestrator-metrics.ts"],"names":[],"mappings":"AAAA,wEAAwE;AAExE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,yBAAyB;;;;;iBAKpC,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;iBAQ9B,CAAA;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;iBAE1C,CAAA"}

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

@@ -0,0 +1,177 @@
+/** Shared Zod schemas used across streaming capabilities. */
+import { z } from 'zod';
+export declare const CamProfileSchema: z.ZodEnum<{
+    high: "high";
+    mid: "mid";
+    low: "low";
+}>;
+export type CamProfile = z.infer<typeof CamProfileSchema>;
+/** Canonical ordering. Hard-coded; never sorted. */
+export declare const CAM_PROFILE_ORDER: readonly ["high", "mid", "low"];
+export declare const CamStreamKindSchema: z.ZodEnum<{
+    "pull-rtsp": "pull-rtsp";
+    "pull-rtmp": "pull-rtmp";
+    "pull-http": "pull-http";
+    "pull-rfc4571": "pull-rfc4571";
+    "push-annexb": "push-annexb";
+}>;
+export type CamStreamKind = z.infer<typeof CamStreamKindSchema>;
+export declare const CamStreamResolutionSchema: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>;
+export declare const CameraStreamSchema: z.ZodObject<{
+    camStreamId: z.ZodString;
+    deviceId: z.ZodNumber;
+    kind: z.ZodEnum<{
+        "pull-rtsp": "pull-rtsp";
+        "pull-rtmp": "pull-rtmp";
+        "pull-http": "pull-http";
+        "pull-rfc4571": "pull-rfc4571";
+        "push-annexb": "push-annexb";
+    }>;
+    url: z.ZodOptional<z.ZodString>;
+    codec: z.ZodOptional<z.ZodString>;
+    resolution: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+    fps: z.ZodOptional<z.ZodNumber>;
+    label: z.ZodOptional<z.ZodString>;
+    deviceFeatures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    autoEligible: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type CameraStream = z.infer<typeof CameraStreamSchema>;
+export declare const ProfileSlotStatusSchema: z.ZodEnum<{
+    error: "error";
+    streaming: "streaming";
+    idle: "idle";
+    connecting: "connecting";
+    unassigned: "unassigned";
+}>;
+export type ProfileSlotStatus = z.infer<typeof ProfileSlotStatusSchema>;
+export declare const ProfileSlotSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    profile: z.ZodEnum<{
+        high: "high";
+        mid: "mid";
+        low: "low";
+    }>;
+    brokerId: z.ZodString;
+    sourceCamStreamId: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        error: "error";
+        streaming: "streaming";
+        idle: "idle";
+        connecting: "connecting";
+        unassigned: "unassigned";
+    }>;
+    resolution: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+    codec: z.ZodOptional<z.ZodString>;
+    preBufferSec: z.ZodOptional<z.ZodNumber>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ProfileSlot = z.infer<typeof ProfileSlotSchema>;
+/**
+ * Zod schema for StreamSourceEntry — the canonical stream descriptor
+ * exposed by ICameraDevice.getStreamSources() and consumed by the broker.
+ */
+export declare const StreamSourceEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    protocol: z.ZodEnum<{
+        custom: "custom";
+        rtsp: "rtsp";
+        rtmp: "rtmp";
+        webrtc: "webrtc";
+        annexb: "annexb";
+        "http-mjpeg": "http-mjpeg";
+    }>;
+    url: z.ZodOptional<z.ZodString>;
+    resolution: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>>;
+    fps: z.ZodOptional<z.ZodNumber>;
+    bitrate: z.ZodOptional<z.ZodNumber>;
+    codec: z.ZodOptional<z.ZodString>;
+    profileHint: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        mid: "mid";
+        low: "low";
+    }>>;
+}, z.core.$strip>;
+export declare const StreamSourceSchema: z.ZodObject<{
+    type: z.ZodString;
+    url: z.ZodString;
+    videoCodec: z.ZodOptional<z.ZodString>;
+    audioCodec: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare const EncodedPacketSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        audio: "audio";
+        video: "video";
+    }>;
+    data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+    pts: z.ZodNumber;
+    dts: z.ZodNumber;
+    keyframe: z.ZodBoolean;
+    codec: z.ZodString;
+}, z.core.$strip>;
+export declare const DecodedFrameSchema: z.ZodObject<{
+    data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    format: z.ZodEnum<{
+        jpeg: "jpeg";
+        rgb: "rgb";
+        bgr: "bgr";
+        yuv420: "yuv420";
+        gray: "gray";
+    }>;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export declare const BrokerStatusSchema: z.ZodEnum<{
+    error: "error";
+    streaming: "streaming";
+    stopped: "stopped";
+    idle: "idle";
+    connecting: "connecting";
+}>;
+export declare const BrokerStatsSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        error: "error";
+        streaming: "streaming";
+        stopped: "stopped";
+        idle: "idle";
+        connecting: "connecting";
+    }>;
+    inputFps: z.ZodNumber;
+    decodeFps: z.ZodNumber;
+    encodedSubscribers: z.ZodNumber;
+    decodedSubscribers: z.ZodNumber;
+    uptimeMs: z.ZodNumber;
+    bitrateKbps: z.ZodNumber;
+    idrIntervalMs: z.ZodNumber;
+    codec: z.ZodOptional<z.ZodString>;
+    totalBytes: z.ZodNumber;
+    packetCount: z.ZodNumber;
+    rtspClients: z.ZodNumber;
+    pipeClients: z.ZodNumber;
+    preBufferSec: z.ZodNumber;
+    preBufferMs: z.ZodNumber;
+    preBufferPackets: z.ZodNumber;
+    decoderNodeId: z.ZodNullable<z.ZodString>;
+    audio: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        codec: z.ZodString;
+        sampleRate: z.ZodNumber;
+        channels: z.ZodNumber;
+        supported: z.ZodBoolean;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+//# sourceMappingURL=streaming-shared.d.ts.map

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

@@ -0,0 +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;AAUvB,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,eAAO,MAAM,kBAAkB;;;;;;EAAkE,CAAA;AAEjG,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuC5B,CAAA"}

package/dist/capabilities/schemas/zone-rule.d.ts

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+/**
+ * Per-stage gating mode applied to the zones a rule references.
+ *
+ * - `include`: the rule contributes to a **whitelist** for its stage.
+ *   When at least one `include` rule fires for a stage, only entities
+ *   inside one of those zones pass that stage.
+ * - `exclude`: the rule contributes to a **blacklist** for its stage.
+ *   Entities inside one of those zones are dropped at that stage.
+ *
+ * `monitor`-style observation (count without filtering) is not a rule
+ * mode — zones without any matching rule are observed naturally by
+ * `zone-analytics` (live snapshot + history), so an "I just want to
+ * count, not filter" use case needs no rule at all.
+ */
+export declare const ZoneRuleModeEnum: z.ZodEnum<{
+    include: "include";
+    exclude: "exclude";
+}>;
+export type ZoneRuleMode = z.infer<typeof ZoneRuleModeEnum>;
+/**
+ * Per-consumer rule that references existing zones (geometry) and
+ * defines how a specific pipeline stage should treat them. Each
+ * consumer addon owns its own `ZoneRule[]` array in its per-device
+ * settings:
+ *
+ * - `addon-motion-wasm` → `motionZoneRules: ZoneRule[]` (motion stage)
+ * - `addon-detection-pipeline` → `detectionZoneRules: ZoneRule[]` (detection stage)
+ * - future: notification rules, audio gating, etc.
+ *
+ * One rule applies to N zones (`zoneIds[]`) so the operator can
+ * express "ignore motion in ALL of {garden, street}" with a single
+ * rule. `classFilter` narrows the rule to specific object classes —
+ * "drop person detections in the street, but keep cars" is one
+ * `exclude` rule with `classFilter: ['person']`.
+ *
+ * `enabled` is a soft toggle — the operator can keep the rule
+ * configured but inert without deleting it.
+ */
+export declare const ZoneRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    zoneIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    mode: z.ZodEnum<{
+        include: "include";
+        exclude: "exclude";
+    }>;
+    classFilter: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    overlapThreshold: z.ZodOptional<z.ZodNumber>;
+    bboxInclusionPct: z.ZodOptional<z.ZodNumber>;
+    preferMask: z.ZodOptional<z.ZodBoolean>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ZoneRule = z.infer<typeof ZoneRuleSchema>;
+/**
+ * Convenience array schema — used by addon device-settings
+ * contributions and runtime payloads (e.g. `RunnerCameraConfig`).
+ */
+export declare const ZoneRulesArraySchema: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    zoneIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    mode: z.ZodEnum<{
+        include: "include";
+        exclude: "exclude";
+    }>;
+    classFilter: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    overlapThreshold: z.ZodOptional<z.ZodNumber>;
+    bboxInclusionPct: z.ZodOptional<z.ZodNumber>;
+    preferMask: z.ZodOptional<z.ZodBoolean>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>>>;
+export type ZoneRules = z.infer<typeof ZoneRulesArraySchema>;
+//# sourceMappingURL=zone-rule.d.ts.map

package/dist/capabilities/schemas/zone-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zone-rule.d.ts","sourceRoot":"","sources":["../../../src/capabilities/schemas/zone-rule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB;;;EAAiC,CAAA;AAC9D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE3D;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;iBAkDzB,CAAA;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAErD;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;mBAAqC,CAAA;AACtE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

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

@@ -0,0 +1,198 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * Query filter for settings-store collections.
+ */
+declare const QueryFilterSchema: 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>;
+/** A single stored record: `{ id, data }`. */
+declare const SettingsRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+/**
+ * Column declaration for a structured (SQL-backed) collection.
+ * SQLite types: TEXT, INTEGER, REAL, JSON (JSON is a compatibility type —
+ * SQLite stores it as TEXT, backend handles serialization).
+ */
+declare const CollectionColumnSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        TEXT: "TEXT";
+        INTEGER: "INTEGER";
+        REAL: "REAL";
+        JSON: "JSON";
+    }>;
+    primaryKey: z.ZodOptional<z.ZodBoolean>;
+    notNull: z.ZodOptional<z.ZodBoolean>;
+    unique: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const CollectionIndexSchema: z.ZodObject<{
+    name: z.ZodString;
+    columns: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    unique: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * settings-store — singleton capability for addon-scoped persistence.
+ *
+ * Every method operates within a `collection`. An optional `namespace`
+ * field provides access to additional data spaces beyond the default
+ * addon settings — useful for business data (events, tracks, faces, etc.).
+ *
+ * Scoping: the implementation prefixes every collection with the calling
+ * addon's ID automatically. Addons never see each other's data.
+ *
+ *   - No namespace (default): `"addon-settings"` → `"<addonId>:addon-settings"`
+ *   - With namespace: `{ namespace: 'events', collection: 'detections' }` →
+ *     `"<addonId>:events:detections"`
+ *
+ * Implemented by `@camstack/core/builtins/sqlite-settings` (SQLite WAL backend).
+ * Addons access it via `ctx.api.settingsStore.*`.
+ */
+export declare const settingsStoreCapability: {
+    readonly name: "settings-store";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        /** Get a single value by key from a collection. */
+        readonly get: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            key: z.ZodString;
+        }, z.core.$strip>, z.ZodUnknown, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Set a value by key in a collection (upsert). */
+        readonly set: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            key: z.ZodString;
+            value: z.ZodUnknown;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Get all entries matching an optional filter. */
+        readonly query: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            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<{
+            id: z.ZodString;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Insert a new record. */
+        readonly insert: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            record: z.ZodObject<{
+                id: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Update an existing record by ID. */
+        readonly update: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            id: z.ZodString;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Delete a record by key/ID. */
+        readonly delete: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            key: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Count entries in a collection, optionally filtered. */
+        readonly count: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            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.ZodNumber, 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>;
+            collection: z.ZodString;
+        }, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Declare a typed (SQL-backed) collection with explicit columns +
+         * indexes. Idempotent: re-declaring an existing collection with the
+         * same shape is a no-op; shape changes (new columns, new indexes)
+         * are applied additively. Subsequent `insert` / `update` / `delete`
+         * / `query` calls on this collection use typed columns instead of
+         * JSON-blob storage — `record.data` fields are spread across
+         * columns, `query.filter.where` matches real columns (no
+         * `json_extract` overhead), `orderBy` uses column indexes.
+         *
+         * Addons call this in `onInitialize` before their first read/write.
+         * Collection names should be namespaced by addon (e.g.
+         * `pipeline-analytics:object-events`) to avoid cross-addon
+         * clashes — no automatic prefix is added.
+         */
+        readonly declareCollection: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            columns: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodEnum<{
+                    TEXT: "TEXT";
+                    INTEGER: "INTEGER";
+                    REAL: "REAL";
+                    JSON: "JSON";
+                }>;
+                primaryKey: z.ZodOptional<z.ZodBoolean>;
+                notNull: z.ZodOptional<z.ZodBoolean>;
+                unique: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+            indexes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                columns: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                unique: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+};
+export type ISettingsStoreProvider = InferProvider<typeof settingsStoreCapability>;
+/**
+ * tRPC client namespace type for the settings-store capability.
+ * Used as the dependency type for services that need settings persistence.
+ * Methods are accessed as `client.get.query(input)`, `client.set.mutate(input)`, etc.
+ */
+export type SettingsStoreClient = import('../generated/addon-api.js').AddonApi['settingsStore'];
+export { QueryFilterSchema, SettingsRecordSchema, CollectionColumnSchema, CollectionIndexSchema };
+export type CollectionColumn = z.infer<typeof CollectionColumnSchema>;
+export type CollectionIndex = z.infer<typeof CollectionIndexSchema>;
+//# sourceMappingURL=settings-store.cap.d.ts.map

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

@@ -0,0 +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;;;;GAIG;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"}

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * snapshot-provider — collection of native snapshot implementations.
+ *
+ * Device provider addons (ONVIF, Frigate, Scrypted, 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
+ * provider whether it supports the requested device, and calls the
+ * first matching one.
+ *
+ * If no provider in the collection supports a device, the orchestrator
+ * falls back to `stream-broker.grabFrame` (universal fallback).
+ *
+ * Public tRPC router (auto-mounted) so out-of-process addons, agents,
+ * and advanced clients can bypass the orchestrator when needed.
+ */
+export declare const snapshotProviderCapability: {
+    readonly name: "snapshot-provider";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly methods: {
+        readonly supportsDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getSnapshot: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            streamId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            base64: z.ZodString;
+            contentType: z.ZodString;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type ISnapshotProvider = InferProvider<typeof snapshotProviderCapability> & {
+    readonly id: string;
+    readonly name: string;
+};
+//# sourceMappingURL=snapshot-provider.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-provider.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/snapshot-provider.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAGlG;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;CAiBE,CAAA;AAEzC,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC,OAAO,0BAA0B,CAAC,GAAG;IACjF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB,CAAA"}

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

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * A single device snapshot returned as base64 JPEG/PNG.
+ *
+ * Shared with the `snapshot-provider` collection cap — the orchestrator
+ * receives the same shape from each native provider and from the
+ * broker-based fallback.
+ */
+declare const SnapshotImageSchema: z.ZodObject<{
+    base64: z.ZodString;
+    contentType: z.ZodString;
+}, z.core.$strip>;
+/**
+ * snapshot — device-scoped capability for camera image capture.
+ *
+ * Two kinds of providers coexist behind this cap name:
+ *
+ *   - **Native** providers (kind:'native'): registered per-device by
+ *     device-driver addons (RtspCamera, OnvifCamera, …) via
+ *     `DeviceContext.registerNativeCap`. Each knows how to fetch a frame
+ *     straight from the camera (HTTP snapshot URL, ONVIF action, etc.).
+ *
+ *   - **Wrapper** providers (kind:'wrapper'): register as a system
+ *     provider (SnapshotAddon in `@camstack/core/builtins/snapshot`). The
+ *     wrapper owns the cache and invokes the native via
+ *     `ctx.getNativeProvider(snapshotCapability, deviceId)` on miss.
+ *
+ * Device-scoped routing: callers use `ctx.fetchDevice(id).snapshot.*`;
+ * the DeviceProxy auto-injects `deviceId` + `nodeId` and dispatches to
+ * the provider currently active for that device (wrapper wins when
+ * activated via `setWrapperActive`, otherwise the native).
+ */
+/**
+ * Live readable snapshot state — diagnostic info that a consumer can
+ * pull to know when the last image was captured, how stale the cache
+ * is, and which stream was used. Distinct from `getSnapshot` which
+ * returns the JPEG itself.
+ */
+declare const SnapshotStatusSchema: z.ZodObject<{
+    lastCapturedAt: z.ZodNullable<z.ZodNumber>;
+    cacheAgeMs: z.ZodNullable<z.ZodNumber>;
+    lastBytes: z.ZodNullable<z.ZodNumber>;
+    lastStreamId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const snapshotCapability: {
+    readonly name: "snapshot";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly exposesDeviceSettings: true;
+    readonly methods: {
+        readonly getSnapshot: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            streamId: z.ZodOptional<z.ZodString>;
+            force: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            base64: z.ZodString;
+            contentType: z.ZodString;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly invalidateCache: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            lastCapturedAt: z.ZodNullable<z.ZodNumber>;
+            cacheAgeMs: z.ZodNullable<z.ZodNumber>;
+            lastBytes: z.ZodNullable<z.ZodNumber>;
+            lastStreamId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        readonly kind: "poll";
+    };
+};
+export type ISnapshotOrchestrator = InferProvider<typeof snapshotCapability>;
+export { SnapshotImageSchema, SnapshotStatusSchema };
+//# sourceMappingURL=snapshot.cap.d.ts.map

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

@@ -0,0 +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;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCU,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE5E,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,CAAA"}