@camstack/types 0.1.14 → 0.1.16

package/dist/capabilities/webrtc-session.cap.d.ts

@@ -0,0 +1,181 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Discriminated target for a WebRTC session. The client sends this
+ * structured object instead of building / parsing brokerId strings;
+ * the server resolves it to a brokerId via the assignments map.
+ *
+ * - `adaptive`: server picks the best broker for the device based on
+ *   client hints (viewport, downlink).
+ * - `profile`: pin the session to a profile slot (`high`/`mid`/`low`).
+ *   The actual source can change as the operator reassigns the slot.
+ * - `cam-stream`: pin the session to a specific source by camStreamId
+ *   (e.g. `native:main`, `rtsp:sub`). Useful when the operator wants
+ *   a stable view of a specific source regardless of profile bindings,
+ *   or to consume a manually-activated stream that isn't profile-bound.
+ */
+export declare const WebrtcStreamTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"adaptive">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"profile">;
+    profile: z.ZodEnum<{
+        high: "high";
+        mid: "mid";
+        low: "low";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"cam-stream">;
+    camStreamId: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type WebrtcStreamTarget = z.infer<typeof WebrtcStreamTargetSchema>;
+/** A stream choice the UI can offer for a device. */
+export declare const WebrtcStreamChoiceSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"adaptive">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"profile">;
+        profile: z.ZodEnum<{
+            high: "high";
+            mid: "mid";
+            low: "low";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"cam-stream">;
+        camStreamId: z.ZodString;
+    }, z.core.$strip>], "kind">;
+    codec: z.ZodNullable<z.ZodString>;
+    resolution: z.ZodNullable<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>;
+    status: z.ZodNullable<z.ZodEnum<{
+        error: "error";
+        streaming: "streaming";
+        stopped: "stopped";
+        idle: "idle";
+        connecting: "connecting";
+    }>>;
+    inputFps: z.ZodNullable<z.ZodNumber>;
+    decodeFps: z.ZodNullable<z.ZodNumber>;
+    bitrateKbps: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type WebrtcStreamChoice = z.infer<typeof WebrtcStreamChoiceSchema>;
+/**
+ * WebRTC session — device-scoped facade over the system `webrtc` cap.
+ *
+ * Exposes per-device signaling (`createSession`, `handleAnswer`,
+ * `closeSession`) on the device proxy so UI / integrations can
+ * negotiate a session by (deviceId, profile) instead of constructing
+ * an opaque `${deviceId}/${profile}` streamId string. The provider is
+ * registered by the stream-broker addon for every camera device with
+ * at least one active profile slot; internally it resolves
+ * `${deviceId}/${profile}` and forwards to the system webrtc provider.
+ *
+ * The system `webrtc` cap remains available for cross-device / raw
+ * streamId callers (debugging, admin tools). Production UI should
+ * prefer this device-scoped cap.
+ */
+export declare const webrtcSessionCapability: {
+    readonly name: "webrtc-session";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly methods: {
+        /**
+         * List available WebRTC streams for a device.
+         * Returns adaptive (if any profile is assigned) + each assigned profile
+         * with codec/resolution info. UI renders this directly — no hardcoded
+         * profile names needed.
+         */
+        readonly listStreams: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"adaptive">;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"profile">;
+                profile: z.ZodEnum<{
+                    high: "high";
+                    mid: "mid";
+                    low: "low";
+                }>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"cam-stream">;
+                camStreamId: z.ZodString;
+            }, z.core.$strip>], "kind">;
+            codec: z.ZodNullable<z.ZodString>;
+            resolution: z.ZodNullable<z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>>;
+            status: z.ZodNullable<z.ZodEnum<{
+                error: "error";
+                streaming: "streaming";
+                stopped: "stopped";
+                idle: "idle";
+                connecting: "connecting";
+            }>>;
+            inputFps: z.ZodNullable<z.ZodNumber>;
+            decodeFps: z.ZodNullable<z.ZodNumber>;
+            bitrateKbps: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Open a WebRTC session against a specific target on the device.
+         * `target.kind` discriminates between adaptive selection, a profile
+         * slot, or a specific cam stream source — see `WebrtcStreamTarget`.
+         * The server resolves the target to a live broker; clients never
+         * build or parse brokerId strings.
+         */
+        readonly createSession: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"adaptive">;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"profile">;
+                profile: z.ZodEnum<{
+                    high: "high";
+                    mid: "mid";
+                    low: "low";
+                }>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"cam-stream">;
+                camStreamId: z.ZodString;
+            }, z.core.$strip>], "kind">;
+            hints: z.ZodOptional<z.ZodObject<{
+                viewportWidth: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                viewportHeight: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                devicePixelRatio: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                downlinkMbps: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                prefersTier: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            sessionId: z.ZodString;
+            sdpOffer: z.ZodString;
+        }, z.core.$strip>, "mutation">;
+        readonly handleAnswer: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            sessionId: z.ZodString;
+            sdpAnswer: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly closeSession: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            sessionId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Whether the underlying provider supports adaptive bitrate for this profile. */
+        readonly hasAdaptiveBitrate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            profile: z.ZodEnum<{
+                high: "high";
+                mid: "mid";
+                low: "low";
+            }>;
+        }, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IWebrtcSessionProvider = InferProvider<typeof webrtcSessionCapability>;
+//# sourceMappingURL=webrtc-session.cap.d.ts.map

