@camstack/types 1.2.41 → 1.2.43

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

@@ -441,6 +441,15 @@ declare const CameraStatusSchema: z.ZodObject<{
         active: z.ZodBoolean;
         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";
+    }>>>;
     fetchedAt: z.ZodNumber;
 }, z.core.$strip>;
 declare const NodeInferenceDeviceSchema: z.ZodObject<{
@@ -1062,6 +1071,128 @@ export declare const pipelineOrchestratorCapability: {
                 settings: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
             }, z.core.$strip>>>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * The whole per-camera function switch group, DERIVED — never a stored
+         * list ([D61](../../../../docs/decisions/adr-0067.md)).
+         *
+         * The group adds no state. Each switch is a view onto the authority that
+         * already owned it (`deviceManager.setDisabled`,
+         * `deviceManager.setWrapperActive`, `RecordingConfig.enabled`,
+         * `notificationRules.setDeviceMuted`), and `switch.authority` says which.
+         * Availability comes from `deviceManager.listBindableCapsForDeviceType`,
+         * so a deployment with no audio analyzer renders no audio switch.
+         *
+         * `auth: 'view'` deliberately — a NON-admin must be able to see that a
+         * camera is quiet because somebody switched it off. Only the mutation is
+         * admin-gated.
+         */
+        readonly getCameraSwitches: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, 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";
+                }>;
+                label: z.ZodString;
+                costWhenOff: z.ZodString;
+                available: z.ZodBoolean;
+                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<{
+                    kind: z.ZodLiteral<"device-disabled">;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"wrapper-binding">;
+                    capName: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    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>], "kind">;
+            }, z.core.$strip>>>;
+            fetchedAt: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Flip ONE switch, routed to its existing authority.
+         *
+         * Never writes a parallel map: `recording` patches `RecordingConfig.enabled`
+         * and leaves `bands` byte-identical (clearing bands to express "off"
+         * destroys the operator's authored schedule and turning the camera back on
+         * would silently record nothing), and the two pipeline switches write the
+         * SAME wrapper binding the legacy `pipelineEnabled` / `audioEnabled`
+         * booleans were migrated onto.
+         *
+         * Rejects a switch this camera does not offer rather than persisting a
+         * write nothing reads.
+         */
+        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";
+            }>;
+            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";
+                }>;
+                label: z.ZodString;
+                costWhenOff: z.ZodString;
+                available: z.ZodBoolean;
+                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<{
+                    kind: z.ZodLiteral<"device-disabled">;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"wrapper-binding">;
+                    capName: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    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>], "kind">;
+            }, z.core.$strip>>>;
+            fetchedAt: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
         /**
          * Server-composed aggregated status for a single camera.
          *
@@ -1171,6 +1302,15 @@ export declare const pipelineOrchestratorCapability: {
                 active: z.ZodBoolean;
                 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";
+            }>>>;
             fetchedAt: z.ZodNumber;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
@@ -1281,6 +1421,15 @@ export declare const pipelineOrchestratorCapability: {
                 active: z.ZodBoolean;
                 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";
+            }>>>;
             fetchedAt: z.ZodNumber;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** List every template the operator has saved. */

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { type InferProvider } from './capability-definition.js';
 import type { ConfigField } from '../interfaces/config-ui.js';
