@camstack/types 1.2.43 → 1.2.45

package/dist/interfaces/camera-switches.d.ts

@@ -18,6 +18,19 @@
  * | `notifications` | `notificationRules.setDeviceMuted` | `NotificationCenter.evaluateAndEnqueue` returns before any rule is evaluated |
  * | `privacy-mask` | `privacyMask.setMask({ enabled })` → the CAMERA | the camera blanks the masked regions itself; every stream and recording carries the black boxes |
  * | `device-audio` | `privacyMask.setAudioEnabled` → the CAMERA | the camera stops encoding an audio track at all; every consumer sees silent video |
+ * | `broker-audio` | `streamBroker.setDeviceAudioMute` → `DeviceOverride.audioMuted` | `StreamBroker.setAudioMuted` drops the audio plane at the source: no `type:'audio'` packet leaves `fanOutEncoded`, no RTP reaches the restreamer, and the restreamer serves the video-only SDP |
+ *
+ * ## `device-audio` and `broker-audio` are two functions, not two knobs
+ *
+ * They look adjacent and they are not the same control ([D83](../../../../docs/decisions/adr-0083.md)):
+ * `device-audio` writes the CAMERA, so it is hardware privacy — the microphone
+ * genuinely stops, it survives CamStack entirely, and it costs a multi-second
+ * encoder restart on every flip. `broker-audio` writes THIS server, so it is
+ * instant, vendor-independent and reversible without touching the camera, and
+ * a camera that ignores or lacks the ISAPI/Reolink control is still silenced.
+ * D62 forbids a second switch that *disagrees* with the first; these two
+ * cannot disagree, because neither reads the other's store — the camera holds
+ * one, the broker holds the other, and each reports its own fact.
  *
  * ## The two switches whose authority is not on this server
  *
@@ -83,6 +96,7 @@ export declare const CameraSwitchIdSchema: z.ZodEnum<{
     notifications: "notifications";
     "object-detection": "object-detection";
     "device-audio": "device-audio";
+    "broker-audio": "broker-audio";
 }>;
 export type CameraSwitchId = z.infer<typeof CameraSwitchIdSchema>;
 /**
@@ -96,6 +110,10 @@ export type CameraSwitchId = z.infer<typeof CameraSwitchIdSchema>;
  * `object-detection` despite feeding it: a mask blanks REGIONS, so its blast
  * radius is partial, and the "broadest first" rule does not rank a partial
  * control above a whole-function one.
+ *
+ * `broker-audio` sits directly BELOW `device-audio` by the same source-first
+ * rule: the camera's microphone feeds the broker, so silencing the camera
+ * leaves the broker's mute with nothing to suppress; the reverse is not true.
  */
 export declare const CAMERA_SWITCH_ORDER: readonly CameraSwitchId[];
 /**
@@ -119,6 +137,8 @@ export declare const CameraSwitchAuthoritySchema: z.ZodDiscriminatedUnion<[z.Zod
 }, 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">;
 export type CameraSwitchAuthority = z.infer<typeof CameraSwitchAuthoritySchema>;
 /**
@@ -149,6 +169,7 @@ export declare const CameraSwitchSchema: z.ZodObject<{
         notifications: "notifications";
         "object-detection": "object-detection";
         "device-audio": "device-audio";
+        "broker-audio": "broker-audio";
     }>;
     label: z.ZodString;
     costWhenOff: z.ZodString;
@@ -174,6 +195,8 @@ export declare const CameraSwitchSchema: z.ZodObject<{
     }, 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>;
 export type CameraSwitch = z.infer<typeof CameraSwitchSchema>;
@@ -189,6 +212,7 @@ export declare const CameraSwitchGroupSchema: z.ZodObject<{
             notifications: "notifications";
             "object-detection": "object-detection";
             "device-audio": "device-audio";
+            "broker-audio": "broker-audio";
         }>;
         label: z.ZodString;
         costWhenOff: z.ZodString;
@@ -214,6 +238,8 @@ export declare const CameraSwitchGroupSchema: z.ZodObject<{
         }, 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;
@@ -305,6 +331,28 @@ export interface CameraSwitchDerivationInput {
      * `null` = the cap is bound to this camera but did not answer.
      */
     readonly privacyMask: PrivacyMaskSwitchState | null;
