@camstack/types 1.2.177 → 1.2.179

package/dist/interfaces/recording-config.d.ts

@@ -74,6 +74,30 @@ export type RecordingObjectTriggerClass = z.infer<typeof RecordingObjectTriggerC
  * sensori su UNA camera è già oltre qualunque installazione osservata.
  */
 export declare const MAX_SENSOR_TRIGGER_DEVICES = 16;
+/**
+ * What the bands editor OFFERS when an operator first ticks "audio above
+ * threshold" on a band. Not a schema default: an absent `audioThresholdDbfs`
+ * means the audio source is not listened to at all, and it stays absent until
+ * asked for.
+ *
+ * It lived as a bare `-30` inline in `RecordingBandsEditor.tsx`, which is how
+ * a calibration hides: unnamed, unexplained, and invisible to any guard. D460
+ * gave it a name so the claim below can be read and disagreed with.
+ *
+ * **Not shifted at the D459 epoch.** `-30 dBFS is loud enough to be worth
+ * recording` is a statement about the scale, not a number anybody read off the
+ * pre-epoch decoder — there is no recorded measurement behind it, and absent
+ * evidence of measurement the provenance test says a scale statement stays put
+ * (the reasoning is D460's, and the same answer `SILENCE_FLOOR_DBFS` gets).
+ *
+ * As with `audioMarkerMinDbfs`, the epoch makes this seed START working rather
+ * than become too permissive: on the old scale a PCMU camera had to reach a
+ * true -18 dBFS to read -30, so the trigger was nearly dead on 19 of 25
+ * cameras. A band seeded with it now fires roughly as the editor implies.
+ *
+ * @dbfs-era itu
+ */
+export declare const RECORDING_AUDIO_TRIGGER_OFFERED_DBFS = -30;
 /** Which detectors trigger an `events`-mode band. */
 export declare const RecordingTriggersSchema: z.ZodObject<{
     motion: z.ZodOptional<z.ZodBoolean>;

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

@@ -4,6 +4,7 @@ import type { BrokerConsumerAttribution } from '../capabilities/stream-broker.ca
 import type { FrameRef } from '../types/frame-view.js';
 import type { FrameFormat } from '../types/io.js';
 import type { FrameHandle } from './frame-handle.js';
+import type { AudioChunkFormat } from '../audio/audio-chunk-format.js';
 export declare const DecoderStatsSchema: z.ZodObject<{
     inputFps: z.ZodNumber;
     outputFps: z.ZodNumber;
@@ -167,6 +168,12 @@ export interface DecodedAudioChunk {
     readonly sampleRate: number;
     readonly channels: number;
     readonly timestamp: number;
+    /**
+     * Byte format of `data`. ABSENT MEANS `f32le` (D455). A chunk carrying
+     * `pcmu` / `pcma` holds ONE byte per sample and is only ever delivered to a
+     * subscription whose `accept` list named that format.
+     */
+    readonly format?: AudioChunkFormat;
 }
 export interface AudioSubscribeOptions {
     /**
@@ -175,6 +182,12 @@ export interface AudioSubscribeOptions {
      * (`audio-analyzer`, …). Missing tag → recorded as `'unknown'`.
      */
     readonly tag?: string;
+    /**
+     * Byte formats this subscriber can READ (D455). The broker serves a chunk's
+     * own format when it is named here and expands to `f32le` otherwise, so a
+     * subscriber is never handed bytes it cannot interpret. Absent = `f32le`.
+     */
+    readonly accept?: readonly AudioChunkFormat[];
 }
 /**
  * Broker lifecycle state. Inferred from `BrokerStatusSchema` — the enum the

package/dist/notification/audio-condition.d.ts

@@ -1,36 +1,3 @@
-/**
- * audio-condition — the authoring logic behind the sustained-sound condition
- * (`NcConditions.audio`), pure and UI-framework-free.
- *
- * WHY IT LIVES HERE
- * ─────────────────
- * Same reason as `condition-taxonomy.ts` next door: two editors author this
- * condition (the admin UI and the viewer), the vocabulary it offers is already
- * in this package (`AUDIO_MACRO_LABELS`), and a second copy of "what a cleared
- * threshold writes" is a mirror free to drift. The viewer keeps its own copy
- * because it is a separate app with its own toolchain; every surface that CAN
- * import `@camstack/types` uses this one.
- *
- * Four behaviours here are not cosmetic:
- *
- *  1. **dBFS is negative-going.** `0` is full scale; digital silence reads
- *     {@link NC_AUDIO_DBFS_FLOOR}. A control that let an operator author `60`
- *     meaning "loud" would write a threshold no sample can reach, and the rule
- *     would look broken rather than mis-configured. Every write is clamped.
- *  2. **Neither filter given = the engine REFUSES.** With no level floor and no
- *     labels every sample is trivially a hit, so the window would fire on
- *     silence. {@link audioIsFailClosed} is how an editor says that BEFORE the
- *     save instead of shipping a rule that never notifies and never says why.
- *  3. **Both label spellings are the same label.** The hub's taxonomy serves
- *     `audio-dog`; the macro catalog and an operator both say `dog`, and the
- *     matcher normalizes the prefix away on both sides. Selection therefore
- *     compares NORMALIZED ids — a rule authored in the admin UI must not read
- *     as "nothing selected" on the phone.
- *  4. **A stored label the build does not know stays visible.** It is offered
- *     as an explicitly-unknown, removable choice, never silently dropped:
- *     rewriting the rule the operator is looking at is worse than showing a
- *     stale id.
- */
 import { type NcAudioCondition } from '../capabilities/notification-rules.cap.js';
 import type { NcTaxonomy } from '../catalogs/nc-taxonomy.js';
 /** Strip the taxonomy's `audio-` namespace: `audio-dog` and `dog` are one label. */
@@ -50,8 +17,21 @@ export declare function normalizeAudioLabel(value: string): string;
 export declare function audioKindId(macroId: string): string;
 /** Level bounds, in dBFS. Negative-going: the ceiling is full scale. */
 export declare const NC_AUDIO_DB_MIN = -96;
+/**
+ * Full scale. The ceiling of dBFS itself on any decoder, not a calibration —
+ * untouched by D459 and untouchable by anything like it.
+ *
+ * @dbfs-era scale-bound
+ */
 export declare const NC_AUDIO_DB_MAX = 0;
-/** Step of the level control — 3 dB is one perceptual notch, not one unit. */
+/**
+ * Step of the level control — 3 dB is one perceptual notch, not one unit.
+ *
+ * A step between two levels, so it survives any uniform scale change: 3 dB is
+ * the same interval before and after the D459 epoch.
+ *
+ * @dbfs-era relative
+ */
 export declare const NC_AUDIO_DB_STEP = 3;
 /**
  * Offered when the operator turns the level filter ON. NOT a schema default:
@@ -66,8 +46,42 @@ export declare const NC_AUDIO_DB_STEP = 3;
  * operator turned the filter on for, and the rule looks broken rather than
  * mis-seeded. The offered floor is the QUIET end of that measured band; the
  * editor says which way the number runs rather than leaving it to be inferred.
+ *
+ * ⚠ **That measurement was taken on the pre-D459 scale, and D460 moved this
+ * constant because of it.** Until {@link AUDIO_SCALE_EPOCH_MS} the native RTP
+ * G.711 decoder reported levels 12.04 dB low (PCMU) or 18.06 dB low (PCMA).
+ *
+ * This is the ONE absolute-dBFS number in the repo that is a MEASUREMENT
+ * rather than a statement about the scale, and it is the only one with a
+ * recorded provenance — which is exactly why it is also the only shared
+ * constant that converts. Three things agree that the camera it was measured
+ * on spoke PCMU:
+ *
+ *  - 19 of this hub's 25 cameras with audio are PCMU, 5 AAC, 1 L16, 0 PCMA
+ *    (codec census over 10 h of `audio: track detected`, 2026-09-11);
+ *  - **-55..-26 dBFS is not a close cry on a true scale.** -26 is a quiet
+ *    room. Read as a PCMU measurement the band is -43..-14, which is exactly
+ *    where a cry a metre from the microphone sits;
+ *  - there is no PCMA camera on this installation, so the only candidate
+ *    correction is mu-law's.
+ *
+ * So the band is restated, not re-guessed: the offered floor stays "the QUIET
+ * end of the measured band", and the band moves to where it was always really
+ * sitting. {@link ituDbfsFromPreEpoch} does the arithmetic so the derivation
+ * survives in the source instead of becoming a number somebody preferred.
+ *
+ * `Math.round` is the control's own granularity, not a fudge: the editor's
+ * level field is an integer stepper and `patchAudio` clamps through
+ * `clampInt`, so a fractional seed could never reach storage anyway.
+ *
+ * **This changes no existing rule.** It is what an editor OFFERS when the
+ * level filter is switched on with nothing stored; every `dbThreshold` an
+ * operator already authored is untouched, and those are a separate question
+ * — see D460 on why they are declared rather than migrated.
+ *
+ * @dbfs-era pre-itu-pcmu
  */
-export declare const NC_AUDIO_DB_OFFERED = -55;
+export declare const NC_AUDIO_DB_OFFERED: number;
 export declare const NC_AUDIO_HIT_PERCENT_MIN = 1;
 export declare const NC_AUDIO_HIT_PERCENT_MAX = 100;
 export declare const NC_AUDIO_SAMPLING_MIN_SEC = 1;

package/dist/{sleep-CTHjJilA.js → sleep-B1ZwxAhh.js}

@@ -1,5 +1,121 @@
 const require_event_category = require("./event-category-BNJ9EE5B.js");
 let zod = require("zod");
+//#region src/audio/audio-chunk-format.ts
+/**
+* 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. */
+var AUDIO_CHUNK_FORMATS = [
+	"f32le",
+	"pcmu",
+	"pcma"
+];
+/** Type guard for a value that arrived over the wire as a format name. */
+function isAudioChunkFormat(value) {
+	return typeof value === "string" && AUDIO_CHUNK_FORMATS.includes(value);
+}
+/**
+* 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.
+*/
+function audioChunkBytesPerSample(format) {
+	return format === "f32le" ? 4 : 1;
+}
+/**
+* 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.
+*/
+function expandAudioChunkToF32le(data, format) {
+	if (format === "f32le") {
+		const copy = new Uint8Array(data.byteLength);
+		copy.set(data);
+		return copy;
+	}
+	const table = format === "pcmu" ? ULAW_TABLE : ALAW_TABLE;
+	const out = new Float32Array(data.length);
+	for (let i = 0; i < data.length; i++) out[i] = table[data[i]];
+	return new Uint8Array(out.buffer);
+}
+/**
+* Build the μ-law decode table (ITU-T G.711). Each of the 256 byte values maps
+* to a 16-bit PCM sample, normalised to [-1.0, 1.0] for f32le output.
+*
+* Moved here verbatim from `audio-rtp-decoder.ts`, which no longer decodes:
+* it buffers the coded bytes and the plane's consumers expand.
+*/
+function buildUlawTable() {
+	const table = new Float32Array(256);
+	for (let i = 0; i < 256; i++) {
+		const complemented = ~i & 255;
+		const sign = (complemented & 128) !== 0 ? -1 : 1;
+		const exponent = complemented >> 4 & 7;
+		table[i] = sign * ((8 * (complemented & 15) + 132 << exponent) - 132) / 32768;
+	}
+	return table;
+}
+/** Build the A-law decode table (ITU-T G.711). */
+function buildAlawTable() {
+	const table = new Float32Array(256);
+	for (let i = 0; i < 256; i++) {
+		const xored = i ^ 85;
+		const sign = (xored & 128) !== 0 ? 1 : -1;
+		const exponent = xored >> 4 & 7;
+		const mantissa = xored & 15;
+		table[i] = sign * (exponent === 0 ? 16 * mantissa + 8 : 16 * mantissa + 264 << exponent - 1) / 32768;
+	}
+	return table;
+}
+var ULAW_TABLE = buildUlawTable();
+var ALAW_TABLE = buildAlawTable();
+//#endregion
 //#region src/interfaces/config-ui.ts
 /** Predefined tabs with standard label, icon, and sort order.
 *
@@ -1533,11 +1649,20 @@ var SubscribeFramesResultSchema = zod.z.object({
 * (the wire-serialisable supertype of `Buffer`) to match `DecodedFrameSchema`
 * / `EncodedPacketSchema`'s precedent; a `Buffer` is assignable to it.
 */
+var AudioChunkFormatSchema = zod.z.enum(AUDIO_CHUNK_FORMATS);
 var DecodedAudioChunkSchema = zod.z.object({
 	data: zod.z.instanceof(Uint8Array),
 	sampleRate: zod.z.number().int().positive(),
 	channels: zod.z.number().int().positive(),
-	timestamp: zod.z.number()
+	timestamp: zod.z.number(),
+	/**
+	* Byte format of `data`. ABSENT MEANS `f32le` — today's bytes, byte for
+	* byte, for any peer that never heard of this field. A coded window
+	* (`pcmu` / `pcma`, one byte per sample) is only ever emitted to a
+	* subscription that DECLARED it accepts one, so absence can never mean
+	* "coded bytes a consumer will read as floats" (D455).
+	*/
+	format: AudioChunkFormatSchema.optional()
 });
 /**
 * Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9). The
@@ -1549,7 +1674,18 @@ var DecodedAudioChunkSchema = zod.z.object({
 var SubscribeAudioChunksInputSchema = zod.z.object({
 	brokerId: zod.z.string(),
 	/** Short caller-identity tag (`audio-analyzer`, …) for `listClients`. */
-	tag: zod.z.string().optional()
+	tag: zod.z.string().optional(),
+	/**
+	* Byte formats this subscriber can READ, best first. The broker serves the
+	* chunk's own format when it is in this list and expands to `f32le`
+	* otherwise, so a subscriber is never handed bytes it cannot interpret.
+	*
+	* Absent (or without the source format) means `f32le` — the behaviour every
+	* subscriber had before D455, unchanged. This is the negotiation half of
+	* the source-bytes lever: it is what lets the broker and its consumers
+	* deploy one at a time across three nodes.
+	*/
+	accept: zod.z.array(AudioChunkFormatSchema).readonly().optional()
 });
 /** Result of `stream-broker.subscribeAudioChunks`. */
 var SubscribeAudioChunksResultSchema = zod.z.object({ 
@@ -3701,6 +3837,7 @@ function createDeviceProxy(api, binding, opts) {
 			getDeviceSettings: (input) => dispatchSystem("addonSettings", "getDeviceSettings", "query", input),
 			updateDeviceSettings: (input) => dispatchSystem("addonSettings", "updateDeviceSettings", "mutation", input)
 		},
+		audioAnalyzer: { detachDevice: (input) => dispatchSystem("audioAnalyzer", "detachDevice", "mutation", input) },
 		cameraPipelineConfig: {
 			getDeviceSettingsContribution: (input) => dispatchSystem("cameraPipelineConfig", "getDeviceSettingsContribution", "query", input),
 			getDeviceLiveContribution: (input) => dispatchSystem("cameraPipelineConfig", "getDeviceLiveContribution", "query", input),
@@ -4113,6 +4250,18 @@ function sleepCancellable(ms, signal) {
 	});
 }
 //#endregion
+Object.defineProperty(exports, "AUDIO_CHUNK_FORMATS", {
+	enumerable: true,
+	get: function() {
+		return AUDIO_CHUNK_FORMATS;
+	}
+});
+Object.defineProperty(exports, "AudioChunkFormatSchema", {
+	enumerable: true,
+	get: function() {
+		return AudioChunkFormatSchema;
+	}
+});
 Object.defineProperty(exports, "BOOT_RECOVERY_BACKOFF_MS", {
 	enumerable: true,
 	get: function() {
@@ -4395,6 +4544,12 @@ Object.defineProperty(exports, "asString", {
 		return asString;
 	}
 });
+Object.defineProperty(exports, "audioChunkBytesPerSample", {
+	enumerable: true,
+	get: function() {
+		return audioChunkBytesPerSample;
+	}
+});
 Object.defineProperty(exports, "collectHydratedFieldEntries", {
 	enumerable: true,
 	get: function() {
@@ -4473,6 +4628,12 @@ Object.defineProperty(exports, "event", {
 		return event;
 	}
 });
+Object.defineProperty(exports, "expandAudioChunkToF32le", {
+	enumerable: true,
+	get: function() {
+		return expandAudioChunkToF32le;
+	}
+});
 Object.defineProperty(exports, "expandCapMethods", {
 	enumerable: true,
 	get: function() {
@@ -4485,6 +4646,12 @@ Object.defineProperty(exports, "hydrateSchema", {
 		return hydrateSchema;
 	}
 });
+Object.defineProperty(exports, "isAudioChunkFormat", {
+	enumerable: true,
+	get: function() {
+		return isAudioChunkFormat;
+	}
+});
 Object.defineProperty(exports, "isDeviceConfigCap", {
 	enumerable: true,
 	get: function() {

package/dist/{sleep-ox21Ig4I.mjs → sleep-BnujYGPe.mjs}

@@ -1,5 +1,121 @@
 import { t as EventCategory } from "./event-category-DAXzJeTX.mjs";
 import { z } from "zod";
+//#region src/audio/audio-chunk-format.ts
+/**
+* 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. */
+var AUDIO_CHUNK_FORMATS = [
+	"f32le",
+	"pcmu",
+	"pcma"
+];
+/** Type guard for a value that arrived over the wire as a format name. */
+function isAudioChunkFormat(value) {
+	return typeof value === "string" && AUDIO_CHUNK_FORMATS.includes(value);
+}
+/**
+* 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.
+*/
+function audioChunkBytesPerSample(format) {
+	return format === "f32le" ? 4 : 1;
+}
+/**
+* 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.
+*/
+function expandAudioChunkToF32le(data, format) {
+	if (format === "f32le") {
+		const copy = new Uint8Array(data.byteLength);
+		copy.set(data);
+		return copy;
+	}
+	const table = format === "pcmu" ? ULAW_TABLE : ALAW_TABLE;
+	const out = new Float32Array(data.length);
+	for (let i = 0; i < data.length; i++) out[i] = table[data[i]];
+	return new Uint8Array(out.buffer);
+}
+/**
+* Build the μ-law decode table (ITU-T G.711). Each of the 256 byte values maps
+* to a 16-bit PCM sample, normalised to [-1.0, 1.0] for f32le output.
+*
+* Moved here verbatim from `audio-rtp-decoder.ts`, which no longer decodes:
+* it buffers the coded bytes and the plane's consumers expand.
+*/
+function buildUlawTable() {
+	const table = new Float32Array(256);
+	for (let i = 0; i < 256; i++) {
+		const complemented = ~i & 255;
+		const sign = (complemented & 128) !== 0 ? -1 : 1;
+		const exponent = complemented >> 4 & 7;
+		table[i] = sign * ((8 * (complemented & 15) + 132 << exponent) - 132) / 32768;
+	}
+	return table;
+}
+/** Build the A-law decode table (ITU-T G.711). */
+function buildAlawTable() {
+	const table = new Float32Array(256);
+	for (let i = 0; i < 256; i++) {
+		const xored = i ^ 85;
+		const sign = (xored & 128) !== 0 ? 1 : -1;
+		const exponent = xored >> 4 & 7;
+		const mantissa = xored & 15;
+		table[i] = sign * (exponent === 0 ? 16 * mantissa + 8 : 16 * mantissa + 264 << exponent - 1) / 32768;
+	}
+	return table;
+}
+var ULAW_TABLE = buildUlawTable();
+var ALAW_TABLE = buildAlawTable();
+//#endregion
 //#region src/interfaces/config-ui.ts
 /** Predefined tabs with standard label, icon, and sort order.
 *
@@ -1533,11 +1649,20 @@ var SubscribeFramesResultSchema = z.object({
 * (the wire-serialisable supertype of `Buffer`) to match `DecodedFrameSchema`
 * / `EncodedPacketSchema`'s precedent; a `Buffer` is assignable to it.
 */
+var AudioChunkFormatSchema = z.enum(AUDIO_CHUNK_FORMATS);
 var DecodedAudioChunkSchema = z.object({
 	data: z.instanceof(Uint8Array),
 	sampleRate: z.number().int().positive(),
 	channels: z.number().int().positive(),
-	timestamp: z.number()
+	timestamp: z.number(),
+	/**
+	* Byte format of `data`. ABSENT MEANS `f32le` — today's bytes, byte for
+	* byte, for any peer that never heard of this field. A coded window
+	* (`pcmu` / `pcma`, one byte per sample) is only ever emitted to a
+	* subscription that DECLARED it accepts one, so absence can never mean
+	* "coded bytes a consumer will read as floats" (D455).
+	*/
+	format: AudioChunkFormatSchema.optional()
 });
 /**
 * Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9). The
@@ -1549,7 +1674,18 @@ var DecodedAudioChunkSchema = z.object({
 var SubscribeAudioChunksInputSchema = z.object({
 	brokerId: z.string(),
 	/** Short caller-identity tag (`audio-analyzer`, …) for `listClients`. */
-	tag: z.string().optional()
+	tag: z.string().optional(),
+	/**
+	* Byte formats this subscriber can READ, best first. The broker serves the
+	* chunk's own format when it is in this list and expands to `f32le`
+	* otherwise, so a subscriber is never handed bytes it cannot interpret.
+	*
+	* Absent (or without the source format) means `f32le` — the behaviour every
+	* subscriber had before D455, unchanged. This is the negotiation half of
+	* the source-bytes lever: it is what lets the broker and its consumers
+	* deploy one at a time across three nodes.
+	*/
+	accept: z.array(AudioChunkFormatSchema).readonly().optional()
 });
 /** Result of `stream-broker.subscribeAudioChunks`. */
 var SubscribeAudioChunksResultSchema = z.object({ 
@@ -3701,6 +3837,7 @@ function createDeviceProxy(api, binding, opts) {
 			getDeviceSettings: (input) => dispatchSystem("addonSettings", "getDeviceSettings", "query", input),
 			updateDeviceSettings: (input) => dispatchSystem("addonSettings", "updateDeviceSettings", "mutation", input)
 		},
+		audioAnalyzer: { detachDevice: (input) => dispatchSystem("audioAnalyzer", "detachDevice", "mutation", input) },
 		cameraPipelineConfig: {
 			getDeviceSettingsContribution: (input) => dispatchSystem("cameraPipelineConfig", "getDeviceSettingsContribution", "query", input),
 			getDeviceLiveContribution: (input) => dispatchSystem("cameraPipelineConfig", "getDeviceLiveContribution", "query", input),
@@ -4113,4 +4250,4 @@ function sleepCancellable(ms, signal) {
 	});
 }
 //#endregion
-export { DecodedAudioChunkSchema as $, DEVICE_STATUS_METHOD as A, hydrateSchema as At, toNodeId as B, ChargingStatus as C, createEvent as Ct, adminUiCapability as D, WELL_KNOWN_TAB_MAP as Dt, DeviceType as E, WELL_KNOWN_TABS as Et, resolveCapMount as F, scopeKey as G, ReadinessTimeoutError as H, systemMethod as I, CAM_PROFILE_ORDER as J, BrokerStatsSchema as K, CAP_NODE_PIN_CONTEXT_KEY as L, expandCapMethods as M, isDeviceConfigCap as N, DEFAULT_RUNTIME_STATE_DURABILITY as O, collectHydratedFieldEntries as Ot, method as P, CameraStreamSchema as Q, nodePin as R, DEVICE_CHILDREN_BATCH_MAX as S, createDurableState as St, DeviceRole as T, isEvent as Tt, emitDownForOwnedCaps as U, ReadinessRegistry as V, readinessKey as W, CamStreamKindSchema as X, CamProfileSchema as Y, CamStreamResolutionSchema as Z, createMirrorSource as _, DATAPLANE_SECRET_HEADER as _t, asJsonObject as a, ProfileSlotSchema as at, deviceOpsCapability as b, BaseAddon as bt, parseJsonArray as c, StreamSourceSchema as ct, BOOT_RECOVERY_BACKOFF_MS as d, SubscribeFramesInputSchema as dt, DecodedFrameSchema as et, DEVICE_SCOPED_CAPS as f, SubscribeFramesResultSchema as ft, createLazyTrpcSource as g, selectAssignedProfileSlots as gt, createEventBusSliceSource as h, parseProfileBrokerId as ht, asJsonArray as i, ProfileRtspEntrySchema as it, event as j, resolveHydratedFieldValue as jt, DEVICE_SETTINGS_CONTRIBUTION_METHODS as k, collectHydratedFieldValues as kt, parseJsonObject as l, SubscribeAudioChunksInputSchema as lt, createDeviceProxy as m, makeSourceBrokerId as mt, sleepCancellable as n, FrameHandleFormatSchema as nt, asNumber as o, ProfileSlotStatusSchema as ot, isDeviceScopedCap as p, makeProfileBrokerId as pt, BrokerStatusSchema as q, asBoolean as r, FrameHandleSchema as rt, asString as s, StreamSourceEntrySchema$1 as st, sleep as t, EncodedPacketSchema as tt, parseJsonUnknown as u, SubscribeAudioChunksResultSchema as ut, createSliceHandle as v, SHARE_VIEW_KINDS as vt, DeviceFeature as w, emitReadiness as wt, viewerUiCapability as x, normalizeAddonInitResult as xt, RawStateResultSchema as y, DisposerChain as yt, readNodePin as z };
+export { CameraStreamSchema as $, DEVICE_STATUS_METHOD as A, collectHydratedFieldValues as At, toNodeId as B, ChargingStatus as C, createDurableState as Ct, adminUiCapability as D, WELL_KNOWN_TABS as Dt, DeviceType as E, isEvent as Et, resolveCapMount as F, expandAudioChunkToF32le as Ft, scopeKey as G, ReadinessTimeoutError as H, systemMethod as I, isAudioChunkFormat as It, BrokerStatusSchema as J, AudioChunkFormatSchema as K, CAP_NODE_PIN_CONTEXT_KEY as L, expandCapMethods as M, resolveHydratedFieldValue as Mt, isDeviceConfigCap as N, AUDIO_CHUNK_FORMATS as Nt, DEFAULT_RUNTIME_STATE_DURABILITY as O, WELL_KNOWN_TAB_MAP as Ot, method as P, audioChunkBytesPerSample as Pt, CamStreamResolutionSchema as Q, nodePin as R, DEVICE_CHILDREN_BATCH_MAX as S, normalizeAddonInitResult as St, DeviceRole as T, emitReadiness as Tt, emitDownForOwnedCaps as U, ReadinessRegistry as V, readinessKey as W, CamProfileSchema as X, CAM_PROFILE_ORDER as Y, CamStreamKindSchema as Z, createMirrorSource as _, selectAssignedProfileSlots as _t, asJsonObject as a, ProfileRtspEntrySchema as at, deviceOpsCapability as b, DisposerChain as bt, parseJsonArray as c, StreamSourceEntrySchema$1 as ct, BOOT_RECOVERY_BACKOFF_MS as d, SubscribeAudioChunksResultSchema as dt, DecodedAudioChunkSchema as et, DEVICE_SCOPED_CAPS as f, SubscribeFramesInputSchema as ft, createLazyTrpcSource as g, parseProfileBrokerId as gt, createEventBusSliceSource as h, makeSourceBrokerId as ht, asJsonArray as i, FrameHandleSchema as it, event as j, hydrateSchema as jt, DEVICE_SETTINGS_CONTRIBUTION_METHODS as k, collectHydratedFieldEntries as kt, parseJsonObject as l, StreamSourceSchema as lt, createDeviceProxy as m, makeProfileBrokerId as mt, sleepCancellable as n, EncodedPacketSchema as nt, asNumber as o, ProfileSlotSchema as ot, isDeviceScopedCap as p, SubscribeFramesResultSchema as pt, BrokerStatsSchema as q, asBoolean as r, FrameHandleFormatSchema as rt, asString as s, ProfileSlotStatusSchema as st, sleep as t, DecodedFrameSchema as tt, parseJsonUnknown as u, SubscribeAudioChunksInputSchema as ut, createSliceHandle as v, DATAPLANE_SECRET_HEADER as vt, DeviceFeature as w, createEvent as wt, viewerUiCapability as x, BaseAddon as xt, RawStateResultSchema as y, SHARE_VIEW_KINDS as yt, readNodePin as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/types",
-  "version": "1.2.177",
+  "version": "1.2.179",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",