package/dist/capabilities/webrtc-session.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webrtc-session.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/webrtc-session.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;AAIrD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;2BAInC,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,qDAAqD;AACrD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBnC,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,uBAAuB;;;;;;QAMhC;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAKH;;;;;;WAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA2BH,kFAAkF;;;;;;;;;;CAS7C,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}

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

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * Optional client-side hints sent at session creation to help the
+ * provider pick the best native source. All fields are optional —
+ * a viewer that knows nothing still gets a sane default.
+ */
+export declare const webrtcClientHintsSchema: z.ZodObject<{
+    viewportWidth: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    viewportHeight: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    devicePixelRatio: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    downlinkMbps: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    prefersTier: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export type WebrtcClientHints = z.infer<typeof webrtcClientHintsSchema>;
+export declare const webrtcCapability: {
+    readonly name: "webrtc";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly internal: true;
+    readonly methods: {
+        readonly handleOffer: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            streamId: z.ZodString;
+            sdpOffer: z.ZodString;
+        }, z.core.$strip>, z.ZodString, "mutation">;
+        readonly supportsStream: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            streamId: z.ZodString;
+        }, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly registerStream: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            streamId: z.ZodString;
+            codec: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly unregisterStream: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            streamId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /**
+         * Two-step server-offer signaling. `hints` is optional — providers
+         * that don't care about adaptive source selection ignore it.
+         */
+        readonly createSession: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            streamId: z.ZodString;
+            hints: z.ZodOptional<z.ZodObject<{
+                viewportWidth: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                viewportHeight: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                devicePixelRatio: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                downlinkMbps: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                prefersTier: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            sessionId: z.ZodString;
+            sdpOffer: z.ZodString;
+        }, z.core.$strip>, "mutation">;
+        readonly handleAnswer: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            sessionId: z.ZodString;
+            sdpAnswer: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly closeSession: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            sessionId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /**
+         * Whether this provider supports adaptive bitrate for the given stream.
+         * Currently always false — adaptive selection is one-shot at session
+         * start, not in-session encoder switching. Phase 5 plans to layer
+         * encoder-driven adaptation on top.
+         */
+        readonly hasAdaptiveBitrate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            streamId: z.ZodString;
+        }, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IWebrtcProvider = InferProvider<typeof webrtcCapability>;
+//# sourceMappingURL=webrtc.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webrtc.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/webrtc.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;;GAIG;AACH,eAAO,MAAM,uBAAuB;;;;;;iBAQxB,CAAA;AAEZ,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;QAkBzB;;;WAGG;;;;;;;;;;;;;;;;;;;;;QAeH;;;;;WAKG;;;;;CAMkC,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

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