+    /**
+     * The BROKER's audio-plane policy for this camera, read from the
+     * stream-broker on the device's source-owner node. `null` = the broker did
+     * not answer, which renders no control rather than a control defaulted to
+     * "audio flows".
+     */
+    readonly brokerAudio: BrokerAudioSwitchState | null;
+}
+/** What the stream-broker reported about its audio plane for one camera. */
+export interface BrokerAudioSwitchState {
+    /**
+     * `DeviceOverride.audioMuted` — the broker's own persisted policy. `true`
+     * means the broker drops this camera's audio on every plane it serves.
+     *
+     * There is no `supported` companion, deliberately. Muting a camera that is
+     * currently silent is not a dead control: the policy governs what happens
+     * when sound DOES appear (a camera unmuted at the device, a stream that
+     * only carries audio at night), so it is meaningful to set in advance.
+     * That is the opposite of the privacy mask with zero zones, where flipping
+     * the master enable is provably a no-op until something else changes.
+     */
+    readonly muted: boolean;
 }
 /** What the camera-probed audio switch reported for one camera. */
 export interface DeviceAudioSwitchState {

package/dist/interfaces/stream-broker.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import type { SubscribeAudioChunksResult, SubscribeFramesInput, SubscribeFramesResult } from '../capabilities/schemas/streaming-shared.js';
+import type { BrokerStatsSchema, BrokerStatusSchema, SubscribeAudioChunksResult, SubscribeFramesInput, SubscribeFramesResult } from '../capabilities/schemas/streaming-shared.js';
 import type { BrokerConsumerAttribution } from '../capabilities/stream-broker.cap.js';
 import type { FrameFormat } from '../types/io.js';
 import type { FrameHandle } from './frame-handle.js';
@@ -161,54 +161,24 @@ export interface AudioSubscribeOptions {
      */
     readonly tag?: string;
 }
-export type BrokerStatus = 'idle' | 'connecting' | 'streaming' | 'error' | 'stopped';
-export interface BrokerStats {
-    readonly status: BrokerStatus;
-    readonly inputFps: number;
-    readonly decodeFps: number;
-    readonly encodedSubscribers: number;
-    readonly decodedSubscribers: number;
-    readonly uptimeMs: number;
-    /** Measured bitrate in kbps (averaged over 2s window) */
-    readonly bitrateKbps: number;
-    /** Time between last two keyframes in ms (IDR interval) */
-    readonly idrIntervalMs: number;
-    /** Detected video codec (h264, h265) */
-    readonly codec?: string;
-    /** Total bytes received since broker start */
-    readonly totalBytes: number;
-    /** Total encoded packets received since broker start */
-    readonly packetCount: number;
-    /** Number of connected RTSP restream clients */
-    readonly rtspClients: number;
-    /** Number of connected TCP pipe clients */
-    readonly pipeClients: number;
-    /** Pre-buffer configured duration in seconds */
-    readonly preBufferSec: number;
-    /** Pre-buffer actual buffered duration in ms */
-    readonly preBufferMs: number;
-    /** Pre-buffer packet count */
-    readonly preBufferPackets: number;
-    /**
-     * Moleculer node id of the decoder provider currently servicing this
-     * stream's decoded subscribers. `null` until the deferred decoder is
-     * created (no decoded clients yet, or codec not detected).
-     */
-    readonly decoderNodeId: string | null;
-    /**
-     * Detected audio track parameters from the RTSP DESCRIBE / SDP. Null
-     * when the stream has no audio track or the broker is still in cold
-     * start. `supported` reflects whether the local native + ffmpeg-based
-     * decoder pipeline can produce PCM chunks for downstream consumers
-     * (audio-analyzer). When `false`, the codec is detected but skipped.
-     */
-    readonly audio?: {
-        readonly codec: string;
-        readonly sampleRate: number;
-        readonly channels: number;
-        readonly supported: boolean;
-    } | null;
-}
+/**
+ * Broker lifecycle state. Inferred from `BrokerStatusSchema` — the enum the
+ * wire actually validates against.
+ */
+export type BrokerStatus = z.infer<typeof BrokerStatusSchema>;
+/**
+ * Live broker telemetry: the payload of `streamBroker.getBrokerStats` and of
+ * the stats push the admin-UI panel subscribes to.
+ *
+ * Inferred from `BrokerStatsSchema` in
+ * `capabilities/schemas/streaming-shared.ts`, which is the schema the cap
+ * method validates its output against — so the schema IS the type. This was a
+ * hand-written twin until 2026-08-08: two shapes, neither generated from the
+ * other, and a field added to one and not the other compiled fine and then
+ * silently disappeared on the wire. Every field is documented on the schema;
+ * do not restate it here, and never re-introduce a second declaration.
+ */
+export type BrokerStats = z.infer<typeof BrokerStatsSchema>;
 export interface IStreamBroker {
     readonly deviceId: string;
     readonly status: BrokerStatus;

package/dist/node.d.ts

@@ -8,3 +8,7 @@ export { canonicalDeviceFingerprint, diffExportTargets, resolveExportFingerprint
 export type { DeviceExportShape, ExportDelta, ExportTargetEntry, } from './utils/export-reconciler.js';
 export { FfmpegProcess } from './ffmpeg/process.js';
 export type { FfmpegProcessOptions, FfmpegExit, FfmpegExitClass } from './ffmpeg/process.js';
+export { Fmp4FragmentPlane } from './ffmpeg/fmp4-fragment-plane.js';
+export type { Fmp4CloseReason, Fmp4Packet, Fmp4PrebufferOptions, Fmp4PrebufferStats, Fmp4SubscribeInput, Fmp4SubscriberInfo, Fmp4Subscription, } from './ffmpeg/fmp4-fragment-plane.js';
+export { Fmp4FragmentChild } from './ffmpeg/fmp4-fragment-child.js';
+export type { Fmp4FragmentChildArgs, Fmp4FragmentChildDeps, } from './ffmpeg/fmp4-fragment-child.js';