@camstack/types 1.2.42 → 1.2.43

package/dist/addon.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_event_category = require("./event-category-BE4PDZ_3.js");
-const require_sleep = require("./sleep-Cvi1JxZp.js");
+const require_sleep = require("./sleep-Bx9IIoT0.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
 //#region src/generated/collection-array-methods.ts
 /**

package/dist/addon.mjs

@@ -1,5 +1,5 @@
 import { t as EventCategory } from "./event-category-41fKf-q9.mjs";
-import { B as scopeKey, C as DeviceType, F as readNodePin, I as ReadinessRegistry, L as ReadinessTimeoutError, O as expandCapMethods, P as nodePin, a as asJsonObject, d as DEVICE_SCOPED_CAPS, f as isDeviceScopedCap, ft as DATAPLANE_SECRET_HEADER, ht as normalizeAddonInitResult, mt as BaseAddon, p as createDeviceProxy, pt as DisposerChain, s as asString, t as sleep, u as parseJsonUnknown, v as deviceOpsCapability, vt as emitReadiness, w as adminUiCapability, y as viewerUiCapability } from "./sleep-BmNKsY7v.mjs";
+import { C as DeviceType, F as readNodePin, L as ReadinessRegistry, O as expandCapMethods, P as nodePin, R as ReadinessTimeoutError, V as scopeKey, a as asJsonObject, d as DEVICE_SCOPED_CAPS, f as isDeviceScopedCap, gt as normalizeAddonInitResult, ht as BaseAddon, mt as DisposerChain, p as createDeviceProxy, pt as DATAPLANE_SECRET_HEADER, s as asString, t as sleep, u as parseJsonUnknown, v as deviceOpsCapability, w as adminUiCapability, y as viewerUiCapability, yt as emitReadiness } from "./sleep-DtstvzWm.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 //#region src/generated/collection-array-methods.ts
 /**

package/dist/cap-call-context.d.ts

@@ -28,8 +28,34 @@ export interface NodePinnedRequestOptions {
 /**
  * Build the tRPC request options that pin a single capability call to `nodeId`.
  * Pass as the second argument to `.query(input, …)` / `.mutate(input, …)`.
+ *
+ * ## The id is normalised here, and it has to be
+ *
+ * A forked addon reads its own node from `ctx.kernel.localNodeId`, and inside a
+ * worker that value is a RUNNER id — `hub/export-hap`, not `hub`. Routing
+ * compares a pin against real node ids, so such a pin matches nothing and the
+ * call fails with `no provider registered for cap "…"`. The local-first
+ * resolver already guarded against this (`localNodeId.split('/')[0]`), which
+ * made the hazard invisible: unpinned calls worked, and only an explicit pin —
+ * the thing you reach for when you specifically need THIS node — silently
+ * addressed a node that does not exist.
+ *
+ * Cost of it being missing: `addon-export-hap` pinned `decoder.getInfo` to its
+ * own node to read the host's hardware-decode backend. It never once answered,
+ * so every HomeKit egress transcode decoded in SOFTWARE — including 4K H.265 —
+ * while D67's whole premise was that the decoder addon is the authority on
+ * hardware. The warn said `decoding in SOFTWARE` and read as "this node has no
+ * hardware", which was false.
+ *
+ * Normalising in the ONE constructor fixes every caller at once, which is why
+ * it is here and not at the call sites.
  */
 export declare function nodePin(nodeId: string): NodePinnedRequestOptions;
+/**
+ * A runner id is `<nodeId>/<addonId>`; a node id has no slash. Taking the head
+ * is idempotent, so passing an already-clean id costs nothing.
+ */
+export declare function toNodeId(idOrRunnerId: string): string;
 /**
  * Read a per-call node pin out of a tRPC `op.context` (transport side).
  * Returns the pinned nodeId, or `undefined` when no pin is present.

package/dist/capabilities/index.d.ts

@@ -99,7 +99,7 @@ export { type IStorageCapProvider, StorageLocationTypeSchema, storageCapability,
 export { type EvictableUsage, type EvictResult, type IStorageEvictableProvider, storageEvictableCapability, } from './storage-evictable.cap.js';
 export { AbortUploadInputSchema as StorageAbortUploadInputSchema, BeginDownloadInputSchema as StorageBeginDownloadInputSchema, BeginDownloadResultSchema as StorageBeginDownloadResultSchema, BeginUploadInputSchema as StorageBeginUploadInputSchema, BeginUploadResultSchema as StorageBeginUploadResultSchema, EndDownloadInputSchema as StorageEndDownloadInputSchema, FinalizeUploadInputSchema as StorageFinalizeUploadInputSchema, type IStorageProviderImpl, ProviderInfoSchema as StorageProviderInfoSchema, ReadChunkInputSchema as StorageReadChunkInputSchema, storageProviderCapability, TestLocationResultSchema as StorageTestLocationResultSchema, WriteChunkInputSchema as StorageWriteChunkInputSchema, } from './storage-provider.cap.js';
 export type { AudioCodecTarget, BrokerAudioClient, BrokerClients, BrokerConsumerAttribution, BrokerConsumerKind, BrokerDecodedClient, BrokerEncodedClient, BrokerRtspClient, GetStreamWithCodecInput, PlaceholderReason, RtpSource, VideoCodecTarget, } from './stream-broker.cap.js';
-export { BrokerAudioClientSchema, BrokerClientsSchema, BrokerConsumerAttributionSchema, BrokerConsumerKindSchema, BrokerDecodedClientSchema, BrokerEncodedClientSchema, BrokerRtspClientSchema, GetStreamWithCodecInputSchema, PlaceholderReasonSchema, RtpSourceSchema, RtspRestreamEntrySchema, type StreamBrokerClient, type StreamFormat, StreamFormatSchema, streamBrokerCapability, } from './stream-broker.cap.js';
+export { BrokerAudioClientSchema, BrokerClientsSchema, BrokerConsumerAttributionSchema, BrokerConsumerKindSchema, BrokerDecodedClientSchema, BrokerEncodedClientSchema, BrokerRtspClientSchema, type EgressEncode, EgressEncodeSchema, type EgressRateControl, EgressRateControlSchema, type EgressTranscode, type EgressTranscodeRequest, EgressTranscodeRequestSchema, EgressTranscodeSchema, GetStreamWithCodecInputSchema, PlaceholderReasonSchema, RtpSourceSchema, RtspRestreamEntrySchema, type StreamBrokerClient, type StreamFormat, StreamFormatSchema, streamBrokerCapability, } from './stream-broker.cap.js';
 export { type ITerminalSessionProvider, type TerminalProfileInfo, TerminalProfileInfoSchema, type TerminalSessionInfo, TerminalSessionInfoSchema, terminalSessionCapability, } from './terminal-session.cap.js';
 export type { ITurnProvider } from './turn-provider.cap.js';
 export { TurnServerSchema, turnProviderCapability } from './turn-provider.cap.js';
@@ -172,11 +172,11 @@ export { type HardwareDecodeAccels, type HardwareEncoderId, type HardwareEncoder
 export { type IPowerMeterProvider, type PowerMeterStatus, PowerMeterStatusSchema, powerMeterCapability, } from './power-meter.cap.js';
 export { type GpsLocation, type IPresenceProvider, type PresenceStatus, PresenceStatusSchema, presenceCapability, } from './presence.cap.js';
 export { type IPressureSensorProvider, type PressureSensorStatus, PressureSensorStatusSchema, pressureSensorCapability, } from './pressure-sensor.cap.js';
-export { type IPrivacyMaskProvider, type PrivacyMaskOptions, PrivacyMaskOptionsSchema, type PrivacyMaskPatch, PrivacyMaskPatchSchema, type PrivacyMaskRegion, PrivacyMaskRegionSchema, type PrivacyMaskShape, PrivacyMaskShapeSchema, type PrivacyMaskStatus, PrivacyMaskStatusSchema, privacyMaskCapability, } from './privacy-mask.cap.js';
+export { type IPrivacyMaskProvider, type PrivacyMaskOptions, PrivacyMaskOptionsSchema, type PrivacyMaskPatch, PrivacyMaskPatchSchema, type PrivacyMaskRegion, PrivacyMaskRegionSchema, type PrivacyMaskShape, PrivacyMaskShapeSchema, type PrivacyMaskStatus, PrivacyMaskStatusSchema, privacyMaskCapability, summarisePrivacyAudio, } from './privacy-mask.cap.js';
 export { type IPtzProvider, PtzMoveCommandSchema, type PtzOptions, PtzOptionsSchema, PtzPositionSchema, PtzPresetSchema, type PtzStatus, PtzStatusSchema, ptzCapability, } from './ptz.cap.js';
 export { type IPtzAutotrackProvider, type PtzAutotrackRuntimeState, PtzAutotrackRuntimeStateSchema, type PtzAutotrackSettings, PtzAutotrackSettingsSchema, type PtzAutotrackStatus, PtzAutotrackStatusSchema, type PtzAutotrackTargetOption, PtzAutotrackTargetOptionSchema, ptzAutotrackCapability, } from './ptz-autotrack.cap.js';
 export { type IRebootProvider, rebootCapability } from './reboot.cap.js';
-export { type IRecordingProvider, type LocateSegmentResult, LocateSegmentResultSchema, type ReadSegmentBytesResult, ReadSegmentBytesResultSchema, type RecordingAvailability, RecordingAvailabilitySchema, type RecordingDays, RecordingDaysSchema, type RecordingDeviceUsage, RecordingDeviceUsageSchema, type RecordingLocationUsage, RecordingLocationUsageSchema, type RecordingManifest, RecordingManifestSchema, RecordingRangeSchema, type RecordingStatus, RecordingStatusSchema, type RecordingStorageUsage, RecordingStorageUsageSchema, recordingCapability, } from './recording.cap.js';
+export { type IRecordingProvider, type LocateSegmentResult, LocateSegmentResultSchema, type ReadGopBytesResult, ReadGopBytesResultSchema, type ReadSegmentBytesResult, ReadSegmentBytesResultSchema, type RecordingAvailability, RecordingAvailabilitySchema, type RecordingDays, RecordingDaysSchema, type RecordingDeviceUsage, RecordingDeviceUsageSchema, type RecordingLocationUsage, RecordingLocationUsageSchema, type RecordingManifest, RecordingManifestSchema, RecordingRangeSchema, type RecordingStatus, RecordingStatusSchema, type RecordingStorageUsage, RecordingStorageUsageSchema, recordingCapability, } from './recording.cap.js';
 export { type ExportDownload, ExportDownloadSchema, type ExportOptions, ExportOptionsSchema, type ExportRecord, ExportRecordSchema, ExportSpeedSchema, type ExportState, ExportStateSchema, ExportTimelapseSchema, type IRecordingExportProvider, recordingExportCapability, } from './recording-export.cap.js';
 export { type ISceneMonitorProvider, type SceneCheck, SceneCheckSchema, type SceneCondition, SceneConditionSchema, type SceneMonitor, SceneMonitorSchema, type SceneMonitorState, SceneMonitorStateSchema, type SceneMonitorStatus, SceneMonitorStatusSchema, type SceneReference, SceneReferenceSchema, sceneMonitorCapability, } from './scene-monitor.cap.js';
 export { type ZoneRule, type ZoneRuleMode, ZoneRuleModeEnum, ZoneRuleSchema, type ZoneRules, ZoneRulesArraySchema, } from './schemas/zone-rule.js';

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

@@ -442,11 +442,13 @@ 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";
     }>>>;
     fetchedAt: z.ZodNumber;
 }, z.core.$strip>;
@@ -1090,11 +1092,13 @@ 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";
                 }>;
                 label: z.ZodString;
                 costWhenOff: z.ZodString;
@@ -1102,6 +1106,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 +1118,12 @@ 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>], "kind">;
             }, z.core.$strip>>>;
             fetchedAt: z.ZodNumber;
@@ -1133,22 +1144,26 @@ 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";
             }>;
             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;
@@ -1156,6 +1171,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 +1183,12 @@ 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>], "kind">;
             }, z.core.$strip>>>;
             fetchedAt: z.ZodNumber;
@@ -1281,11 +1303,13 @@ 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";
             }>>>;
             fetchedAt: z.ZodNumber;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
@@ -1398,11 +1422,13 @@ 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";
             }>>>;
             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/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.
  *

package/dist/capabilities/stream-broker.cap.d.ts

@@ -420,6 +420,7 @@ export declare const EgressTranscodeRequestSchema: z.ZodObject<{
         h264_mp4toannexb: "h264_mp4toannexb";
         hevc_mp4toannexb: "hevc_mp4toannexb";
     }>>;
+    publishLocally: z.ZodOptional<z.ZodBoolean>;
     pixelFormat: z.ZodOptional<z.ZodEnum<{
         yuv420p: "yuv420p";
         nv12: "nv12";
@@ -450,6 +451,7 @@ export declare const EgressTranscodeSchema: z.ZodObject<{
     transcoded: z.ZodBoolean;
     encoder: z.ZodString;
     decodeHwAccel: z.ZodNullable<z.ZodString>;
+    camStreamId: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 export type EgressTranscode = z.infer<typeof EgressTranscodeSchema>;
 export declare const streamBrokerCapability: {
@@ -955,6 +957,7 @@ export declare const streamBrokerCapability: {
                 h264_mp4toannexb: "h264_mp4toannexb";
                 hevc_mp4toannexb: "hevc_mp4toannexb";
             }>>;
+            publishLocally: z.ZodOptional<z.ZodBoolean>;
             pixelFormat: z.ZodOptional<z.ZodEnum<{
                 yuv420p: "yuv420p";
                 nv12: "nv12";
@@ -983,6 +986,7 @@ export declare const streamBrokerCapability: {
             transcoded: z.ZodBoolean;
             encoder: z.ZodString;
             decodeHwAccel: z.ZodNullable<z.ZodString>;
+            camStreamId: z.ZodNullable<z.ZodString>;
         }, z.core.$strip>, "mutation">;
         /** Drop one reference. The child dies when the last holder releases. */
         readonly releaseEgressTranscode: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{

package/dist/capabilities/stream-params.cap.d.ts

@@ -1,6 +1,6 @@
 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';
 /** One of the camera's stream profiles. */
 export declare const StreamProfileSchema: z.ZodEnum<{
     sub: "sub";
@@ -183,7 +183,13 @@ export declare const StreamParamsOptionsSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 /** A partial change to one profile — every field optional; a provider
- *  ignores fields it doesn't support. */
+ *  ignores fields it doesn't support.
+ *
+ *  There is deliberately NO `audio` here. It existed until 2026-08-07,
+ *  reachable from no form and honoured by exactly one provider, while the
+ *  camera's microphone is a whole-device fact. It now has one writer,
+ *  `privacyMask.setAudioEnabled`, which writes every profile — see
+ *  `privacy-mask.cap.ts`. */
 export declare const StreamProfilePatchSchema: z.ZodObject<{
     width: z.ZodOptional<z.ZodNumber>;
     height: z.ZodOptional<z.ZodNumber>;
@@ -203,7 +209,6 @@ export declare const StreamProfilePatchSchema: z.ZodObject<{
         main: "main";
     }>>;
     gop: z.ZodOptional<z.ZodNumber>;
-    audio: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type StreamParamsStatus = z.infer<typeof StreamParamsStatusSchema>;
 export type StreamParamsOptions = z.infer<typeof StreamParamsOptionsSchema>;
@@ -316,7 +321,6 @@ export declare const streamParamsCapability: {
                     main: "main";
                 }>>;
                 gop: z.ZodOptional<z.ZodNumber>;
-                audio: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>;
         }, z.core.$strip>, z.ZodVoid, "mutation">;
         /**

package/dist/device/device-profile.d.ts

@@ -120,10 +120,18 @@ export interface DeviceProfile {
      */
     readonly defaults: DeviceProfileDefaults;
     /**
-     * Generic settings overrides (snapshot interval, pre-buffer flag,
-     * etc.). Same sticky semantics as defaults — applied on first read,
-     * operator override wins. Keys are dot-paths interpreted by the
-     * per-driver / per-addon config schema.
+     * Generic settings overrides, keyed by dot-path, intended to be
+     * interpreted by the per-driver / per-addon config schema.
+     *
+     * **Nothing reads this today.** It is a declared extension point with no
+     * consumer anywhere in the workspace, so any entry placed here is inert. It
+     * shipped populated — `snapshot.minRefreshIntervalSec: 3600` and
+     * `streamBroker.preBufferEnabled: false` on the battery profile — which read
+     * as live policy and were not: both behaviours are really enforced off
+     * `DeviceFeature.BatteryOperated` directly, by `BATTERY_DEFAULT_MAX_AGE_S`
+     * in `snapshot.addon.ts` and by `getEffectivePreBufferSec` in
+     * `stream-broker-manager.ts`. Emptied 2026-08-07; keep it empty until a
+     * reader exists, or an entry here is just documentation that lies.
      */
     readonly settings: Readonly<Record<string, unknown>>;
 }

package/dist/device/system-mirror.d.ts

@@ -62,6 +62,17 @@ export interface SystemMirrorApi extends SliceHandleApi {
                 addonId?: string;
             }): Promise<ReadonlyArray<DeviceInfo>>;
         };
