@camstack/types 1.2.42 → 1.2.44

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

@@ -247,6 +247,31 @@ export declare const TrackSourceSchema: z.ZodEnum<{
     pipeline: "pipeline";
 }>;
 export type TrackSource = z.infer<typeof TrackSourceSchema>;
+/**
+ * Where a track sits in the RETRAIN lifecycle (D81).
+ *
+ *  - `none` — never marked, or un-marked. Evictable.
+ *  - `staging` — the operator wants this track as training material and has not
+ *    finished with it. **This is the only state retention holds**: the track and
+ *    everything it owns (object events, crops, keyframes, CLIP vector) survive
+ *    the device's age window.
+ *  - `trained` — the retrain page has taken what it needed. The frames it chose
+ *    were COPIED into the retrain dataset at selection time, so the dataset no
+ *    longer depends on the track's media and the track becomes EVICTABLE again.
+ *    Terminal for the plain `markForTrain` toggle: returning it to `staging` is
+ *    a deliberate action of the retrain page, not a side effect of a checkbox.
+ *
+ * There is no `null`. The state is stored `TEXT NOT NULL DEFAULT 'none'` because
+ * the store's filter language has only positive equality and `whereIn` — no
+ * negation, no IS NULL — so a NULL would be unselectable by ANY predicate and
+ * would make the entire pre-column history immortal in one deploy.
+ */
+export declare const RetrainStatusSchema: z.ZodEnum<{
+    none: "none";
+    staging: "staging";
+    trained: "trained";
+}>;
+export type RetrainStatus = z.infer<typeof RetrainStatusSchema>;
 /**
  * The write half: a PARTIAL patch. An omitted key is left untouched, so setting
  * one flag can never clear the other — the toggles are independent and are
@@ -266,9 +291,45 @@ export declare const TrackFlagsSchema: z.ZodObject<{
     trackId: z.ZodString;
     markForTrain: z.ZodBoolean;
     debug: z.ZodBoolean;
+    retrainStatus: z.ZodEnum<{
+        none: "none";
+        staging: "staging";
+        trained: "trained";
+    }>;
 }, z.core.$strip>;
 export type TrackFlags = z.infer<typeof TrackFlagsSchema>;
+/** Per-camera slice of a training-export estimate. */
+export declare const TrainingExportDeviceTotalsSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    tracks: z.ZodNumber;
+    files: z.ZodNumber;
+    bytes: z.ZodNumber;
+}, z.core.$strip>;
+export type TrainingExportDeviceTotals = z.infer<typeof TrainingExportDeviceTotalsSchema>;
+/**
+ * What a training export WOULD contain. Computed from media index rows only —
+ * no blob is read to produce this.
+ */
+export declare const TrainingExportSummarySchema: z.ZodObject<{
+    generatedAt: z.ZodNumber;
+    trackCount: z.ZodNumber;
+    fileCount: z.ZodNumber;
+    byteCount: z.ZodNumber;
+    truncated: z.ZodBoolean;
+    devices: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        deviceId: z.ZodNumber;
+        tracks: z.ZodNumber;
+        files: z.ZodNumber;
+        bytes: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type TrainingExportSummary = z.infer<typeof TrainingExportSummarySchema>;
 declare const TrackSchema: z.ZodObject<{
+    retrainStatus: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        staging: "staging";
+        trained: "trained";
+    }>>;
     markForTrain: z.ZodOptional<z.ZodBoolean>;
     debug: z.ZodOptional<z.ZodBoolean>;
     trackId: z.ZodString;
@@ -550,6 +611,11 @@ declare const RecentTracksQueryInput: z.ZodObject<{
 export type RecentTracksQuery = z.infer<typeof RecentTracksQueryInput>;
 declare const RecentTracksPageSchema: z.ZodObject<{
     tracks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        retrainStatus: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            staging: "staging";
+            trained: "trained";
+        }>>;
         markForTrain: z.ZodOptional<z.ZodBoolean>;
         debug: z.ZodOptional<z.ZodBoolean>;
         trackId: z.ZodString;
@@ -622,6 +688,11 @@ declare const RecentTracksPageSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type RecentTracksPage = z.infer<typeof RecentTracksPageSchema>;
 declare const KeyEventSchema: z.ZodObject<{
+    retrainStatus: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        staging: "staging";
+        trained: "trained";
+    }>>;
     markForTrain: z.ZodOptional<z.ZodBoolean>;
     debug: z.ZodOptional<z.ZodBoolean>;
     id: z.ZodString;
@@ -744,6 +815,11 @@ export declare const pipelineAnalyticsCapability: {
         readonly getActiveTracks: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            retrainStatus: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                staging: "staging";
+                trained: "trained";
+            }>>;
             markForTrain: z.ZodOptional<z.ZodBoolean>;
             debug: z.ZodOptional<z.ZodBoolean>;
             trackId: z.ZodString;
@@ -816,6 +892,11 @@ export declare const pipelineAnalyticsCapability: {
             deviceId: z.ZodNumber;
             trackId: z.ZodString;
         }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            retrainStatus: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                staging: "staging";
+                trained: "trained";
+            }>>;
             markForTrain: z.ZodOptional<z.ZodBoolean>;
             debug: z.ZodOptional<z.ZodBoolean>;
             trackId: z.ZodString;
@@ -910,6 +991,11 @@ export declare const pipelineAnalyticsCapability: {
                 slim: "slim";
             }>>;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            retrainStatus: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                staging: "staging";
+                trained: "trained";
+            }>>;
             markForTrain: z.ZodOptional<z.ZodBoolean>;
             debug: z.ZodOptional<z.ZodBoolean>;
             trackId: z.ZodString;
