@camstack/types 0.1.14 → 0.1.16

package/dist/capabilities/audio-analyzer.cap.d.ts

@@ -0,0 +1,148 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const AudioAnalysisResultSchema: z.ZodObject<{
+    level: z.ZodObject<{
+        rms: z.ZodNumber;
+        dbfs: z.ZodNumber;
+    }, z.core.$strip>;
+    classification: z.ZodOptional<z.ZodObject<{
+        labels: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            className: z.ZodString;
+            originalClass: z.ZodOptional<z.ZodString>;
+            score: z.ZodNumber;
+        }, z.core.$strip>>>;
+        inferenceMs: z.ZodNumber;
+    }, z.core.$strip>>;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+declare const AudioAnalysisSettingsSchema: z.ZodObject<{
+    minConfidence: z.ZodDefault<z.ZodNumber>;
+    allowedClasses: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const AudioClassificationResultSchema: z.ZodObject<{
+    labels: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        className: z.ZodString;
+        originalClass: z.ZodOptional<z.ZodString>;
+        score: z.ZodNumber;
+    }, z.core.$strip>>>;
+    rawLabels: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        className: z.ZodString;
+        originalClass: z.ZodOptional<z.ZodString>;
+        score: z.ZodNumber;
+    }, z.core.$strip>>>>;
+    inferenceMs: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * audio-analyzer — system-scoped compute cap.
+ *
+ * Owns the engine lifecycle (isReady / dispose), the stateless
+ * `analyseChunk` call and the `classify` method. Per-device settings,
+ * device-settings contribution and the `onAudioLevel` event live on the
+ * paired `audio-analysis` cap (device-scoped, singleton, wrapper
+ * defaultActive) so every camera gets its own bindings row and per-device
+ * toggle. Pairing mirrors `stream-broker` (system) + `camera-streams`
+ * (device) + `webrtc-session` (device) — single addon registers both.
+ */
+/**
+ * Operator-facing audio-backend choice. 'auto' defers to the addon's
+ * platform heuristic (Apple SoundAnalysis on macOS, YAMNet elsewhere).
+ */
+export declare const AUDIO_BACKEND_CHOICES: readonly [{
+    readonly value: "auto";
+    readonly label: "Auto (platform default)";
+}, {
+    readonly value: "apple-soundanalysis";
+    readonly label: "Apple SoundAnalysis (macOS 12+)";
+}, {
+    readonly value: "yamnet-onnx";
+    readonly label: "YAMNet ONNX (cross-platform)";
+}];
+export type AudioBackendChoice = typeof AUDIO_BACKEND_CHOICES[number]['value'];
+/**
+ * Shared shape of the audio-analyzer addon's global settings.
+ * `audioBackend` = operator choice (wins); `probedBestAudioBackend`
+ * = hint refreshed by `reprobeAudioEngine`. `selectedAudioModel`
+ * replaces the orchestrator's legacy
+ * `AgentPipelineSettings.audio.modelId`.
+ *
+ * NOTE — enable/disable is NOT stored here:
+ *   - per-device: `audio-analysis` wrapper cap + `setWrapperActive`
+ *     (binding system — the canonical gate).
+ *   - cluster-wide: `addonDefaults['audio-classifier'].enabled` on
+ *     the pipeline-orchestrator; drives whether the audio step
+ *     appears in the resolved tree at all.
+ */
+export interface AudioAnalyzerGlobalConfig {
+    readonly audioBackend: AudioBackendChoice;
+    readonly probedBestAudioBackend: string;
+    readonly selectedAudioModel: string;
+}
+export declare const DEFAULT_AUDIO_ANALYZER_CONFIG: AudioAnalyzerGlobalConfig;
+export declare const audioAnalyzerCapability: {
+    readonly name: "audio-analyzer";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        readonly analyseChunk: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            chunk: z.ZodObject<{
+                data: z.ZodCustom<Float32Array<ArrayBuffer>, Float32Array<ArrayBuffer>>;
+                sampleRate: z.ZodNumber;
+                channels: z.ZodNumber;
+                timestamp: z.ZodNumber;
+                deviceId: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+            settings: z.ZodObject<{
+                minConfidence: z.ZodDefault<z.ZodNumber>;
+                allowedClasses: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            level: z.ZodObject<{
+                rms: z.ZodNumber;
+                dbfs: z.ZodNumber;
+            }, z.core.$strip>;
+            classification: z.ZodOptional<z.ZodObject<{
+                labels: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    className: z.ZodString;
+                    originalClass: z.ZodOptional<z.ZodString>;
+                    score: z.ZodNumber;
+                }, z.core.$strip>>>;
+                inferenceMs: z.ZodNumber;
+            }, z.core.$strip>>;
+            timestamp: z.ZodNumber;
+        }, z.core.$strip>>, "mutation">;
+        readonly classify: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            data: z.ZodCustom<Float32Array<ArrayBuffer>, Float32Array<ArrayBuffer>>;
+            sampleRate: z.ZodNumber;
+            channels: z.ZodNumber;
+            timestamp: z.ZodNumber;
+            deviceId: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            labels: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                className: z.ZodString;
+                originalClass: z.ZodOptional<z.ZodString>;
+                score: z.ZodNumber;
+            }, z.core.$strip>>>;
+            rawLabels: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                className: z.ZodString;
+                originalClass: z.ZodOptional<z.ZodString>;
+                score: z.ZodNumber;
+            }, z.core.$strip>>>>;
+            inferenceMs: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly isReady: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly dispose: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodVoid, "mutation">;
+        /**
+         * Re-run the host platform-probe for the audio backend and persist
+         * the detected value into `probedBestAudioBackend`. Replaces the
+         * orchestrator's legacy `AgentPipelineSettings.audio.engine` —
+         * audio-analyzer now owns the choice. Operator `audioBackend` is
+         * not touched; only the probed-best hint.
+         */
+        readonly reprobeAudioEngine: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            backend: z.ZodString;
+        }, z.core.$strip>, "mutation">;
+    };
+};
+export type IAudioAnalyzerProvider = InferProvider<typeof audioAnalyzerCapability>;
+export { AudioAnalysisResultSchema, AudioAnalysisSettingsSchema, AudioClassificationResultSchema };
+//# sourceMappingURL=audio-analyzer.cap.d.ts.map

