@camstack/types 1.2.177 → 1.2.179

package/dist/addon.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sleep = require("./sleep-B1ZwxAhh.js");
 const require_event_category = require("./event-category-BNJ9EE5B.js");
-const require_sleep = require("./sleep-CTHjJilA.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
 //#region src/generated/cap-input-defaults.ts
 /**
@@ -16,14 +16,20 @@ const require_err_msg = require("./err-msg-COpsHMw2.js");
 * Plain data, zero Zod: a forked runner must not import the schema barrel
 * (~144MB RSS per runner — D28).
 *
-* Coverage: 24 caps, 56 methods with defaults.
+* Coverage: 24 caps, 57 methods with defaults.
 */
 var CAP_INPUT_DEFAULTS = Object.freeze({
 	"addons": { "getLogs": { "limit": 100 } },
-	"audio-analyzer": { "analyseChunk": { "settings": { "__nested__": {
-		"minConfidence": .3,
-		"allowedClasses": []
-	} } } },
+	"audio-analyzer": {
+		"analyseChunk": { "settings": { "__nested__": {
+			"minConfidence": .3,
+			"allowedClasses": []
+		} } },
+		"attachDevice": { "settings": { "__nested__": {
+			"minConfidence": .3,
+			"allowedClasses": []
+		} } }
+	},
 	"audio-codec": {
 		"pullEncoded": { "maxCount": 8 },
 		"pullPcm": { "maxCount": 8 }

package/dist/addon.mjs

@@ -1,5 +1,5 @@
+import { D as adminUiCapability, E as DeviceType, G as scopeKey, H as ReadinessTimeoutError, M as expandCapMethods, R as nodePin, S as DEVICE_CHILDREN_BATCH_MAX, St as normalizeAddonInitResult, Tt as emitReadiness, V as ReadinessRegistry, a as asJsonObject, b as deviceOpsCapability, bt as DisposerChain, d as BOOT_RECOVERY_BACKOFF_MS, f as DEVICE_SCOPED_CAPS, h as createEventBusSliceSource, m as createDeviceProxy, p as isDeviceScopedCap, s as asString, t as sleep, u as parseJsonUnknown, vt as DATAPLANE_SECRET_HEADER, x as viewerUiCapability, xt as BaseAddon, z as readNodePin } from "./sleep-BnujYGPe.mjs";
 import { t as EventCategory } from "./event-category-DAXzJeTX.mjs";
-import { D as adminUiCapability, E as DeviceType, G as scopeKey, H as ReadinessTimeoutError, M as expandCapMethods, R as nodePin, S as DEVICE_CHILDREN_BATCH_MAX, V as ReadinessRegistry, _t as DATAPLANE_SECRET_HEADER, a as asJsonObject, b as deviceOpsCapability, bt as BaseAddon, d as BOOT_RECOVERY_BACKOFF_MS, f as DEVICE_SCOPED_CAPS, h as createEventBusSliceSource, m as createDeviceProxy, p as isDeviceScopedCap, s as asString, t as sleep, u as parseJsonUnknown, wt as emitReadiness, x as viewerUiCapability, xt as normalizeAddonInitResult, yt as DisposerChain, z as readNodePin } from "./sleep-ox21Ig4I.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 //#region src/generated/cap-input-defaults.ts
 /**
@@ -15,14 +15,20 @@ import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 * Plain data, zero Zod: a forked runner must not import the schema barrel
 * (~144MB RSS per runner — D28).
 *
-* Coverage: 24 caps, 56 methods with defaults.
+* Coverage: 24 caps, 57 methods with defaults.
 */
 var CAP_INPUT_DEFAULTS = Object.freeze({
 	"addons": { "getLogs": { "limit": 100 } },
-	"audio-analyzer": { "analyseChunk": { "settings": { "__nested__": {
-		"minConfidence": .3,
-		"allowedClasses": []
-	} } } },
+	"audio-analyzer": {
+		"analyseChunk": { "settings": { "__nested__": {
+			"minConfidence": .3,
+			"allowedClasses": []
+		} } },
+		"attachDevice": { "settings": { "__nested__": {
+			"minConfidence": .3,
+			"allowedClasses": []
+		} } }
+	},
 	"audio-codec": {
 		"pullEncoded": { "maxCount": 8 },
 		"pullPcm": { "maxCount": 8 }

package/dist/audio/audio-chunk-format.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The audio chunk plane's byte format, and the ONE expansion from a coded
+ * window to float samples (D455).
+ *
+ * ## Why a format at all
+ *
+ * D450 took the plane off its 8 → 16 kHz upsample: it carries the SOURCE
+ * RATE, and the one consumer that needs 16 kHz resamples next to the model.
+ * It left the FORMAT alone — the broker still turned each G.711 byte into a
+ * 4-byte f32le sample before the bytes entered the transport, so every leg of
+ * the plane carried four times the source. The plane crosses hub-main twice on
+ * the way to the analyzer, and the fleet's G.711 cameras are ~79 % of it.
+ *
+ * So the plane carries the source BYTES too, and whoever needs floats expands
+ * them where it needs them. That is the same argument D450 made for the rate,
+ * one step further along the same wire.
+ *
+ * ## Why the expansion lives here
+ *
+ * Two packages need it and they must never disagree: `addon-pipeline`'s broker
+ * (which still has to serve a subscriber that did NOT ask for coded bytes —
+ * `AudioChunkPlane` expands per subscription) and
+ * `addon-pipeline-orchestrator`'s `AudioWindowAccumulator` (which flushes an
+ * f32le window to the analyzer cap, whose `AudioChunkInput` contract is
+ * unchanged and stays f32le). Both bundle the bare `@camstack/types` entry
+ * into their own dist (`self-contained` externals), so this travels with a
+ * `camstack deploy` and needs no published server.
+ *
+ * A second μ-law table anywhere else is the defect this module exists to
+ * prevent. (`stream-broker.ts`'s `mulawToPcm` / `alawToPcm` are the ENCODE
+ * direction for the WebRTC egress — a different transform, not a copy.)
+ *
+ * ## Absent means f32le
+ *
+ * `format` is optional on the wire and its absence means `f32le` — today's
+ * bytes, byte for byte. A peer that never heard of the field is served what it
+ * has always been served, because the broker only emits a coded window to a
+ * subscription that DECLARED it accepts one (`AudioSubscribeOptions.accept`).
+ * That is the D448 `rawForward` negotiation, and it is what makes this
+ * deployable one addon at a time across three nodes.
+ */
+/** Every byte format the audio chunk plane can carry. `f32le` is the default. */
+export declare const AUDIO_CHUNK_FORMATS: readonly ["f32le", "pcmu", "pcma"];
+/**
+ * The byte format of a decoded audio chunk's `data`.
+ *
+ * - `f32le` — 4 bytes per sample, normalised IEEE 754 float in [-1, 1].
+ * - `pcmu` — ITU-T G.711 μ-law, 1 byte per sample.
+ * - `pcma` — ITU-T G.711 A-law, 1 byte per sample.
+ */
+export type AudioChunkFormat = (typeof AUDIO_CHUNK_FORMATS)[number];
+/** Type guard for a value that arrived over the wire as a format name. */
+export declare function isAudioChunkFormat(value: unknown): value is AudioChunkFormat;
+/**
+ * Bytes one sample of `format` occupies. This is the number every duration
+ * calculation over a chunk's `data` must use — a window accumulator that
+ * hard-codes 4 reports a quarter of the audio it actually holds and flushes
+ * four-second windows to a classifier expecting one.
+ */
+export declare function audioChunkBytesPerSample(format: AudioChunkFormat): number;
+/**
+ * Expand a CODED audio window to freshly-owned f32le bytes, 4-byte aligned at
+ * offset 0, so a caller can build a `Float32Array` view over them directly.
+ * The input may be a msgpack subview at any offset; nothing here reads it as
+ * anything but bytes.
+ *
+ * `f32le` is accepted and returns a copy, but a caller that already knows the
+ * format is `f32le` should not call this at all — it has the bytes. Both
+ * callers branch on the format first for exactly that reason, and the copy
+ * here exists so the return type is always owned rather than sometimes
+ * aliasing the argument.
+ */
+export declare function expandAudioChunkToF32le(data: Uint8Array, format: AudioChunkFormat): Uint8Array<ArrayBuffer>;

package/dist/audio/audio-scale-epoch.d.ts

@@ -0,0 +1,117 @@
+/**
+ * The instant the audio amplitude scale changed, and by how much (D459).
+ *
+ * ## What happened
+ *
+ * Until this epoch the native RTP G.711 decoder that feeds the audio chunk
+ * plane — `stream-broker/rtsp/audio-rtp-decoder.ts`, the PCM the audio
+ * CLASSIFIER and the dBFS level meter read — decoded μ-law at exactly 1/4 of
+ * its ITU-T G.711 value and A-law at exactly −1/8 (magnitude *and* sign). The
+ * WebRTC/Opus egress decoded the same bytes correctly in `g711-mulaw.ts`, so
+ * **the audio an operator HEARD was right and the audio the detector MEASURED
+ * was 4–8× quieter**, which is why it survived so long.
+ *
+ * Non-G.711 sources — AAC and Opus, decoded through the `audio-codec` cap —
+ * were always on the ITU-T scale and are NOT affected. Nothing here should
+ * ever be applied to them.
+ *
+ * ## What this module is for, and what it is NOT for
+ *
+ * It is the ONE place the two numbers live, so no caller re-derives them and
+ * no second constant can disagree. It exists for two readers:
+ *
+ *  - **A person re-calibrating a threshold.** Every absolute-dBFS gate
+ *    authored before the epoch against a native G.711 camera is now that many
+ *    dB too permissive: `NcAudioCondition.dbThreshold`,
+ *    `RecordingTriggers.audioThresholdDbfs`, `audioMarkerMinDbfs`, and the
+ *    viewer's per-grid `audioDb`.
+ *  - **Anything drawing a level across the epoch.** A graph that spans it
+ *    shows a step of 12.04 dB (PCMU) or 18.06 dB (PCMA) on the affected
+ *    cameras. `audioScaleEraOf` is how a reader says which side a sample is
+ *    on instead of leaving the step unexplained.
+ *
+ * **It is NOT a gain to apply to a sample.** Stored history is NOT rewritten
+ * and live audio is NOT re-scaled: the decoder is correct now, and a second
+ * authority that "fixes up" a number the decoder already got right is the
+ * defect again with an extra place to argue with. Nor can history be
+ * retro-corrected honestly — `DecodedAudioChunk` never carried the codec, so
+ * a stored `AudioEvent.dbfs` does not say which of the two factors (or
+ * neither) applied to it. Guessing per row is exactly the move that wrote the
+ * original defect.
+ */
+/** Spelling of the epoch, so the millisecond constant is readable. */
+export declare const AUDIO_SCALE_EPOCH_ISO = "2026-09-11T00:00:00.000Z";
+/**
+ * The instant, in epoch milliseconds. A reading at or after it is on the
+ * ITU-T scale; a reading before it, from a native G.711 camera, is 12–18 dB
+ * low.
+ *
+ * It is the DAY, not the deploy minute, and deliberately so: the correction
+ * reaches each node when that node's `addon-pipeline` is redeployed, which is
+ * neither simultaneous across the fleet nor knowable from here. A reader that
+ * treats the boundary as fuzzy by a few hours is reading it correctly; one
+ * that treats a sample 200 ms after it as authoritative is not.
+ */
+export declare const AUDIO_SCALE_EPOCH_MS: number;
+/**
+ * How many dB a pre-epoch reading from a native G.711 camera was LOW, by law.
+ *
+ * Derived, not measured: the old tables were under-scaled by exactly 4 (μ-law)
+ * and exactly 8 (A-law) on all 256 codes, and `20·log10` turns an amplitude
+ * factor into dB. A-law's extra octave is its own separate defect — its
+ * magnitudes were built on a 13-bit scale and never shifted to 16.
+ *
+ * To convert a threshold authored on the old scale to the same intent on the
+ * ITU-T scale, ADD this (a −55 dBFS gate on a PCMU camera meant −42.96).
+ */
+export type G711Law = 'PCMU' | 'PCMA';
+export declare const G711_SCALE_CORRECTION_DB: Readonly<Record<G711Law, number>>;
+/**
+ * Restate a dBFS number that was MEASURED through the pre-epoch decoder as the
+ * same intent on the ITU-T scale (D460).
+ *
+ * ## When this applies, and when it is the wrong thing to reach for
+ *
+ * An absolute-dBFS number in this repo is one of two things, and only one of
+ * them converts:
+ *
+ *  - **A statement about the scale** — "-55 dBFS is near silence", "-25 dBFS
+ *    is loud". It was true on the ITU-T scale before the epoch and it is true
+ *    after. The defect was never in the number; it was that 19 of this hub's
+ *    25 cameras did not obey it. Converting such a number takes something
+ *    correct and makes it wrong, in order to preserve a bug.
+ *  - **A measurement taken through the old decoder** — a value someone read
+ *    off a meter that under-reported by exactly 4× (PCMU) or 8× (PCMA). It
+ *    describes a sound that was really {@link G711_SCALE_CORRECTION_DB} dB
+ *    louder. That is what this function is for.
+ *
+ * Telling the two apart is a question about PROVENANCE, not about arithmetic,
+ * and it cannot be answered from the number. It is answered by the comment the
+ * author left — which is why `scripts/check-dbfs-era.mts` makes leaving one
+ * mandatory.
+ *
+ * ## Why a function and not a typed-in number
+ *
+ * `-55 + 12.04` written into a source file is, six months later, completely
+ * indistinguishable from a threshold somebody simply preferred. Calling this
+ * keeps the derivation, the law, and the original measurement all visible at
+ * the call site, so a future reader can disagree with the *premise* instead of
+ * having to reverse-engineer the sum.
+ *
+ * **This is not a runtime gain.** It converts an authored CONSTANT once, where
+ * it is declared. It must never be applied to a live sample or a stored
+ * `AudioEvent.dbfs`: the decoder is correct now, and a second authority
+ * adjusting numbers the decoder already got right is the original defect with
+ * an extra place to argue with (D459).
+ */
+export declare function ituDbfsFromPreEpoch(law: G711Law, authoredDbfs: number): number;
+/**
+ * Which amplitude scale a dBFS reading taken at `timestampMs` is on.
+ *
+ * `unknown` is a real answer and never collapses into `itu`: a row with no
+ * usable timestamp carries no claim about its scale, and calling it current
+ * would make the oldest readings look freshly calibrated — the direction that
+ * destroys the ability to explain the step at all (D393).
+ */
+export type AudioScaleEra = 'pre-itu' | 'itu' | 'unknown';
+export declare function audioScaleEraOf(timestampMs: number): AudioScaleEra;

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

@@ -19,6 +19,37 @@ declare const AudioAnalysisSettingsSchema: z.ZodObject<{
     minConfidence: z.ZodDefault<z.ZodNumber>;
     allowedClasses: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
+/**
+ * `attachDevice` — the analyzer PULLS a camera's audio from the broker (D461).
+ *
+ * Until D461 the orchestrator drained the broker's chunk plane, accumulated
+ * ~1 s windows and pushed them back out as `analyseChunk`. It neither produced
+ * nor consumed the audio: the PCM crossed hub-main twice for a process that
+ * only buffered it. `attachDevice` inverts the direction — the analyzer opens
+ * its own `subscribeAudioChunks` against the broker and the subscriber IS the
+ * decoder, so the coded G.711 bytes D455 put on the plane stay coded all the
+ * way to the one expansion that feeds the model.
+ *
+ * The orchestrator still owns the POLICY (the `audioMode` gate, the on-motion
+ * window, the per-device node assignment, the settings read) and therefore
+ * still owns the attach/detach pair. It no longer owns the bytes.
+ */
+declare const AudioAttachDeviceInputSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    brokerId: z.ZodString;
+    ingestNodeId: z.ZodString;
+    settings: z.ZodObject<{
+        minConfidence: z.ZodDefault<z.ZodNumber>;
+        allowedClasses: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const AudioAttachDeviceResultSchema: z.ZodObject<{
+    attached: z.ZodBoolean;
+    replaced: z.ZodBoolean;
+}, z.core.$strip>;
+declare const AudioDetachDeviceResultSchema: z.ZodObject<{
+    detached: z.ZodBoolean;
+}, z.core.$strip>;
 declare const AudioClassificationResultSchema: z.ZodObject<{
     labels: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         className: z.ZodString;
@@ -132,6 +163,36 @@ export declare const audioAnalyzerCapability: {
             }, z.core.$strip>>>>;
             inferenceMs: z.ZodNumber;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Start pulling this camera's audio from the broker, in THIS process.
+         * Returns as soon as the attachment exists — the first
+         * `subscribeAudioChunks` retries with backoff behind it, because the
+         * broker for a camStream may not be registered yet (that tolerance moved
+         * with the poller, D461). Replaces any live attachment for the device.
+         */
+        readonly attachDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            brokerId: z.ZodString;
+            ingestNodeId: z.ZodString;
+            settings: z.ZodObject<{
+                minConfidence: z.ZodDefault<z.ZodNumber>;
+                allowedClasses: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            attached: z.ZodBoolean;
+            replaced: z.ZodBoolean;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Stop pulling this camera's audio and release the broker subscription.
+         * Idempotent. A detach that never arrives is the one failure mode this
+         * split adds, which is why `AudioChunkPlane` reaps a subscription nobody
+         * drains rather than trusting it (D461).
+         */
+        readonly detachDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            detached: z.ZodBoolean;
+        }, z.core.$strip>, "mutation">;
         readonly isReady: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
         readonly dispose: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodVoid, "mutation">;
         /**
@@ -147,4 +208,4 @@ export declare const audioAnalyzerCapability: {
     };
 };
 export type IAudioAnalyzerProvider = InferProvider<typeof audioAnalyzerCapability>;
-export { AudioAnalysisResultSchema, AudioAnalysisSettingsSchema, AudioClassificationResultSchema };
+export { AudioAnalysisResultSchema, AudioAnalysisSettingsSchema, AudioClassificationResultSchema, AudioAttachDeviceInputSchema, AudioAttachDeviceResultSchema, AudioDetachDeviceResultSchema, };

package/dist/capabilities/index.d.ts

@@ -28,7 +28,7 @@ export type { Alert, AlertSeverity, AlertStatus } from './alerts.cap.js';
 export { AlertSchema, AlertSeveritySchema, AlertSourceSchema, AlertStatusSchema, alertsCapability, } from './alerts.cap.js';
 export { audioAnalysisCapability, type IAudioAnalysisProvider } from './audio-analysis.cap.js';
 export type { AudioAnalyzerGlobalConfig, AudioBackendChoice, IAudioAnalyzerProvider, } from './audio-analyzer.cap.js';
-export { AUDIO_BACKEND_CHOICES, AudioAnalysisResultSchema, AudioAnalysisSettingsSchema, AudioClassificationResultSchema, audioAnalyzerCapability, DEFAULT_AUDIO_ANALYZER_CONFIG, } from './audio-analyzer.cap.js';
+export { AUDIO_BACKEND_CHOICES, AudioAnalysisResultSchema, AudioAnalysisSettingsSchema, AudioAttachDeviceInputSchema, AudioAttachDeviceResultSchema, AudioClassificationResultSchema, AudioDetachDeviceResultSchema, audioAnalyzerCapability, DEFAULT_AUDIO_ANALYZER_CONFIG, } from './audio-analyzer.cap.js';
 export { AudioCodecInfoSchema, AudioDecodeSessionConfigSchema, AudioEncodedChunkSchema, AudioEncodeSessionConfigSchema, AudioPcmChunkSchema, audioCodecCapability, type IAudioCodecCapProvider, PcmSampleFormatSchema, } from './audio-codec.cap.js';
 export { AuthResultSchema, authProviderCapability } from './auth-provider.cap.js';
 export { ArchiveEntrySchema, ArchiveManifestSchema, BackupDestinationInfoSchema, BackupEntrySchema, type BackupRun, type BackupRunPhase, BackupRunPhaseSchema, BackupRunSchema, type BackupRunState, BackupRunStateSchema, type BackupTriggerResult, BackupTriggerResultSchema, backupCapability, type IBackupProvider, LocationStatSchema, } from './backup.cap.js';
@@ -92,7 +92,7 @@ export { FrameLazyCountersSchema, FrameLazyMetricsSchema, MotionSourceEnum, Moti
 export { AudioChunkInputSchema, AudioClassificationLabelSchema, AudioLevelSchema, BoundingBoxSchema, FrameInputSchema, SpatialDetectionSchema, } from './schemas/detection-shared.js';
 export { CameraMetricsSchema, CameraMetricsWithDeviceIdSchema, OrchestratorMetricsSchema, } from './schemas/orchestrator-metrics.js';
 export type { CameraStream, CamProfile, CamStreamKind, DecodedAudioChunkWire, FrameHandleFormat, ProfileRtspEntry, ProfileSlot, ProfileSlotStatus, SubscribeAudioChunksInput, SubscribeAudioChunksResult, SubscribeFramesInput, SubscribeFramesResult, } from './schemas/streaming-shared.js';
-export { BrokerStatsSchema, BrokerStatusSchema, CAM_PROFILE_ORDER, CameraStreamSchema, CamProfileSchema, CamStreamKindSchema, CamStreamResolutionSchema, DecodedAudioChunkSchema, DecodedFrameSchema, EncodedPacketSchema, FrameHandleFormatSchema, FrameHandleSchema, makeProfileBrokerId, makeSourceBrokerId, ProfileRtspEntrySchema, ProfileSlotSchema, ProfileSlotStatusSchema, parseProfileBrokerId, StreamSourceEntrySchema, StreamSourceSchema, SubscribeAudioChunksInputSchema, SubscribeAudioChunksResultSchema, SubscribeFramesInputSchema, SubscribeFramesResultSchema, selectAssignedProfileSlots, } from './schemas/streaming-shared.js';
+export { BrokerStatsSchema, BrokerStatusSchema, CAM_PROFILE_ORDER, CameraStreamSchema, CamProfileSchema, CamStreamKindSchema, CamStreamResolutionSchema, AudioChunkFormatSchema, DecodedAudioChunkSchema, DecodedFrameSchema, EncodedPacketSchema, FrameHandleFormatSchema, FrameHandleSchema, makeProfileBrokerId, makeSourceBrokerId, ProfileRtspEntrySchema, ProfileSlotSchema, ProfileSlotStatusSchema, parseProfileBrokerId, StreamSourceEntrySchema, StreamSourceSchema, SubscribeAudioChunksInputSchema, SubscribeAudioChunksResultSchema, SubscribeFramesInputSchema, SubscribeFramesResultSchema, selectAssignedProfileSlots, } from './schemas/streaming-shared.js';
 export { buildEventKindDescriptor, EVENT_KIND_BY_CAP, EVENTFUL_CAP_NAMES, type SensorEventKindDescriptor, } from './sensor-event-kinds.js';
 export { type ImageContract, ImageContractSchema, type ImageContractState, ImageContractStateSchema, type IServerManagementProvider, type ServerBootMode, ServerBootModeSchema, type ServerPackageStatus, ServerPackageStatusSchema, type ServerRollbackInfo, ServerRollbackInfoSchema, type ServerUpdateActionResult, ServerUpdateActionResultSchema, type ServerUpdateCheckResult, ServerUpdateCheckResultSchema, type ServerUpdateState, ServerUpdateStateSchema, serverManagementCapability, type WrapperEvidence, WrapperEvidenceSchema, type WrapperIdentity, WrapperIdentitySchema, type WrapperKind, WrapperKindSchema, } from './server-management.cap.js';
 export { type BulkRecord, BulkRecordSchema, type CollectionColumn, CollectionColumnSchema, type CollectionIndex, CollectionIndexSchema, type ISettingsStoreProvider, type MutationFilter, MutationFilterSchema, QueryFilterSchema, SettingsRecordSchema, type SettingsStoreClient, settingsStoreCapability, } from './settings-store.cap.js';

package/dist/capabilities/notification-rules.cap.d.ts

@@ -239,6 +239,12 @@ export type NcOccupancyCondition = z.infer<typeof NcOccupancyConditionSchema>;
  * number. An operator (or a UI) that writes `60` meaning "60 decibels, quite
  * loud" would author a threshold NO sample can ever reach, and the rule would
  * look broken rather than mis-configured. The schema range rejects it instead.
+ *
+ * Untouched by the D459 scale correction, and structurally so: -96 dBFS is
+ * where 16-bit digital silence sits on ANY decoder, right or wrong. It
+ * describes the container, not a calibration made through one.
+ *
+ * @dbfs-era scale-bound
  */
 export declare const NC_AUDIO_DBFS_FLOOR = -96;
 /**

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

@@ -261,11 +261,21 @@ export type SubscribeFramesResult = z.infer<typeof SubscribeFramesResultSchema>;
  * (the wire-serialisable supertype of `Buffer`) to match `DecodedFrameSchema`
  * / `EncodedPacketSchema`'s precedent; a `Buffer` is assignable to it.
  */
+export declare const AudioChunkFormatSchema: z.ZodEnum<{
+    f32le: "f32le";
+    pcmu: "pcmu";
+    pcma: "pcma";
+}>;
 export declare const DecodedAudioChunkSchema: z.ZodObject<{
     data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
     sampleRate: z.ZodNumber;
     channels: z.ZodNumber;
     timestamp: z.ZodNumber;
+    format: z.ZodOptional<z.ZodEnum<{
+        f32le: "f32le";
+        pcmu: "pcmu";
+        pcma: "pcma";
+    }>>;
 }, z.core.$strip>;
 export type DecodedAudioChunkWire = z.infer<typeof DecodedAudioChunkSchema>;
 /**
@@ -278,6 +288,11 @@ export type DecodedAudioChunkWire = z.infer<typeof DecodedAudioChunkSchema>;
 export declare const SubscribeAudioChunksInputSchema: z.ZodObject<{
     brokerId: z.ZodString;
     tag: z.ZodOptional<z.ZodString>;
+    accept: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        f32le: "f32le";
+        pcmu: "pcmu";
+        pcma: "pcma";
+    }>>>>;
 }, z.core.$strip>;
 export type SubscribeAudioChunksInput = z.infer<typeof SubscribeAudioChunksInputSchema>;
 /** Result of `stream-broker.subscribeAudioChunks`. */

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

@@ -308,11 +308,11 @@ declare const VideoCodecTargetSchema: z.ZodEnum<{
 }>;
 export type VideoCodecTarget = z.infer<typeof VideoCodecTargetSchema>;
 declare const AudioCodecTargetSchema: z.ZodEnum<{
+    pcmu: "pcmu";
     none: "none";
     copy: "copy";
     opus: "opus";
     aac: "aac";
-    pcmu: "pcmu";
 }>;
 export type AudioCodecTarget = z.infer<typeof AudioCodecTargetSchema>;
 export declare const GetStreamWithCodecInputSchema: z.ZodObject<{
@@ -323,11 +323,11 @@ export declare const GetStreamWithCodecInputSchema: z.ZodObject<{
         copy: "copy";
     }>;
     audio: z.ZodOptional<z.ZodEnum<{
+        pcmu: "pcmu";
         none: "none";
         copy: "copy";
         opus: "opus";
         aac: "aac";
-        pcmu: "pcmu";
     }>>;
     profile: z.ZodOptional<z.ZodEnum<{
         high: "high";
@@ -410,11 +410,11 @@ export declare const EgressEncodeSchema: z.ZodObject<{
     }, z.core.$strip>;
     audio: z.ZodUnion<readonly [z.ZodLiteral<"passthrough">, z.ZodObject<{
         codec: z.ZodEnum<{
+            pcmu: "pcmu";
+            pcma: "pcma";
             copy: "copy";
             opus: "opus";
             aac: "aac";
-            pcmu: "pcmu";
-            pcma: "pcma";
         }>;
         bitrateKbps: z.ZodOptional<z.ZodNumber>;
         sampleRateHz: z.ZodOptional<z.ZodNumber>;
@@ -481,11 +481,11 @@ export declare const EgressTranscodeRequestSchema: z.ZodObject<{
         }, z.core.$strip>;
         audio: z.ZodUnion<readonly [z.ZodLiteral<"passthrough">, z.ZodObject<{
             codec: z.ZodEnum<{
+                pcmu: "pcmu";
+                pcma: "pcma";
                 copy: "copy";
                 opus: "opus";
                 aac: "aac";
-                pcmu: "pcmu";
-                pcma: "pcma";
             }>;
             bitrateKbps: z.ZodOptional<z.ZodNumber>;
             sampleRateHz: z.ZodOptional<z.ZodNumber>;
@@ -605,11 +605,11 @@ export declare const streamBrokerCapability: {
                 }, z.core.$strip>;
                 audio: z.ZodUnion<readonly [z.ZodLiteral<"passthrough">, z.ZodObject<{
                     codec: z.ZodEnum<{
+                        pcmu: "pcmu";
+                        pcma: "pcma";
                         copy: "copy";
                         opus: "opus";
                         aac: "aac";
-                        pcmu: "pcmu";
-                        pcma: "pcma";
                     }>;
                     bitrateKbps: z.ZodOptional<z.ZodNumber>;
                     sampleRateHz: z.ZodOptional<z.ZodNumber>;
@@ -1034,11 +1034,11 @@ export declare const streamBrokerCapability: {
                 copy: "copy";
             }>;
             audio: z.ZodOptional<z.ZodEnum<{
+                pcmu: "pcmu";
                 none: "none";
                 copy: "copy";
                 opus: "opus";
                 aac: "aac";
-                pcmu: "pcmu";
             }>>;
             profile: z.ZodOptional<z.ZodEnum<{
                 high: "high";
@@ -1144,11 +1144,11 @@ export declare const streamBrokerCapability: {
                 }, z.core.$strip>;
                 audio: z.ZodUnion<readonly [z.ZodLiteral<"passthrough">, z.ZodObject<{
                     codec: z.ZodEnum<{
+                        pcmu: "pcmu";
+                        pcma: "pcma";
                         copy: "copy";
                         opus: "opus";
                         aac: "aac";
-                        pcmu: "pcmu";
-                        pcma: "pcma";
                     }>;
                     bitrateKbps: z.ZodOptional<z.ZodNumber>;
                     sampleRateHz: z.ZodOptional<z.ZodNumber>;
@@ -1223,6 +1223,11 @@ export declare const streamBrokerCapability: {
         readonly subscribeAudioChunks: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             brokerId: z.ZodString;
             tag: z.ZodOptional<z.ZodString>;
+            accept: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                f32le: "f32le";
+                pcmu: "pcmu";
+                pcma: "pcma";
+            }>>>>;
         }, z.core.$strip>, z.ZodObject<{
             subscriptionId: z.ZodString;
         }, z.core.$strip>, "mutation">;
@@ -1234,6 +1239,11 @@ export declare const streamBrokerCapability: {
             sampleRate: z.ZodNumber;
             channels: z.ZodNumber;
             timestamp: z.ZodNumber;
+            format: z.ZodOptional<z.ZodEnum<{
+                f32le: "f32le";
+                pcmu: "pcmu";
+                pcma: "pcma";
+            }>>;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         readonly unsubscribeAudioChunks: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             subscriptionId: z.ZodString;

package/dist/encode-profile.d.ts

@@ -46,11 +46,11 @@ export declare const VideoEncodeSchema: z.ZodObject<{
 export type VideoEncode = z.infer<typeof VideoEncodeSchema>;
 export declare const AudioEncodeSchema: z.ZodUnion<readonly [z.ZodLiteral<"passthrough">, z.ZodObject<{
     codec: z.ZodEnum<{
+        pcmu: "pcmu";
+        pcma: "pcma";
         copy: "copy";
         opus: "opus";
         aac: "aac";
-        pcmu: "pcmu";
-        pcma: "pcma";
     }>;
     bitrateKbps: z.ZodOptional<z.ZodNumber>;
     sampleRateHz: z.ZodOptional<z.ZodNumber>;
@@ -92,11 +92,11 @@ export declare const EncodeProfileSchema: z.ZodObject<{
     }, z.core.$strip>;
     audio: z.ZodUnion<readonly [z.ZodLiteral<"passthrough">, z.ZodObject<{
         codec: z.ZodEnum<{
+            pcmu: "pcmu";
+            pcma: "pcma";
             copy: "copy";
             opus: "opus";
             aac: "aac";
-            pcmu: "pcmu";
-            pcma: "pcma";
         }>;
         bitrateKbps: z.ZodOptional<z.ZodNumber>;
         sampleRateHz: z.ZodOptional<z.ZodNumber>;

package/dist/generated/addon-api.d.ts

@@ -693,6 +693,20 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof audioAnalyzerCapability.methods.classify.output>;
             meta: object;
         }>;
+        attachDevice: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof audioAnalyzerCapability.methods.attachDevice.input>;
+            output: z.infer<typeof audioAnalyzerCapability.methods.attachDevice.output>;
+            meta: object;
+        }>;
+        detachDevice: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof audioAnalyzerCapability.methods.detachDevice.input>;
+            output: z.infer<typeof audioAnalyzerCapability.methods.detachDevice.output>;
+            meta: object;
+        }>;
         isReady: TRPCQueryProcedure<{
             input: {
                 nodeId?: string | undefined;

package/dist/generated/cap-input-defaults.d.ts

@@ -11,7 +11,7 @@
  * Plain data, zero Zod: a forked runner must not import the schema barrel
  * (~144MB RSS per runner — D28).
  *
- * Coverage: 24 caps, 56 methods with defaults.
+ * Coverage: 24 caps, 57 methods with defaults.
  */
 export declare const CAP_INPUT_DEFAULTS: Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, unknown>>>>>>;
 /**

package/dist/generated/device-proxy.d.ts

@@ -86,6 +86,7 @@ import type { zoneAnalyticsCapability } from '../capabilities/zone-analytics.cap
 import type { zoneRulesCapability } from '../capabilities/zone-rules.cap.js';
 import type { zonesCapability } from '../capabilities/zones.cap.js';
 import type { addonSettingsCapability } from '../capabilities/addon-settings.cap.js';
+import type { audioAnalyzerCapability } from '../capabilities/audio-analyzer.cap.js';
 import type { cameraPipelineConfigCapability } from '../capabilities/camera-pipeline-config.cap.js';
 import type { deviceAdoptionCapability } from '../capabilities/device-adoption.cap.js';
 import type { deviceExportCapability } from '../capabilities/device-export.cap.js';
@@ -278,6 +279,7 @@ export interface DeviceProxy {
     readonly zoneRules?: InferDeviceProxyCap<typeof zoneRulesCapability>;
     readonly zones?: InferDeviceProxyCap<typeof zonesCapability>;
     readonly addonSettings: Pick<InferDeviceProxyCap<typeof addonSettingsCapability>, 'getDeviceSettings' | 'updateDeviceSettings'>;
+    readonly audioAnalyzer: Pick<InferDeviceProxyCap<typeof audioAnalyzerCapability>, 'detachDevice'>;
     readonly cameraPipelineConfig: Pick<InferDeviceProxyCap<typeof cameraPipelineConfigCapability>, 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
     readonly deviceAdoption: Pick<InferDeviceProxyCap<typeof deviceAdoptionCapability>, 'getStatus'>;
     readonly deviceExport: Pick<InferDeviceProxyCap<typeof deviceExportCapability>, 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;

package/dist/generated/method-access-map.d.ts

@@ -6,7 +6,7 @@
  * scope+access check inside `protectedProcedure` (see
  * `server/backend/src/api/trpc/trpc.middleware.ts`).
  *
- * Coverage: 1027 method paths across 129 capabilities.
+ * Coverage: 1029 method paths across 129 capabilities.
  */
 import type { CapabilityMethodAccess } from '../capabilities/capability-definition.js';
 export interface MethodAccessRecord {

package/dist/generated/method-device-selectors.d.ts

@@ -6,8 +6,8 @@
  * system-scope cap that takes a deviceId was previously never device-filtered
  * — see the generator header).
  *
- * Coverage: 372 methods carry a device reference, of which
- * 137 are on SYSTEM-scope caps.
+ * Coverage: 374 methods carry a device reference, of which
+ * 139 are on SYSTEM-scope caps.
  *
  * Top-level fields, number arrays, and one-level arrays of objects carrying
  * a numeric device field (targets[].deviceId) are all mapped; the matcher

package/dist/generated/system-proxy.d.ts

@@ -59,7 +59,7 @@ export interface SystemProxy {
     readonly addonSettings: Pick<InferProvider<typeof addonSettingsCapability>, 'getGlobalSettings' | 'updateGlobalSettings' | 'getIntegrationSettings'>;
     readonly addonWidgets: Pick<InferProvider<typeof addonWidgetsCapability>, 'listWidgets'>;
     readonly alerts: Pick<InferProvider<typeof alertsCapability>, 'emit' | 'update' | 'list' | 'getUnreadCount' | 'markRead' | 'markAllRead' | 'dismiss'>;
-    readonly audioAnalyzer: Pick<InferProvider<typeof audioAnalyzerCapability>, 'analyseChunk' | 'classify' | 'isReady' | 'dispose' | 'reprobeAudioEngine'>;
+    readonly audioAnalyzer: Pick<InferProvider<typeof audioAnalyzerCapability>, 'analyseChunk' | 'classify' | 'attachDevice' | 'isReady' | 'dispose' | 'reprobeAudioEngine'>;
     readonly audioCodec: Pick<InferProvider<typeof audioCodecCapability>, 'listSupportedCodecs' | 'canHandle' | 'createDecodeSession' | 'createEncodeSession' | 'closeSession' | 'pushEncodedFrame' | 'pullPcm' | 'pushPcm' | 'pullEncoded' | 'flushEncode' | 'listActiveSessions'>;
     readonly backup: Pick<InferProvider<typeof backupCapability>, 'listDestinations' | 'trigger' | 'listRuns' | 'cancel' | 'list' | 'listLocations' | 'getEntries' | 'restore' | 'delete' | 'listArchives' | 'upsertDestinationPolicy' | 'previewSchedule' | 'listSchedules' | 'upsertSchedule' | 'deleteSchedule'>;
     readonly broker: Pick<InferProvider<typeof brokerCapability>, 'list' | 'get' | 'listProviders' | 'add' | 'remove' | 'testConnection' | 'getSettings' | 'setSettings' | 'getBrokerConfig' | 'getSettingsSchema' | 'testSettings' | 'publish' | 'subscribe' | 'unsubscribe' | 'getState' | 'getStatus'>;