@@ -1000,6 +1086,11 @@ export declare const pipelineAnalyticsCapability: {
             }>>;
         }, z.core.$strip>, z.ZodObject<{
             tracks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                retrainStatus: z.ZodOptional<z.ZodEnum<{
+                    none: "none";
+                    staging: "staging";
+                    trained: "trained";
+                }>>;
                 markForTrain: z.ZodOptional<z.ZodBoolean>;
                 debug: z.ZodOptional<z.ZodBoolean>;
                 trackId: z.ZodString;
@@ -1323,6 +1414,11 @@ export declare const pipelineAnalyticsCapability: {
             minImportance: z.ZodOptional<z.ZodNumber>;
             classFilter: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            retrainStatus: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                staging: "staging";
+                trained: "trained";
+            }>>;
             markForTrain: z.ZodOptional<z.ZodBoolean>;
             debug: z.ZodOptional<z.ZodBoolean>;
             id: z.ZodString;
@@ -1434,11 +1530,29 @@ export declare const pipelineAnalyticsCapability: {
          *
          * `auth: 'protected'` (the default), NOT `admin`: the viewer is an
          * authenticated non-admin surface and two of the three call sites are
-         * there. Revisit if a flag ever gains an effect that costs storage —
-         * `deleteTracks` next door is admin for exactly that reason.
+         * there. The note that used to sit here said to revisit this the day a flag
+         * gained an effect that costs storage, and D81 is that day — `markForTrain`
+         * now pins. It STAYS protected, and the reason is that the alternative
+         * makes the feature pointless: marking a track is something you do while
+         * looking at it, on the surface you were already looking at it on, and that
+         * surface is the viewer. What the storage cost gets instead is a BOUND — a
+         * per-device pin budget enforced in the body, refusing a new pin past the
+         * limit while always allowing un-marking. `deleteTracks` next door is still
+         * admin, because destroying evidence and preserving it are not symmetric.
          *
-         * Returns the RESOLVED state of both flags (absent → `false`) so a caller
-         * can drive its toggle without a re-fetch. Rejects an unknown track.
+         * `markForTrain` writes the retrain LIFECYCLE, not a boolean column: `true`
+         * is `none → staging`, `false` is `staging → none`. A track already
+         * `trained` refuses BOTH — its frames are copies inside the retrain dataset
+         * and re-staging it from a generic toggle is how the same material gets
+         * annotated twice under two ground truths. Returning a trained track to
+         * staging is a deliberate action of the retrain page, which is also the only
+         * thing that produces `trained` in the first place.
+         *
+         * Returns the RESOLVED state of both flags (absent → `false`) plus the
+         * `retrainStatus` they were derived from, so a caller can drive its toggle
+         * — and render a `trained` badge — without a re-fetch. Rejects an unknown
+         * track, a new staging mark on a device already holding its full budget, and
+         * any `markForTrain` write against a trained track.
          */
         readonly setTrackFlags: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
@@ -1451,6 +1565,11 @@ export declare const pipelineAnalyticsCapability: {
             trackId: z.ZodString;
             markForTrain: z.ZodBoolean;
             debug: z.ZodBoolean;
+            retrainStatus: z.ZodEnum<{
+                none: "none";
+                staging: "staging";
+                trained: "trained";
+            }>;
         }, z.core.$strip>, "mutation">;
         /**
          * Durable event-store footprint for the management UI: event rows
@@ -1570,6 +1689,54 @@ export declare const pipelineAnalyticsCapability: {
             detail: z.ZodNullable<z.ZodString>;
             actor: z.ZodString;
         }, z.core.$strip>>>, "query">;
+        /**
+         * The CHEAP QUESTION, asked before any media moves: how big is the dataset
+         * the marked (`markForTrain`) tracks would produce?
+         *
+         * Answered from media INDEX rows only — key, kind, size, timestamp — so it
+         * costs ~2 KB of reads per track and no blob reads at all. The measured harm
+         * behind D56 was a bulk pass that read and base64'd every blob a track owned
+         * before deciding anything, taking hub-main to 82 s busy out of 120; an
+         * export is that same I/O shape, so it inherits the same discipline: know
+         * the size, then decide.
+         *
+         * `truncated` reports that more marked tracks exist than one pass carries.
+         * Empty `deviceIds` ⇒ every device that has marked tracks.
+         */
+        readonly getTrainingExportSummary: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strip>, z.ZodObject<{
+            generatedAt: z.ZodNumber;
+            trackCount: z.ZodNumber;
+            fileCount: z.ZodNumber;
+            byteCount: z.ZodNumber;
+            truncated: z.ZodBoolean;
+            devices: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                deviceId: z.ZodNumber;
+                tracks: z.ZodNumber;
+                files: z.ZodNumber;
+                bytes: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, "query">;
+        /**
+         * Where to download the dataset archive.
+         *
+         * The BYTES do not come back through this cap — they come from the returned
+         * data-plane URL, which streams a tar built entry by entry. A multi-gigabyte
+         * archive base64'd through a unary RPC envelope would be held whole in
+         * memory twice on a hub this repo has already OOM'd once (D9/D18 are the
+         * same lesson about frames). `getDownloadUrl` on `recordingExport` is the
+         * precedent, and this follows it deliberately.
+         *
+         * The archive contains a `manifest.json` FIRST, then the stored media
+         * VERBATIM under `tracks/<deviceId>/<trackId>/…`. No crop is derived and no
+         * model is run: a training set's pixels must be the pixels the pipeline saw.
+         */
+        readonly getTrainingExportUrl: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strip>, z.ZodObject<{
+            url: z.ZodString;
+        }, z.core.$strip>, "query">;
         readonly getEventMedia: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             eventId: z.ZodString;
             kind: z.ZodOptional<z.ZodEnum<{

package/dist/capabilities/pipeline-orchestrator.cap.d.ts

@@ -442,11 +442,14 @@ declare const CameraStatusSchema: z.ZodObject<{
         storageBytes: z.ZodNumber;
     }, z.core.$strip>>;
     switchedOff: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        "privacy-mask": "privacy-mask";
         "audio-analysis": "audio-analysis";
         recording: "recording";
         "stream-broker": "stream-broker";
         notifications: "notifications";
         "object-detection": "object-detection";
+        "device-audio": "device-audio";
+        "broker-audio": "broker-audio";
     }>>>;
     fetchedAt: z.ZodNumber;
 }, z.core.$strip>;
@@ -1090,11 +1093,14 @@ export declare const pipelineOrchestratorCapability: {
             deviceId: z.ZodNumber;
             switches: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                 id: z.ZodEnum<{
+                    "privacy-mask": "privacy-mask";
                     "audio-analysis": "audio-analysis";
                     recording: "recording";
                     "stream-broker": "stream-broker";
                     notifications: "notifications";
                     "object-detection": "object-detection";
+                    "device-audio": "device-audio";
+                    "broker-audio": "broker-audio";
                 }>;
                 label: z.ZodString;
                 costWhenOff: z.ZodString;
@@ -1102,6 +1108,7 @@ export declare const pipelineOrchestratorCapability: {
                 unavailableReason: z.ZodOptional<z.ZodEnum<{
                     "no-provider": "no-provider";
                     "source-unreachable": "source-unreachable";
+                    "not-configured": "not-configured";
                 }>>;
                 enabled: z.ZodBoolean;
                 authority: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -1113,6 +1120,14 @@ export declare const pipelineOrchestratorCapability: {
                     kind: z.ZodLiteral<"recording-config">;
                 }, z.core.$strip>, z.ZodObject<{
                     kind: z.ZodLiteral<"notification-mute">;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"camera-audio">;
+                    capName: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"camera-mask">;
+                    capName: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"broker-audio-mute">;
                 }, z.core.$strip>], "kind">;
             }, z.core.$strip>>>;
             fetchedAt: z.ZodNumber;
@@ -1133,22 +1148,28 @@ export declare const pipelineOrchestratorCapability: {
         readonly setCameraSwitch: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
             switchId: z.ZodEnum<{
+                "privacy-mask": "privacy-mask";
                 "audio-analysis": "audio-analysis";
                 recording: "recording";
                 "stream-broker": "stream-broker";
                 notifications: "notifications";
                 "object-detection": "object-detection";
+                "device-audio": "device-audio";
+                "broker-audio": "broker-audio";
             }>;
             enabled: z.ZodBoolean;
         }, z.core.$strip>, z.ZodObject<{
             deviceId: z.ZodNumber;
             switches: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                 id: z.ZodEnum<{
+                    "privacy-mask": "privacy-mask";
                     "audio-analysis": "audio-analysis";
                     recording: "recording";
                     "stream-broker": "stream-broker";
                     notifications: "notifications";
                     "object-detection": "object-detection";
+                    "device-audio": "device-audio";
+                    "broker-audio": "broker-audio";
                 }>;
                 label: z.ZodString;
                 costWhenOff: z.ZodString;
@@ -1156,6 +1177,7 @@ export declare const pipelineOrchestratorCapability: {
                 unavailableReason: z.ZodOptional<z.ZodEnum<{
                     "no-provider": "no-provider";
                     "source-unreachable": "source-unreachable";
+                    "not-configured": "not-configured";
                 }>>;
                 enabled: z.ZodBoolean;
                 authority: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -1167,6 +1189,14 @@ export declare const pipelineOrchestratorCapability: {
                     kind: z.ZodLiteral<"recording-config">;
                 }, z.core.$strip>, z.ZodObject<{
                     kind: z.ZodLiteral<"notification-mute">;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"camera-audio">;
+                    capName: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"camera-mask">;
+                    capName: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"broker-audio-mute">;
                 }, z.core.$strip>], "kind">;
             }, z.core.$strip>>>;
             fetchedAt: z.ZodNumber;
@@ -1281,11 +1311,14 @@ export declare const pipelineOrchestratorCapability: {
                 storageBytes: z.ZodNumber;
             }, z.core.$strip>>;
             switchedOff: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                "privacy-mask": "privacy-mask";
                 "audio-analysis": "audio-analysis";
                 recording: "recording";
                 "stream-broker": "stream-broker";
                 notifications: "notifications";
                 "object-detection": "object-detection";
+                "device-audio": "device-audio";
+                "broker-audio": "broker-audio";
             }>>>;
             fetchedAt: z.ZodNumber;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
@@ -1398,11 +1431,14 @@ export declare const pipelineOrchestratorCapability: {
                 storageBytes: z.ZodNumber;
             }, z.core.$strip>>;
             switchedOff: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                "privacy-mask": "privacy-mask";
                 "audio-analysis": "audio-analysis";
                 recording: "recording";
                 "stream-broker": "stream-broker";
                 notifications: "notifications";
                 "object-detection": "object-detection";
+                "device-audio": "device-audio";
+                "broker-audio": "broker-audio";
             }>>>;
             fetchedAt: z.ZodNumber;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;

