@camstack/types 0.1.14 → 0.1.15

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

@@ -0,0 +1,164 @@
+/**
+ * Alerts capability — collection-based internal alert system.
+ *
+ * Multiple providers can register. Each provider filters by EventBus category
+ * and creates/updates alerts. The built-in Alert Center addon persists alerts
+ * in the DB and serves them to the admin UI.
+ */
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+export declare const AlertSeveritySchema: z.ZodEnum<{
+    info: "info";
+    error: "error";
+    success: "success";
+    warning: "warning";
+}>;
+export declare const AlertStatusSchema: z.ZodEnum<{
+    active: "active";
+    "in-progress": "in-progress";
+    completed: "completed";
+    failed: "failed";
+    dismissed: "dismissed";
+}>;
+export declare const AlertSourceSchema: z.ZodObject<{
+    type: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const AlertSchema: z.ZodObject<{
+    id: z.ZodString;
+    category: z.ZodString;
+    severity: z.ZodEnum<{
+        info: "info";
+        error: "error";
+        success: "success";
+        warning: "warning";
+    }>;
+    title: z.ZodString;
+    message: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        "in-progress": "in-progress";
+        completed: "completed";
+        failed: "failed";
+        dismissed: "dismissed";
+    }>;
+    progress: z.ZodOptional<z.ZodNumber>;
+    read: z.ZodBoolean;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    source: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type AlertSeverity = z.infer<typeof AlertSeveritySchema>;
+export type AlertStatus = z.infer<typeof AlertStatusSchema>;
+export type Alert = z.infer<typeof AlertSchema>;
+export declare const alertsCapability: {
+    readonly name: "alerts";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        readonly emit: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+            category: z.ZodString;
+            severity: z.ZodEnum<{
+                info: "info";
+                error: "error";
+                success: "success";
+                warning: "warning";
+            }>;
+            title: z.ZodString;
+            message: z.ZodString;
+            status: z.ZodEnum<{
+                active: "active";
+                "in-progress": "in-progress";
+                completed: "completed";
+                failed: "failed";
+                dismissed: "dismissed";
+            }>;
+            progress: z.ZodOptional<z.ZodNumber>;
+            read: z.ZodBoolean;
+            createdAt: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+            source: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strip>>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly update: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            alertId: z.ZodString;
+            patch: z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                category: z.ZodOptional<z.ZodString>;
+                severity: z.ZodOptional<z.ZodEnum<{
+                    info: "info";
+                    error: "error";
+                    success: "success";
+                    warning: "warning";
+                }>>;
+                title: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+                status: z.ZodOptional<z.ZodEnum<{
+                    active: "active";
+                    "in-progress": "in-progress";
+                    completed: "completed";
+                    failed: "failed";
+                    dismissed: "dismissed";
+                }>>;
+                progress: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                read: z.ZodOptional<z.ZodBoolean>;
+                createdAt: z.ZodOptional<z.ZodNumber>;
+                updatedAt: z.ZodOptional<z.ZodNumber>;
+                source: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                }, z.core.$strip>>>;
+                metadata: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly list: import("./capability-definition.js").CapabilityMethodSchema<z.ZodOptional<z.ZodObject<{
+            unreadOnly: z.ZodOptional<z.ZodBoolean>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            category: z.ZodString;
+            severity: z.ZodEnum<{
+                info: "info";
+                error: "error";
+                success: "success";
+                warning: "warning";
+            }>;
+            title: z.ZodString;
+            message: z.ZodString;
+            status: z.ZodEnum<{
+                active: "active";
+                "in-progress": "in-progress";
+                completed: "completed";
+                failed: "failed";
+                dismissed: "dismissed";
+            }>;
+            progress: z.ZodOptional<z.ZodNumber>;
+            read: z.ZodBoolean;
+            createdAt: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+            source: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strip>>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getUnreadCount: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodNumber, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly markRead: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            alertId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly markAllRead: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodVoid, "mutation">;
+        readonly dismiss: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            alertId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+};
+export type IAlertsProvider = InferProvider<typeof alertsCapability>;
+//# sourceMappingURL=alerts.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"alerts.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/alerts.cap.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAIlG,eAAO,MAAM,mBAAmB;;;;;EAAkD,CAAA;AAElF,eAAO,MAAM,iBAAiB;;;;;;EAAwE,CAAA;AAEtG,eAAO,MAAM,iBAAiB;;;iBAG5B,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAatB,CAAA;AAIF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC3D,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAI/C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBY,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

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

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+import type { AudioAnalysisSettings } from '../types/io.js';
+/**
+ * audio-analysis — device-scoped facade over the system `audio-analyzer`.
+ *
+ * Pairs with `audio-analyzer` (system, singleton) the way `camera-streams`
+ * pairs with `stream-broker`: the system cap owns the compute path
+ * (`processChunk`, engine lifecycle) while `audio-analysis` exposes the
+ * per-device surface — settings resolution, device-settings contribution,
+ * audio-level events — and is the binding row every camera sees in the
+ * device-manager bindings UI.
+ *
+ * Registered as a wrapper with `defaultActive: true` by `addon-audio-analysis`
+ * so every camera picks up audio analysis automatically; operators can
+ * disable per-device via `device-manager.setWrapperActive` when they don't
+ * want a given camera to be analysed (e.g. muted / motion-only cams).
+ */
+export declare const audioAnalysisCapability: {
+    readonly name: "audio-analysis";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly exposesDeviceSettings: true;
+    readonly methods: {
+        /**
+         * Resolve per-device audio analysis settings (minConfidence,
+         * allowedClasses) from the addon settings store for a given camera.
+         * Orchestrator callers use this before handing chunks to
+         * `audio-analyzer.processChunk`.
+         */
+        readonly resolveDeviceSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodCustom<AudioAnalysisSettings | null, AudioAnalysisSettings | null>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+    readonly events: {
+        readonly onAudioLevel: import("./capability-definition.js").CapabilityEventSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            rms: z.ZodNumber;
+            dbfs: z.ZodNumber;
+        }, z.core.$strip>>;
+    };
+};
+export type IAudioAnalysisProvider = InferProvider<typeof audioAnalysisCapability>;
+//# sourceMappingURL=audio-analysis.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"audio-analysis.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/audio-analysis.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA4C,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AACzG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AACrD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAE3D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,uBAAuB;;;;;;;QAOhC;;;;;WAKG;;;;;;;;;;;;CAakC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}

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