package/dist/capabilities/audio-analyzer.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio-analyzer.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/audio-analyzer.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAGlG,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;iBAO7B,CAAA;AAEF,QAAA,MAAM,2BAA2B;;;iBAG/B,CAAA;AAIF,QAAA,MAAM,+BAA+B;;;;;;;;;;;;iBAWnC,CAAA;AAEF;;;;;;;;;;GAUG;AACH;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;EAIxB,CAAA;AAEV,MAAM,MAAM,kBAAkB,GAAG,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAA;AAE9E;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,YAAY,EAAE,kBAAkB,CAAA;IACzC,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAA;IACvC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAA;CACpC;AAED,eAAO,MAAM,6BAA6B,EAAE,yBAI3C,CAAA;AAED,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAiBhC;;;;;;WAMG;;;;;CAOkC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAElF,OAAO,EAAE,yBAAyB,EAAE,2BAA2B,EAAE,+BAA+B,EAAE,CAAA"}

package/dist/capabilities/audio-codec.cap.d.ts

@@ -0,0 +1,202 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const PcmSampleFormatSchema: z.ZodEnum<{
+    f32le: "f32le";
+    s16le: "s16le";
+}>;
+declare const AudioCodecInfoSchema: z.ZodObject<{
+    codec: z.ZodString;
+    canDecode: z.ZodBoolean;
+    canEncode: z.ZodBoolean;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const AudioDecodeSessionConfigSchema: z.ZodObject<{
+    codec: z.ZodString;
+    sourceSampleRate: z.ZodNumber;
+    sourceChannels: z.ZodNumber;
+    extraData: z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+    targetSampleRate: z.ZodNumber;
+    targetChannels: z.ZodNumber;
+    targetFormat: z.ZodOptional<z.ZodEnum<{
+        f32le: "f32le";
+        s16le: "s16le";
+    }>>;
+    idleMs: z.ZodOptional<z.ZodNumber>;
+    tag: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const AudioEncodeSessionConfigSchema: z.ZodObject<{
+    codec: z.ZodString;
+    sourceSampleRate: z.ZodNumber;
+    sourceChannels: z.ZodNumber;
+    sourceFormat: z.ZodOptional<z.ZodEnum<{
+        f32le: "f32le";
+        s16le: "s16le";
+    }>>;
+    targetSampleRate: z.ZodNumber;
+    targetChannels: z.ZodNumber;
+    bitrateKbps: z.ZodOptional<z.ZodNumber>;
+    idleMs: z.ZodOptional<z.ZodNumber>;
+    tag: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const AudioPcmChunkSchema: z.ZodObject<{
+    data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+    sampleRate: z.ZodNumber;
+    channels: z.ZodNumber;
+    format: z.ZodEnum<{
+        f32le: "f32le";
+        s16le: "s16le";
+    }>;
+    pts: z.ZodNumber;
+}, z.core.$strip>;
+declare const AudioEncodedChunkSchema: z.ZodObject<{
+    data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+    codec: z.ZodString;
+    pts: z.ZodNumber;
+    frameComplete: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * audio-codec — bidirectional PCM ↔ encoded audio I/O box.
+ *
+ * Independent per-consumer sessions. The provider runs decode + resample
+ * (or resample + encode) inside the session so a 16kHz mono ASA
+ * subscriber and a 48kHz stereo WebRTC subscriber on the same source
+ * stream don't share resamplers.
+ *
+ * Singleton on each node. Decoder and encoder live in the same provider
+ * because they share the underlying libav contexts (node-av today,
+ * pluggable later) — operators always install one or the other together.
+ */
+export declare const audioCodecCapability: {
+    readonly name: "audio-codec";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        /** Probe the local runtime and return the supported codec matrix. */
+        readonly listSupportedCodecs: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            codec: z.ZodString;
+            canDecode: z.ZodBoolean;
+            canEncode: z.ZodBoolean;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Cheap predicate — does the runtime support `(codec, kind)`? */
+        readonly canHandle: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            codec: z.ZodString;
+            kind: z.ZodEnum<{
+                decode: "decode";
+                encode: "encode";
+            }>;
+        }, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly createDecodeSession: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            codec: z.ZodString;
+            sourceSampleRate: z.ZodNumber;
+            sourceChannels: z.ZodNumber;
+            extraData: z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
+            targetSampleRate: z.ZodNumber;
+            targetChannels: z.ZodNumber;
+            targetFormat: z.ZodOptional<z.ZodEnum<{
+                f32le: "f32le";
+                s16le: "s16le";
+            }>>;
+            idleMs: z.ZodOptional<z.ZodNumber>;
+            tag: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            sessionId: z.ZodString;
+            nodeId: z.ZodString;
+        }, z.core.$strip>, "mutation">;
+        readonly createEncodeSession: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            codec: z.ZodString;
+            sourceSampleRate: z.ZodNumber;
+            sourceChannels: z.ZodNumber;
+            sourceFormat: z.ZodOptional<z.ZodEnum<{
+                f32le: "f32le";
+                s16le: "s16le";
+            }>>;
+            targetSampleRate: z.ZodNumber;
+            targetChannels: z.ZodNumber;
+            bitrateKbps: z.ZodOptional<z.ZodNumber>;
+            idleMs: z.ZodOptional<z.ZodNumber>;
+            tag: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            sessionId: z.ZodString;
+            nodeId: z.ZodString;
+        }, z.core.$strip>, "mutation">;
+        readonly closeSession: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            sessionId: z.ZodString;
+            nodeId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Push one encoded audio frame into a decode session. */
+        readonly pushEncodedFrame: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            sessionId: z.ZodString;
+            nodeId: z.ZodOptional<z.ZodString>;
+            data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+            pts: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Pull up to `maxCount` PCM chunks from a decode session. */
+        readonly pullPcm: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            sessionId: z.ZodString;
+            nodeId: z.ZodOptional<z.ZodString>;
+            maxCount: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+            sampleRate: z.ZodNumber;
+            channels: z.ZodNumber;
+            format: z.ZodEnum<{
+                f32le: "f32le";
+                s16le: "s16le";
+            }>;
+            pts: z.ZodNumber;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Push one PCM chunk into an encode session. */
+        readonly pushPcm: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            sessionId: z.ZodString;
+            nodeId: z.ZodOptional<z.ZodString>;
+            data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+            pts: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Pull up to `maxCount` encoded chunks from an encode session. */
+        readonly pullEncoded: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            sessionId: z.ZodString;
+            nodeId: z.ZodOptional<z.ZodString>;
+            maxCount: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+            codec: z.ZodString;
+            pts: z.ZodNumber;
+            frameComplete: z.ZodBoolean;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Flush any pending encoded output (call before close on graceful tear). */
+        readonly flushEncode: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            sessionId: z.ZodString;
+            nodeId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+            codec: z.ZodString;
+            pts: z.ZodNumber;
+            frameComplete: z.ZodBoolean;
+        }, z.core.$strip>>, "mutation">;
+        readonly listActiveSessions: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            sessionId: z.ZodString;
+            kind: z.ZodEnum<{
+                decode: "decode";
+                encode: "encode";
+            }>;
+            codec: z.ZodString;
+            sourceSampleRate: z.ZodNumber;
+            sourceChannels: z.ZodNumber;
+            targetSampleRate: z.ZodNumber;
+            targetChannels: z.ZodNumber;
+            format: z.ZodEnum<{
+                f32le: "f32le";
+                s16le: "s16le";
+            }>;
+            tag: z.ZodOptional<z.ZodString>;
+            createdAtMs: z.ZodNumber;
+            lastActivityMs: z.ZodNumber;
+            framesIn: z.ZodNumber;
+            framesOut: z.ZodNumber;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IAudioCodecCapProvider = InferProvider<typeof audioCodecCapability>;
+export { AudioCodecInfoSchema, AudioDecodeSessionConfigSchema, AudioEncodeSessionConfigSchema, AudioPcmChunkSchema, AudioEncodedChunkSchema, PcmSampleFormatSchema, };
+//# sourceMappingURL=audio-codec.cap.d.ts.map

package/dist/capabilities/audio-codec.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio-codec.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/audio-codec.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAIlG,QAAA,MAAM,qBAAqB;;;EAA6B,CAAA;AAExD,QAAA,MAAM,oBAAoB;;;;;iBAKxB,CAAA;AAEF,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;iBAUlC,CAAA;AAEF,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;iBAUlC,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;;;;;;;iBAMvB,CAAA;AAEF,QAAA,MAAM,uBAAuB;;;;;iBAK3B,CAAA;AAoBF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB;;;;;QAM7B,qEAAqE;;;;;;;QAGrE,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAgClE,0DAA0D;;;;;;;QAa1D,8DAA8D;;;;;;;;;;;;;;;QAW9D,iDAAiD;;;;;;;QAajD,mEAAmE;;;;;;;;;;;QAUnE,6EAA6E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAaxC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAE/E,OAAO,EACL,oBAAoB,EACpB,8BAA8B,EAC9B,8BAA8B,EAC9B,mBAAmB,EACnB,uBAAuB,EACvB,qBAAqB,GACtB,CAAA"}

package/dist/capabilities/audio-metrics.cap.d.ts

@@ -0,0 +1,174 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Per-class audio metrics aggregated over a sliding window.
+ */
+declare const AudioClassSummarySchema: z.ZodObject<{
+    className: z.ZodString;
+    hits: z.ZodNumber;
+    avgScore: z.ZodNumber;
+    peakScore: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Per-camera audio metrics snapshot — emitted by the analytics frame
+ * handler on every `pipeline.audio-inference-result` event and
+ * mirrored into the `audio-metrics` device-state slice. Symmetric
+ * with `zone-analytics` snapshots for video — every consumer
+ * (admin UI panel, automations, alert rules) reads via the
+ * canonical `device.state.audioMetrics.value` reactive handle.
+ *
+ * Aggregates are computed over a rolling `windowSec` window
+ * (default 60s). Past that window, classes drop out of `byClass`
+ * and the level history shifts forward.
+ */
+declare const AudioMetricsSnapshotSchema: z.ZodObject<{
+    ts: z.ZodNumber;
+    windowSec: z.ZodNumber;
+    level: z.ZodObject<{
+        rms: z.ZodNumber;
+        dbfs: z.ZodNumber;
+    }, z.core.$strip>;
+    peakDbfs: z.ZodNumber;
+    avgDbfs: z.ZodNumber;
+    current: z.ZodNullable<z.ZodObject<{
+        className: z.ZodString;
+        score: z.ZodNumber;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>>;
+    byClass: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        className: z.ZodString;
+        hits: z.ZodNumber;
+        avgScore: z.ZodNumber;
+        peakScore: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type AudioMetricsSnapshot = z.infer<typeof AudioMetricsSnapshotSchema>;
+export type AudioClassSummary = z.infer<typeof AudioClassSummarySchema>;
+/**
+ * One sample on the audio-metrics history time-series. Captures the
+ * subset of the live snapshot useful for charting: dB level, peak/avg
+ * over the rolling window, and the dominant above-threshold class
+ * (when any). Per-class hit breakdown lives on the snapshot but is
+ * elided from the history sample to keep the buffer compact —
+ * consumers needing class drill-down should pull `getCurrentSnapshot`.
+ */
+declare const AudioMetricsHistoryPointSchema: z.ZodObject<{
+    ts: z.ZodNumber;
+    dbfs: z.ZodNullable<z.ZodNumber>;
+    peakDbfs: z.ZodNumber;
+    avgDbfs: z.ZodNumber;
+    topClass: z.ZodNullable<z.ZodString>;
+    topScore: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type AudioMetricsHistoryPoint = z.infer<typeof AudioMetricsHistoryPointSchema>;
+/**
+ * Audio-metrics history payload — a series of `AudioMetricsHistoryPoint`
+ * samples capped at `maxPoints` (default 1024). When the requested
+ * `windowSec / sampleEveryMs` would exceed the cap, the provider
+ * subsamples by bucketed averaging and reports the effective sample
+ * spacing on `effectiveSampleEveryMs` so the UI can label the x-axis.
+ */
+declare const AudioMetricsHistorySchema: z.ZodObject<{
+    points: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        ts: z.ZodNumber;
+        dbfs: z.ZodNullable<z.ZodNumber>;
+        peakDbfs: z.ZodNumber;
+        avgDbfs: z.ZodNumber;
+        topClass: z.ZodNullable<z.ZodString>;
+        topScore: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    effectiveSampleEveryMs: z.ZodNumber;
+    windowMsActual: z.ZodNumber;
+}, z.core.$strip>;
+export type AudioMetricsHistory = z.infer<typeof AudioMetricsHistorySchema>;
+/**
+ * Audio Metrics capability — sliding-window aggregates over the
+ * pipeline audio inference results. Hosted by `addon-pipeline-analytics`
+ * (same addon that owns `zone-analytics`); the runtime-state slice
+ * gives operators a live read on dB level + dominant classes without
+ * a custom event subscription.
+ */
+export declare const audioMetricsCapability: {
+    readonly name: "audio-metrics";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly methods: {
+        /** Latest snapshot for this device. Null until the analytics
+         *  pipeline has processed at least one audio window. */
+        readonly getCurrentSnapshot: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            ts: z.ZodNumber;
+            windowSec: z.ZodNumber;
+            level: z.ZodObject<{
+                rms: z.ZodNumber;
+                dbfs: z.ZodNumber;
+            }, z.core.$strip>;
+            peakDbfs: z.ZodNumber;
+            avgDbfs: z.ZodNumber;
+            current: z.ZodNullable<z.ZodObject<{
+                className: z.ZodString;
+                score: z.ZodNumber;
+                timestamp: z.ZodNumber;
+            }, z.core.$strip>>;
+            byClass: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                className: z.ZodString;
+                hits: z.ZodNumber;
+                avgScore: z.ZodNumber;
+                peakScore: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Time-series view of recent audio-metrics samples. The provider
+         * keeps an in-memory ring of ~1Hz samples (matching the slice-
+         * write rate) capped at `MAX_HISTORY_POINTS_KEPT` (provider-side).
+         * `windowSec` selects how far back to read; `sampleEveryMs`
+         * downsamples by bucketed averaging when finer than the kept
+         * granularity. Empty `points` array on freshly-booted providers
+         * with no audio yet — same convention as `getCurrentSnapshot`.
+         */
+        readonly getHistory: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            windowSec: z.ZodOptional<z.ZodNumber>;
+            sampleEveryMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            points: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                ts: z.ZodNumber;
+                dbfs: z.ZodNullable<z.ZodNumber>;
+                peakDbfs: z.ZodNumber;
+                avgDbfs: z.ZodNumber;
+                topClass: z.ZodNullable<z.ZodString>;
+                topScore: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            effectiveSampleEveryMs: z.ZodNumber;
+            windowMsActual: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+    /** Reactive runtime-state mirror — live `device.state.audioMetrics.value`. */
+    readonly runtimeState: z.ZodObject<{
+        ts: z.ZodNumber;
+        windowSec: z.ZodNumber;
+        level: z.ZodObject<{
+            rms: z.ZodNumber;
+            dbfs: z.ZodNumber;
+        }, z.core.$strip>;
+        peakDbfs: z.ZodNumber;
+        avgDbfs: z.ZodNumber;
+        current: z.ZodNullable<z.ZodObject<{
+            className: z.ZodString;
+            score: z.ZodNumber;
+            timestamp: z.ZodNumber;
+        }, z.core.$strip>>;
+        byClass: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            className: z.ZodString;
+            hits: z.ZodNumber;
+            avgScore: z.ZodNumber;
+            peakScore: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+};
+export type IAudioMetricsProvider = InferProvider<typeof audioMetricsCapability>;
+export { AudioMetricsSnapshotSchema, AudioClassSummarySchema, AudioMetricsHistoryPointSchema, AudioMetricsHistorySchema, };
+//# sourceMappingURL=audio-metrics.cap.d.ts.map

package/dist/capabilities/audio-metrics.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio-metrics.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/audio-metrics.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;;GAEG;AACH,QAAA,MAAM,uBAAuB;;;;;iBAQ3B,CAAA;AAEF;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;iBAuB9B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAC7E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE;;;;;;;GAOG;AACH,QAAA,MAAM,8BAA8B;;;;;;;iBAelC,CAAA;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAErF;;;;;;GAMG;AACH,QAAA,MAAM,yBAAyB;;;;;;;;;;;iBAO7B,CAAA;AACF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;QAM/B;gEACwD;;;;;;;;;;;;;;;;;;;;;;;;QAKxD;;;;;;;;WAQG;;;;;;;;;;;;;;;;;;IAgBL,8EAA8E;;;;;;;;;;;;;;;;;;;;;;CAEvC,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEhF,OAAO,EACL,0BAA0B,EAC1B,uBAAuB,EACvB,8BAA8B,EAC9B,yBAAyB,GAC1B,CAAA"}

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

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const AuthResultSchema: z.ZodObject<{
+    userId: z.ZodString;
+    username: z.ZodString;
+    email: z.ZodOptional<z.ZodString>;
+    displayName: z.ZodOptional<z.ZodString>;
+    roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const authProviderCapability: {
+    readonly name: "auth-provider";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly internal: true;
+    readonly methods: {
+        readonly validateCredentials: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            username: z.ZodString;
+            password: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            userId: z.ZodString;
+            username: z.ZodString;
+            email: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodOptional<z.ZodString>;
+            roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>, "mutation">;
+        readonly getLoginUrl: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            state: z.ZodString;
+        }, z.core.$strip>, z.ZodString, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly handleCallback: import("./capability-definition.js").CapabilityMethodSchema<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodObject<{
+            userId: z.ZodString;
+            username: z.ZodString;
+            email: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodOptional<z.ZodString>;
+            roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, "mutation">;
+        readonly validateToken: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            token: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            userId: z.ZodString;
+            username: z.ZodString;
+            email: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodOptional<z.ZodString>;
+            roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IAuthProvider = InferProvider<typeof authProviderCapability>;
+export { AuthResultSchema };
+//# sourceMappingURL=auth-provider.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auth-provider.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/auth-provider.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG,QAAA,MAAM,gBAAgB;;;;;;iBAMpB,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAeM,CAAA;AAEzC,MAAM,MAAM,aAAa,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAExE,OAAO,EAAE,gBAAgB,EAAE,CAAA"}