package/dist/capabilities/privacy-mask.cap.d.ts

@@ -1,13 +1,31 @@
 import { z } from 'zod';
-import { type InferNativeProvider } from './capability-definition.js';
 import { DeviceType } from '../device/device-type.js';
+import { type InferNativeProvider } from './capability-definition.js';
 /**
- * Privacy mask = up to `maxRegions` SHAPES the camera blanks out (NOT a
- * cell grid). Reolink `<shelterList>` zones are rectangles; Hikvision
- * ISAPI `<RegionCoordinatesList>` zones are free polygons (this camera:
- * exactly 4 vertices, not necessarily axis-aligned). The cap composes the
- * shared rect|polygon subset of the MaskShape vocabulary. All coords are
- * normalized 0..1 (top-left origin).
+ * PRIVACY — what the camera deliberately does not capture. Two planes:
+ *
+ *  - **video**: up to `maxRegions` SHAPES the camera blanks out (NOT a cell
+ *    grid). Reolink `<shelterList>` zones are rectangles; Hikvision ISAPI
+ *    `<RegionCoordinatesList>` zones are free polygons (this camera: exactly
+ *    4 vertices, not necessarily axis-aligned). The cap composes the shared
+ *    rect|polygon subset of the MaskShape vocabulary. All coords are
+ *    normalized 0..1 (top-left origin).
+ *  - **audio**: the camera's microphone. `setAudioEnabled(false)` stops the
+ *    camera encoding an audio track at all, so EVERY consumer — live view,
+ *    recording, the audio analyzer, an export — sees silent video. There is
+ *    no server-side copy of this fact; the camera is the store and every read
+ *    is a read-through, which is why a switch over it cannot drift
+ *    ([D62](../../../../docs/decisions/adr-0062.md)).
+ *
+ * Both belong here for one reason: they are the two things an operator turns
+ * off when the answer to "what is this camera allowed to record" changes, and
+ * both are applied ON the device, before anything leaves it.
+ *
+ * **The audio flag has exactly one writer.** `stream-params` used to carry a
+ * per-profile `audio` in its patch schema — reachable from no UI and honoured
+ * by one provider — and it was removed when this landed. A second writer onto
+ * one device register is the shape of every knob this repo has shipped that
+ * disagreed with the one the reader read.
  */
 /** A privacy-mask region's geometry — rectangle or free polygon. */
 export declare const PrivacyMaskShapeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -41,7 +59,7 @@ export declare const PrivacyMaskRegionSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>], "kind">;
 }, z.core.$strip>;