@@ -0,0 +1,213 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Per-zone occupancy aggregation produced by the analytics frame
+ * processor on every inference result. Covers the full combinatorial
+ * matrix the operator UI needs: total objects everywhere, total
+ * objects per zone, single class everywhere, single class per zone,
+ * objects outside any zone.
+ *
+ * Counts are derived from the analytics tracker (tracked detections
+ * with stable trackIds), not raw detector hits — this filters out
+ * one-off detector flickers and gives counts that match what the user
+ * sees on the live overlay.
+ *
+ * Overlap policy: a detection that intersects two zones counts in
+ * BOTH zones' `byClass` and `totalObjects` (count-in-each). The
+ * `frame` aggregate de-duplicates trivially since it's frame-wide.
+ * `unzoned` counts only detections that landed in zero zones.
+ */
+declare const PerScopeBreakdownSchema: z.ZodObject<{
+    totalObjects: z.ZodNumber;
+    byClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+declare const ZoneScopeBreakdownSchema: z.ZodObject<{
+    totalObjects: z.ZodNumber;
+    byClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    zoneId: z.ZodString;
+    zoneName: z.ZodString;
+    trackIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const CameraOccupancySnapshotSchema: z.ZodObject<{
+    ts: z.ZodNumber;
+    frameWidth: z.ZodNumber;
+    frameHeight: z.ZodNumber;
+    zones: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        totalObjects: z.ZodNumber;
+        byClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        zoneId: z.ZodString;
+        zoneName: z.ZodString;
+        trackIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    frame: z.ZodObject<{
+        totalObjects: z.ZodNumber;
+        byClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>;
+    unzoned: z.ZodObject<{
+        totalObjects: z.ZodNumber;
+        byClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CameraOccupancySnapshot = z.infer<typeof CameraOccupancySnapshotSchema>;
+export type ZoneScopeBreakdown = z.infer<typeof ZoneScopeBreakdownSchema>;
+export type PerScopeBreakdown = z.infer<typeof PerScopeBreakdownSchema>;
+/**
+ * Time-series resolution. The history methods return one bucket per
+ * step over the requested range. Smaller resolutions cost more
+ * memory + bandwidth; bound to discrete steps so caller cannot ask
+ * for arbitrary fractional buckets.
+ */
+declare const HistoryResolutionEnum: z.ZodEnum<{
+    minute: "minute";
+    "5min": "5min";
+    hour: "hour";
+}>;
+export type HistoryResolution = z.infer<typeof HistoryResolutionEnum>;
+declare const HistoryRangeSchema: z.ZodObject<{
+    from: z.ZodNumber;
+    to: z.ZodNumber;
+    resolution: z.ZodEnum<{
+        minute: "minute";
+        "5min": "5min";
+        hour: "hour";
+    }>;
+}, z.core.$strip>;
+declare const HistoryPointSchema: z.ZodObject<{
+    ts: z.ZodNumber;
+    count: z.ZodNumber;
+}, z.core.$strip>;
+export type HistoryPoint = z.infer<typeof HistoryPointSchema>;
+/**
+ * Zone Analytics capability — spatial occupancy aggregations over
+ * tracked detections. Hosted by `addon-pipeline-analytics`.
+ *
+ * Live snapshot is mirrored into the `zone-occupancy` device-state
+ * slice on every frame; the cap method `getCurrentSnapshot` is a
+ * direct read for callers that don't want to subscribe.
+ *
+ * History methods are sourced from a 60-minute rolling in-memory
+ * ring of frame-level samples (sub-second resolution). Queries
+ * outside the ring window return empty arrays — durable storage
+ * is a follow-up (Step 4b: persisted samples → SQL store).
+ *
+ * Every history method takes an optional `className` filter:
+ * - omitted → bucket count includes ALL classes in scope
+ * - present → bucket count restricted to that class
+ *
+ * The `getZoneHistory` / `getCameraHistory` / `getUnzonedHistory`
+ * triple covers the three spatial scopes (per-zone, frame-wide,
+ * outside-any-zone). Crossing them with `className?` gives the full
+ * combinatorial coverage the operator UI requested.
+ */
+export declare const zoneAnalyticsCapability: {
+    readonly name: "zone-analytics";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly methods: {
+        /** Latest computed occupancy snapshot for this camera. Null when
+         *  the analytics pipeline hasn't seen a frame for this device yet
+         *  (no inference result emitted since boot or since binding was
+         *  activated). */
+        readonly getCurrentSnapshot: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            ts: z.ZodNumber;
+            frameWidth: z.ZodNumber;
+            frameHeight: z.ZodNumber;
+            zones: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                totalObjects: z.ZodNumber;
+                byClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                zoneId: z.ZodString;
+                zoneName: z.ZodString;
+                trackIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+            frame: z.ZodObject<{
+                totalObjects: z.ZodNumber;
+                byClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            }, z.core.$strip>;
+            unzoned: z.ZodObject<{
+                totalObjects: z.ZodNumber;
+                byClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Time-series object count inside one zone. `className` optional —
+         *  omit to count every class in the zone. */
+        readonly getZoneHistory: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            zoneId: z.ZodString;
+            className: z.ZodOptional<z.ZodString>;
+            from: z.ZodNumber;
+            to: z.ZodNumber;
+            resolution: z.ZodEnum<{
+                minute: "minute";
+                "5min": "5min";
+                hour: "hour";
+            }>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            ts: z.ZodNumber;
+            count: z.ZodNumber;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Time-series frame-wide object count (everywhere). */
+        readonly getCameraHistory: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            className: z.ZodOptional<z.ZodString>;
+            from: z.ZodNumber;
+            to: z.ZodNumber;
+            resolution: z.ZodEnum<{
+                minute: "minute";
+                "5min": "5min";
+                hour: "hour";
+            }>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            ts: z.ZodNumber;
+            count: z.ZodNumber;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Time-series count of objects outside every zone. */
+        readonly getUnzonedHistory: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            className: z.ZodOptional<z.ZodString>;
+            from: z.ZodNumber;
+            to: z.ZodNumber;
+            resolution: z.ZodEnum<{
+                minute: "minute";
+                "5min": "5min";
+                hour: "hour";
+            }>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            ts: z.ZodNumber;
+            count: z.ZodNumber;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+    /**
+     * Runtime-state slice — the latest occupancy snapshot mirrored by
+     * the analytics frame processor on every inference result. Consumers
+     * read via `device.state.zoneAnalytics.value` and stay in sync
+     * automatically; the explicit `getCurrentSnapshot` cap method is
+     * still useful for one-off polls without a subscription.
+     */
+    readonly runtimeState: z.ZodObject<{
+        ts: z.ZodNumber;
+        frameWidth: z.ZodNumber;
+        frameHeight: z.ZodNumber;
+        zones: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            totalObjects: z.ZodNumber;
+            byClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            zoneId: z.ZodString;
+            zoneName: z.ZodString;
+            trackIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        frame: z.ZodObject<{
+            totalObjects: z.ZodNumber;
+            byClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, z.core.$strip>;
+        unzoned: z.ZodObject<{
+            totalObjects: z.ZodNumber;
+            byClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+};
+export type IZoneAnalyticsProvider = InferProvider<typeof zoneAnalyticsCapability>;
+export { CameraOccupancySnapshotSchema as _CameraOccupancySnapshotSchema, HistoryResolutionEnum, HistoryPointSchema, HistoryRangeSchema, ZoneScopeBreakdownSchema, PerScopeBreakdownSchema, };
+//# sourceMappingURL=zone-analytics.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zone-analytics.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/zone-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;AAErD;;;;;;;;;;;;;;;;GAgBG;AACH,QAAA,MAAM,uBAAuB;;;iBAK3B,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;iBAM5B,CAAA;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;iBAYxC,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AACnF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE;;;;;GAKG;AACH,QAAA,MAAM,qBAAqB;;;;EAAqC,CAAA;AAChE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAErE,QAAA,MAAM,kBAAkB;;;;;;;;iBAMtB,CAAA;AAEF,QAAA,MAAM,kBAAkB;;;iBAKtB,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,uBAAuB;;;;;;QAMhC;;;0BAGkB;;;;;;;;;;;;;;;;;;;;;;;QAKlB;qDAC6C;;;;;;;;;;;;;;;;QAS7C,wDAAwD;;;;;;;;;;;;;;;QAQxD,uDAAuD;;;;;;;;;;;;;;;;IASzD;;;;;;OAMG;;;;;;;;;;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAElF,OAAO,EACL,6BAA6B,IAAI,8BAA8B,EAC/D,qBAAqB,EACrB,kBAAkB,EAClB,kBAAkB,EAClB,wBAAwB,EACxB,uBAAuB,GACxB,CAAA"}

package/dist/capabilities/zone-rules.cap.d.ts

@@ -0,0 +1,129 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Stages a {@link ZoneRule} can apply to. Discriminator on the rules
+ * cap so a single CRUD surface backs every consumer; each stage has
+ * its own dev-state mirror slice (`motion-zone-rules`,
+ * `detection-zone-rules`, …) so consumer addons subscribe independently.
+ *
+ * Extend the enum here when a new gating consumer comes online (audio
+ * gating, alert filtering, …) — no other surface needs to change.
+ */
+export declare const ZoneRuleStageEnum: z.ZodEnum<{
+    motion: "motion";
+    detection: "detection";
+}>;
+export type ZoneRuleStage = z.infer<typeof ZoneRuleStageEnum>;
+/**
+ * Zone rules capability — per-camera CRUD over the {@link ZoneRule}
+ * arrays that decide how each pipeline stage uses the polygon zones.
+ *
+ * Hosted by `addon-pipeline-orchestrator` alongside the zones provider
+ * so the operator has a single hub-side source of truth for both
+ * geometry and behaviour. Per-stage rules are stored under the
+ * `zoneRules.<stage>` key in the orchestrator's per-device store and
+ * mirrored to the device-state slice `<stage>-zone-rules` on every
+ * mutation; consumer addons (analytics, motion-wasm, pipeline-executor)
+ * subscribe to that slice and refresh their gating without
+ * round-tripping the cap.
+ *
+ * Sets are bulk-replace — the operator UI sends the new rule list
+ * wholesale, so reordering / batch enable-toggle / drag-drop CRUD lives
+ * naturally in the rule editor without per-rule mutation chatter.
+ */
+export declare const zoneRulesCapability: {
+    readonly name: "zone-rules";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly methods: {
+        /** Read the full rule list for a given stage (empty when no rules
+         *  are defined yet). */
+        readonly listRules: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            stage: z.ZodEnum<{
+                motion: "motion";
+                detection: "detection";
+            }>;
+        }, z.core.$strip>, 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>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Bulk-replace the rule list for one stage. The provider validates
+         *  each entry against {@link ZoneRuleSchema} (zoneIds non-empty,
+         *  thresholds in range) and rejects the whole patch if any entry
+         *  is invalid — partial writes are a configuration footgun. */
+        readonly setRules: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            stage: z.ZodEnum<{
+                motion: "motion";
+                detection: "detection";
+            }>;
+            rules: 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>>>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    /**
+     * Runtime-state slice — both stages mirrored together so consumers
+     * see one reactive handle (`device.state.zoneRules.value`) instead
+     * of two. Bulk-replace mutations on either stage write the full
+     * `{motion, detection}` shape, so subscribers always get the
+     * complete current set. Consumers that only care about one stage
+     * just read the matching property.
+     */
+    readonly runtimeState: z.ZodObject<{
+        motion: 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>>>;
+        detection: 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>>>;
+    }, z.core.$strip>;
+};
+export type IZoneRulesProvider = InferProvider<typeof zoneRulesCapability>;
+//# sourceMappingURL=zone-rules.cap.d.ts.map

package/dist/capabilities/zone-rules.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zone-rules.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/zone-rules.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;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB;;;EAAkC,CAAA;AAChE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE7D;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,mBAAmB;;;;;;QAM5B;gCACwB;;;;;;;;;;;;;;;;;;;;;QAKxB;;;uEAG+D;;;;;;;;;;;;;;;;;;;;;;;IAWjE;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKoC,CAAA;AAEzC,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC,OAAO,mBAAmB,CAAC,CAAA"}