+import { type InferProvider } from './capability-definition.js';
 /**
  * A bounding box in NORMALIZED [0,1] frame coordinates for `getNativeCrop`. The
  * decode worker resolves it against the RETAINED native frame's real pixel dims,
@@ -60,6 +60,27 @@ declare const DetailResultSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type DetailParent = z.infer<typeof DetailParentSchema>;
 export type DetailResult = z.infer<typeof DetailResultSchema>;
+/**
+ * Why an executing node REFUSED a stateless step run (`runStatelessStep`).
+ *
+ * A refusal is a first-class answer, not an error, because the caller's next
+ * move depends on WHICH one it is — and because "the pass produced nothing"
+ * must never be reachable without a named, counted cause. The two tiers:
+ *
+ * - **node-level** (`unknown-step`, `model-not-servable`) — this node can
+ *   never serve this (step, model) pair. The caller drops it from its rotation
+ *   and retries the same work elsewhere; nothing about the work changes.
+ * - **work-level** (`unreadable-frame`, `execution-failed`) — this node is
+ *   fine, this one request is not. Retrying it on another node would only
+ *   spread the same failure.
+ */
+declare const StatelessStepRefusalSchema: z.ZodEnum<{
+    "unknown-step": "unknown-step";
+    "model-not-servable": "model-not-servable";
+    "unreadable-frame": "unreadable-frame";
+    "execution-failed": "execution-failed";
+}>;
+export type StatelessStepRefusal = z.infer<typeof StatelessStepRefusalSchema>;
 /**
  * Source enum for motion signals fed to the runner. Extensible — add
  * new variants here when new motion-trigger paths are wired in
@@ -606,6 +627,92 @@ export declare const pipelineRunnerCapability: {
                 nativeFaceShortSidePx: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
         }, z.core.$strip>>, "mutation">;
+        /**
+         * Run ONE enrichment step against caller-supplied pixels, with NO camera
+         * session — no attach, no frame handle, no device affinity.
+         *
+         * ## Why this exists next to `runDetailSubtree` and not inside it
+         *
+         * `runDetailSubtree` resolves its step tree from the LIVE ATTACH STATE. That
+         * is correct for it: its reason to exist is a frame HANDLE, and a handle is
+         * only resolvable while a decode session is open. But it makes the method
+         * useless to anything walking history — cameras run `detectionMode:
+         * 'on-motion'` and detach ~30 s after motion stops, so a fleet-wide
+         * embedding rebuild found most cameras detached and rebuilt only whatever
+         * happened to be attached at that second (measured 2026-08-06: 1125 tracks
+         * scanned, 121 rebuilt, 601 refused as "camera is not attached").
+         *
+         * A caller that ships its own pixels needs none of that machinery. So this
+         * method takes the three things a step actually needs — an image, a box, a
+         * step id — resolves the step from the CATALOG rather than from an
+         * attachment, and runs it on whichever node the caller pinned.
+         *
+         * ## What it deliberately keeps
+         *
+         * The crop rectangle is derived by the SAME `deriveDetailCropRect` call the
+         * live detail plane uses, from the same cluster-wide convention
+         * ([D52](../../../docs/decisions/adr-0052.md)). `frameJpeg` is a FULL frame,
+         * never a pre-cut tile, for exactly the reason `runDetailSubtree` documents:
+         * a caller that cuts is a second feature space.
+         *
+         * ## What it deliberately drops
+         *
+         * No device jump and no `deviceKey`: the jump roster comes from the attach
+         * config, which does not exist here. The step runs on the node's default
+         * engine. This is a maintenance path, not a latency-sensitive one.
+         *
+         * ## Routing
+         *
+         * NOT device-bound. `sourceDeviceId` is DIAGNOSTIC — the camera whose track
+         * these pixels came from, so every log line on the executing node can carry
+         * `tags: { deviceId }`. It is deliberately not named `deviceId`: that field
+         * is a routing hint that would send the call to the camera's owning node,
+         * which is the placement constraint this method exists to remove. Callers
+         * choose the node with `nodePin(nodeId)`; unpinned, an unowned call is
+         * served hub-in-process like any other singleton.
+         */
+        readonly runStatelessStep: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            stepId: z.ZodString;
+            modelId: z.ZodString;
+            frameJpeg: z.ZodString;
+            bbox: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                w: z.ZodNumber;
+                h: z.ZodNumber;
+            }, z.core.$strip>;
+            className: z.ZodString;
+            sourceDeviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"ran">;
+            nodeId: z.ZodString;
+            modelId: z.ZodString;
+            details: z.ZodArray<z.ZodObject<{
+                stepId: z.ZodString;
+                className: z.ZodString;
+                score: z.ZodNumber;
+                bbox: z.ZodOptional<z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    w: z.ZodNumber;
+                    h: z.ZodNumber;
+                }, z.core.$strip>>;
+                embedding: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                alignedCropJpeg: z.ZodOptional<z.ZodString>;
+                nativeFaceShortSidePx: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"refused">;
+            nodeId: z.ZodString;
+            reason: z.ZodEnum<{
+                "unknown-step": "unknown-step";
+                "model-not-servable": "model-not-servable";
+                "unreadable-frame": "unreadable-frame";
+                "execution-failed": "execution-failed";
+            }>;
+            detail: z.ZodString;
+        }, z.core.$strip>], "kind">, "mutation">;
     };
 };
 export type IPipelineRunnerProvider = InferProvider<typeof pipelineRunnerCapability>;
@@ -623,4 +730,15 @@ export type IPipelineRunnerProvider = InferProvider<typeof pipelineRunnerCapabil
  */
 export type RunDetailSubtreeInput = Parameters<IPipelineRunnerProvider['runDetailSubtree']>[0];
 export type RunDetailSubtreeResult = NonNullable<Awaited<ReturnType<IPipelineRunnerProvider['runDetailSubtree']>>>;
+/**
+ * Named input/output types for `runStatelessStep`, derived the same way and for
+ * the same reason as the `runDetailSubtree` pair above — the method's input
+ * stays an inline `z.object({…})` literal so `scripts/lib/parse-cap.ts` keeps
+ * classifying it correctly. Here the classification wanted is the OPPOSITE one:
+ * there is no `deviceId: z.number(` in the body, so the method is NOT
+ * device-bound and never lands on `DeviceProxy` — placement is the caller's
+ * `nodePin`, not the camera's owner.
+ */
+export type RunStatelessStepInput = Parameters<IPipelineRunnerProvider['runStatelessStep']>[0];
+export type RunStatelessStepResult = Awaited<ReturnType<IPipelineRunnerProvider['runStatelessStep']>>;
 export { RunnerCameraConfigSchema, RunnerLocalLoadSchema, RunnerLocalMetricsSchema };

package/dist/capabilities/platform-probe.cap.d.ts

@@ -277,12 +277,12 @@ export declare const platformProbeCapability: {
                 coreml: "coreml";
                 openvino: "openvino";
                 none: "none";
-                tensorrt: "tensorrt";
-                cuda: "cuda";
                 videotoolbox: "videotoolbox";
-                nvdec: "nvdec";
                 vaapi: "vaapi";
                 qsv: "qsv";
+                cuda: "cuda";
+                tensorrt: "tensorrt";
+                nvdec: "nvdec";
                 d3d11va: "d3d11va";
                 dxva2: "dxva2";
                 amf: "amf";

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<{
@@ -355,6 +382,7 @@ export declare const recordingCapability: {
                 operator: "operator";
                 retention: "retention";
                 quota: "quota";
+                maintenance: "maintenance";
             }>>;
         }, z.core.$strip>, z.ZodObject<{
             floorMs: z.ZodNullable<z.ZodNumber>;
@@ -393,12 +421,14 @@ export declare const recordingCapability: {
                 rescan: "rescan";
                 "retention-run": "retention-run";
                 relocate: "relocate";
+                "orphan-audit": "orphan-audit";
             }>;
             reason: z.ZodEnum<{
                 manual: "manual";
                 operator: "operator";
                 retention: "retention";
                 quota: "quota";
+                maintenance: "maintenance";
             }>;
             deviceId: z.ZodNullable<z.ZodNumber>;
             nodeId: z.ZodString;

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.
  *