-/** Current on-camera privacy-mask state — master enable + zones. */
+/** Current on-camera privacy state — mask master enable + zones + microphone. */
 export declare const PrivacyMaskStatusSchema: z.ZodObject<{
     enabled: z.ZodBoolean;
     regions: z.ZodArray<z.ZodObject<{
@@ -61,9 +79,10 @@ export declare const PrivacyMaskStatusSchema: z.ZodObject<{
             }, z.core.$strip>>;
         }, z.core.$strip>], "kind">;
     }, z.core.$strip>>;
+    audioEnabled: z.ZodNullable<z.ZodBoolean>;
     lastFetchedAt: z.ZodNumber;
 }, z.core.$strip>;
-/** Per-camera availability. */
+/** Per-camera availability. Probed, never assumed from the model name. */
 export declare const PrivacyMaskOptionsSchema: z.ZodObject<{
     maxRegions: z.ZodNumber;
     supportedShapes: z.ZodArray<z.ZodEnum<{
@@ -76,6 +95,7 @@ export declare const PrivacyMaskOptionsSchema: z.ZodObject<{
         min: z.ZodNumber;
         max: z.ZodNumber;
     }, z.core.$strip>>;
+    supportsAudioMute: z.ZodBoolean;
 }, z.core.$strip>;
 /** Partial change — every field optional. */
 export declare const PrivacyMaskPatchSchema: z.ZodObject<{
@@ -132,6 +152,7 @@ export declare const privacyMaskCapability: {
                 min: z.ZodNumber;
                 max: z.ZodNumber;
             }, z.core.$strip>>;
+            supportsAudioMute: z.ZodBoolean;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         readonly setMask: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
@@ -156,6 +177,24 @@ export declare const privacyMaskCapability: {
                 }, z.core.$strip>>>;
             }, z.core.$strip>;
         }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /**
+         * Turn the camera's microphone on or off, at the camera.
+         *
+         * Deliberately its OWN mutation rather than a field on
+         * {@link PrivacyMaskPatchSchema}: `patch.enabled` already means "the video
+         * mask master switch", and overloading it would make one boolean mean two
+         * unrelated things on the same call. It is also the only method here whose
+         * write leaves the device in a state a later `getStatus` reads back
+         * verbatim, which is what makes it safe as a switch authority.
+         *
+         * A camera whose `getOptions().supportsAudioMute` is false must REJECT
+         * this rather than silently accept it — a write nothing applies is exactly
+         * what the switch group exists to remove.
+         */
+        readonly setAudioEnabled: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            enabled: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
     };
     readonly status: {
         readonly schema: z.ZodObject<{
@@ -177,6 +216,7 @@ export declare const privacyMaskCapability: {
                     }, z.core.$strip>>;
                 }, z.core.$strip>], "kind">;
             }, z.core.$strip>>;