+        /**
+         * Single-device metadata read. Required — `refreshDeviceMetadata`
+         * runs once per `device.registered` / `device.updated` event, and a
+         * full-catalog fetch there is what melts the hub during a
+         * deploy/restart storm (see `refreshDeviceMetadata`).
+         */
+        readonly getDevice: {
+            query(input: {
+                deviceId: number;
+            }): Promise<DeviceInfo | null>;
+        };
     };
     readonly deviceState: SliceHandleApi['deviceState'] & {
         readonly getAllSnapshots: {

package/dist/ffmpeg/encode-defaults.d.ts

@@ -56,6 +56,24 @@ export declare const WEBRTC_EGRESS_PROFILE: EncodeProfile;
  * audio plane (out-of-band), so this is `passthrough` exactly like the browser
  * — see the ADR for why the previous in-band Opus was encoded and discarded.
  */
+/**
+ * Alexa's egress asks for OPUS, and that is a change with a history.
+ *
+ * The previous profile encoded Opus IN-BAND into an MPEG-TS, where it was
+ * discarded: Opus is `stream_type 0x06` and the broker's demuxer maps only
+ * `0x0f` (aac), `0x03`/`0x04` (mp2) and `0x81` (ac3). Every frame it produced
+ * died at the demuxer, so the encode was replaced with `passthrough` — correct,
+ * because paying libopus for nothing is worse than silence.
+ *
+ * But `passthrough` means the egress emits NO audio at all, and Alexa's audio
+ * does not arrive by magic: it rides the published stream, which is what the
+ * WebRTC session dials. So the Echo had video and silence either way.
+ *
+ * Opus here now reaches the egress AUDIO SIDECAR — a separate RTP leg the
+ * restreamer grafts onto its SDP — which never touches the MPEG-TS demuxer that
+ * killed the in-band attempt. Same codec, different plane, and this one the
+ * consumer can actually negotiate.
+ */
 export declare const ALEXA_EGRESS_PROFILE: EncodeProfile;
 /** VBV window for a consumer whose budget is enforced per second (HomeKit). */
 export declare const RATE_CONTROL_TIGHT: FfmpegRateControl;