+            audioEnabled: z.ZodNullable<z.ZodBoolean>;
             lastFetchedAt: z.ZodNumber;
         }, z.core.$strip>;
         readonly kind: "poll";
@@ -200,7 +240,27 @@ export declare const privacyMaskCapability: {
                 }, z.core.$strip>>;
             }, z.core.$strip>], "kind">;
         }, z.core.$strip>>;
+        audioEnabled: z.ZodNullable<z.ZodBoolean>;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;
 };
 export type IPrivacyMaskProvider = InferNativeProvider<typeof privacyMaskCapability>;
+/**
+ * Collapse a camera's PER-PROFILE audio flags into the one answer
+ * {@link PrivacyMaskStatusSchema.shape.audioEnabled} promises.
+ *
+ * Both firmwares this cap talks to store the flag per stream profile, and
+ * both let those profiles disagree. The rule is `some`, not `every`: privacy
+ * is only satisfied when NOTHING is carrying sound, so a camera whose sub
+ * stream is still audible must read as `true` and be switchable off — not as
+ * `false` because the main stream happens to be muted already.
+ *
+ * An empty list is `null` ("this camera reported no audio flag at all"),
+ * never `false`.
+ *
+ * Lives here rather than in each provider so the rule the schema documents
+ * and the rule the providers apply cannot drift apart.
+ */
+export declare function summarisePrivacyAudio(profiles: readonly {
+    readonly audioEnabled: boolean;
+}[]): boolean | null;

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

@@ -109,6 +109,20 @@ export declare const ReadSegmentBytesResultSchema: z.ZodObject<{
     data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
 }, z.core.$strip>;
 export type ReadSegmentBytesResult = z.infer<typeof ReadSegmentBytesResultSchema>;
+/**
+ * One GOP of a finalized segment, cut by byte range through the segment's own
+ * `mfra` (D31 on the D42 feeder path). `data` is the `ftyp`+`moov` head plus
+ * the single `moof`+`mdat` covering the requested instant — standalone-
+ * demuxable, never the whole file. When the segment's index cannot be parsed
+ * the provider degrades INSIDE the mechanism to the whole segment (still one
+ * `data`, `gopStartMs` = the segment start) — a worse read, not another path.
+ */
+export declare const ReadGopBytesResultSchema: z.ZodObject<{
+    data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+    gopStartMs: z.ZodNumber;
+    gopDurMs: z.ZodNumber;
+}, z.core.$strip>;
+export type ReadGopBytesResult = z.infer<typeof ReadGopBytesResultSchema>;
 export declare const recordingCapability: {
     readonly name: "recording";
     readonly scope: "system";
@@ -246,6 +260,19 @@ export declare const recordingCapability: {
         }, z.core.$strip>, z.ZodObject<{
             data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
         }, z.core.$strip>, "query">;
+        /** Read the single GOP of segment `startMs` covering `epochMs`, by mfra
+         *  byte range — the scrub-granular read (D31 letter on the feeder path).
+         *  See {@link ReadGopBytesResultSchema} for the degradation contract. */
+        readonly readGopBytes: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            profile: z.ZodString;
+            startMs: z.ZodNumber;
+            epochMs: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+            gopStartMs: z.ZodNumber;
+            gopDurMs: z.ZodNumber;
+        }, z.core.$strip>, "query">;
         readonly setDeviceConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
             config: z.ZodObject<{

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

@@ -317,6 +317,8 @@ export declare const BrokerStatsSchema: z.ZodObject<{
         channels: z.ZodNumber;
         supported: z.ZodBoolean;
     }, z.core.$strip>>>;
+    audioMuted: z.ZodOptional<z.ZodBoolean>;
+    audioMutedDropped: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 /**
  * Exporter-facing "profile restream" entry. Returned by

package/dist/capabilities/server-management.cap.d.ts

@@ -50,8 +50,8 @@ declare const ServerBootModeSchema: z.ZodEnum<{
  */
 declare const ServerUpdateStateSchema: z.ZodEnum<{
     idle: "idle";
-    checking: "checking";
     staging: "staging";
+    checking: "checking";
     "pending-restart": "pending-restart";
     "awaiting-confirmation": "awaiting-confirmation";
 }>;
@@ -123,8 +123,8 @@ declare const ServerPackageStatusSchema: z.ZodObject<{
     }>;
     updateState: z.ZodEnum<{
         idle: "idle";
-        checking: "checking";
         staging: "staging";
+        checking: "checking";
         "pending-restart": "pending-restart";
         "awaiting-confirmation": "awaiting-confirmation";
     }>;
@@ -189,8 +189,8 @@ export declare const serverManagementCapability: {
             }>;
             updateState: z.ZodEnum<{
                 idle: "idle";
-                checking: "checking";
                 staging: "staging";
+                checking: "checking";
                 "pending-restart": "pending-restart";
                 "awaiting-confirmation": "awaiting-confirmation";
             }>;

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { type InferProvider } from './capability-definition.js';
 import { DeviceType } from '../device/device-type.js';
+import { type InferProvider } from './capability-definition.js';
 /**
  * A single device snapshot returned as base64 JPEG/PNG.
  *