@camstack/addon-pipeline 1.2.130 → 1.2.132

package/dist/{event-loop-stall-monitor-Bld7jNCb.js → event-loop-stall-monitor-CiH_MHfO.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-DOw-izoI.js");
+const require_dist = require("./dist-DBP47QOz.js");
 let node_crypto = require("node:crypto");
 let node_perf_hooks = require("node:perf_hooks");
 //#region src/detection-pipeline/registry/model-catalogs.ts

package/dist/{event-loop-stall-monitor-CtQCOZqm.mjs → event-loop-stall-monitor-IACE22fK.mjs}

@@ -1,4 +1,4 @@
-import { K as hfModelUrl, a as COCO_80_LABELS, j as audioKindId, o as COCO_TO_MACRO, r as AUDIO_MACRO_LABELS } from "./dist-Wt81pN5Y.mjs";
+import { K as hfModelUrl, a as COCO_80_LABELS, j as audioKindId, o as COCO_TO_MACRO, r as AUDIO_MACRO_LABELS } from "./dist-BZYUUBUx.mjs";
 import { randomUUID } from "node:crypto";
 import { PerformanceObserver } from "node:perf_hooks";
 //#region src/detection-pipeline/registry/model-catalogs.ts

package/dist/{lazy-sharp-BbNI2ZD-.js → lazy-sharp-B_kETjyQ.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-DOw-izoI.js");
+const require_dist = require("./dist-DBP47QOz.js");
 let node_url = require("node:url");
 let node_module = require("node:module");
 let node_path = require("node:path");

package/dist/motion-wasm/index.js

@@ -2,8 +2,8 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-DOw-izoI.js");
-const require_lazy_sharp = require("../lazy-sharp-BbNI2ZD-.js");
+const require_dist = require("../dist-DBP47QOz.js");
+const require_lazy_sharp = require("../lazy-sharp-B_kETjyQ.js");
 let node_path = require("node:path");
 let node_fs = require("node:fs");
 //#region src/motion-wasm/wasm-motion-detector.ts

package/dist/motion-wasm/index.mjs

@@ -1,4 +1,4 @@
-import { Dt as hydrateSchema, G as evaluateZoneRules, St as BaseAddon, Tt as DeviceType, X as motionDetectionCapability } from "../dist-Wt81pN5Y.mjs";
+import { Dt as hydrateSchema, G as evaluateZoneRules, St as BaseAddon, Tt as DeviceType, X as motionDetectionCapability } from "../dist-BZYUUBUx.mjs";
 import { t as getSharp } from "../lazy-sharp-BtT5x-qP.mjs";
 import { join } from "node:path";
 import { readFileSync } from "node:fs";

package/dist/pipeline-runner/index.js

@@ -2,11 +2,11 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-DOw-izoI.js");
-const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-Bld7jNCb.js");
-const require_worker_protocol = require("../worker-protocol-nAZl_Rsv.js");
+const require_dist = require("../dist-DBP47QOz.js");
+const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-CiH_MHfO.js");
+const require_worker_protocol = require("../worker-protocol-C3zaz0Jv.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
-const require_lazy_sharp = require("../lazy-sharp-BbNI2ZD-.js");
+const require_lazy_sharp = require("../lazy-sharp-B_kETjyQ.js");
 const require_restream_intent = require("../restream-intent-Cv9x3jmu.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
 let sharp = require("sharp");

package/dist/pipeline-runner/index.mjs

@@ -1,6 +1,6 @@
-import { Bt as lazy, Et as createEvent, F as customAction, Gt as string, Ht as number, It as _enum, L as defineCustomActions, Lt as array, Rt as boolean, St as BaseAddon, Ut as object, Vt as literal, f as DEFAULT_NATIVE_LEASE_SETTINGS, gt as errMsg, it as pipelineRunnerCapability, jt as nodePin, nt as pickNativeLeaseOverride, p as DEVICE_BACKEND_TO_FORMAT, qt as EventCategory, tt as pickDetailCropConvention, u as DEFAULT_DETAIL_CROP_CONVENTION, z as deriveDetailCropRect } from "../dist-Wt81pN5Y.mjs";
-import { i as resolveFrameViewGeometry, r as localFrameRegistry, t as attributeStall, u as getStepDefinition } from "../event-loop-stall-monitor-CtQCOZqm.mjs";
-import { a as nativeLeaseSettingEnv, t as isWorkerReply } from "../worker-protocol-rpnr7Ldd.mjs";
+import { Bt as lazy, Et as createEvent, F as customAction, Gt as string, Ht as number, It as _enum, L as defineCustomActions, Lt as array, Rt as boolean, St as BaseAddon, Ut as object, Vt as literal, f as DEFAULT_NATIVE_LEASE_SETTINGS, gt as errMsg, it as pipelineRunnerCapability, jt as nodePin, nt as pickNativeLeaseOverride, p as DEVICE_BACKEND_TO_FORMAT, qt as EventCategory, tt as pickDetailCropConvention, u as DEFAULT_DETAIL_CROP_CONVENTION, z as deriveDetailCropRect } from "../dist-BZYUUBUx.mjs";
+import { i as resolveFrameViewGeometry, r as localFrameRegistry, t as attributeStall, u as getStepDefinition } from "../event-loop-stall-monitor-IACE22fK.mjs";
+import { a as nativeLeaseSettingEnv, t as isWorkerReply } from "../worker-protocol-Cut8984B.mjs";
 import { t as resolveHubHostname } from "../hub-hostname-cCknRYKj.mjs";
 import { t as getSharp } from "../lazy-sharp-BtT5x-qP.mjs";
 import { n as withDetectionIntent } from "../restream-intent-B4BXZra7.mjs";

package/dist/{process-memory-1_D3EZT9.mjs → process-memory-C7rsraCR.mjs}

@@ -1,4 +1,4 @@
-import { Q as parseProcStatus } from "./dist-Wt81pN5Y.mjs";
+import { Q as parseProcStatus } from "./dist-BZYUUBUx.mjs";
 import { execFile } from "node:child_process";
 import * as fs from "node:fs";
 //#region src/shared/node-topology-platform.ts

package/dist/{process-memory-D9H5qjDl.js → process-memory-CtXQAA3d.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-DOw-izoI.js");
+const require_dist = require("./dist-DBP47QOz.js");
 let node_child_process = require("node:child_process");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs);

package/dist/recorder/index.js

@@ -1,7 +1,7 @@
-const require_dist = require("../dist-DOw-izoI.js");
+const require_dist = require("../dist-DBP47QOz.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_restream_intent = require("../restream-intent-Cv9x3jmu.js");
-const require_addon_utils = require("../addon-utils-DH78p79i.js");
+const require_addon_utils = require("../addon-utils-DzCn6z7v.js");
 const require_retire_root_keys = require("../retire-root-keys-KE6D6Xh_.js");
 let node_crypto = require("node:crypto");
 let node_child_process = require("node:child_process");
@@ -350,8 +350,13 @@ function fragmentRangeFor(index, offsetTicks) {
 * "nothing to read" (D49's letter, applied to a byte budget: a fallible
 * computation must never silently look like an unbind).
 */
-function fragmentsWithinBudget(index, offsetTicks, maxBytes) {
-	const { samples, mfraOffset } = index;
+/**
+* The last sync sample at or before `offsetTicks` — the keyframe a decoder
+* must start from. Shared by {@link fragmentsWithinBudget} and
+* {@link fragmentsInWindow}: both walk forward from the same anchor, they
+* only differ in the condition that stops the walk.
+*/
+function findAnchor(samples, offsetTicks) {
 	let lo = 0;
 	let hi = samples.length - 1;
 	let anchor = 0;
@@ -364,6 +369,11 @@ function fragmentsWithinBudget(index, offsetTicks, maxBytes) {
 			lo = mid + 1;
 		} else hi = mid - 1;
 	}
+	return anchor;
+}
+function fragmentsWithinBudget(index, offsetTicks, maxBytes) {
+	const { samples, mfraOffset } = index;
+	const anchor = findAnchor(samples, offsetTicks);
 	const endOf = (i) => samples[i + 1]?.moofOffset ?? mfraOffset;
 	const anchorStart = samples[anchor]?.moofOffset ?? 0;
 	const anchorEnd = endOf(anchor);
@@ -400,6 +410,70 @@ function fragmentsWithinBudget(index, offsetTicks, maxBytes) {
 		oversizeFragment
 	};
 }
+/**
+* Convert a TIME WINDOW `[fromTicks, toTicks)` into the set of consecutive
+* fragments that covers it — the replay's primitive for "give me this many
+* seconds of one segment", as opposed to {@link fragmentsWithinBudget}'s
+* "give me as much as fits in N bytes" (the scrub GOP read's primitive).
+*
+* Stops walking forward the instant the NEXT fragment's own start time
+* already reaches `toTicks`: at that point the fragments already collected
+* cover the whole window, because each fragment's coverage runs up to the
+* next one's start (the same relationship {@link fragmentsWithinBudget}'s
+* `endOf` encodes). `maxBytes` is a SAFETY CEILING, not the primary stop
+* condition — a caller with a well-formed window is expected to hit the time
+* condition first; the byte cap exists so a pathological request cannot pull
+* an unbounded amount of one segment into memory.
+*
+* Same never-empty guarantee as {@link fragmentsWithinBudget}: the anchor
+* fragment is always returned, even when it alone exceeds `maxBytes`.
+*/
+function fragmentsInWindow(index, fromTicks, toTicks, maxBytes) {
+	const { samples, mfraOffset } = index;
+	const anchor = findAnchor(samples, fromTicks);
+	const endOf = (i) => samples[i + 1]?.moofOffset ?? mfraOffset;
+	const windowCoveredAt = (i) => {
+		const next = samples[i + 1];
+		return next === void 0 || next.timeTicks >= toTicks;
+	};
+	const anchorStart = samples[anchor]?.moofOffset ?? 0;
+	const anchorEnd = endOf(anchor);
+	const fragments = [{
+		start: anchorStart,
+		end: anchorEnd,
+		sampleIndex: anchor
+	}];
+	let total = anchorEnd - anchorStart;
+	const oversizeFragment = total > maxBytes;
+	let i = anchor;
+	let reachesWindowEnd = windowCoveredAt(i);
+	while (!reachesWindowEnd) {
+		const nextIndex = i + 1;
+		const nextSample = samples[nextIndex];
+		if (nextSample === void 0) break;
+		const nextStart = nextSample.moofOffset;
+		const nextEnd = endOf(nextIndex);
+		const nextSize = nextEnd - nextStart;
+		if (total + nextSize > maxBytes) break;
+		fragments.push({
+			start: nextStart,
+			end: nextEnd,
+			sampleIndex: nextIndex
+		});
+		total += nextSize;
+		i = nextIndex;
+		reachesWindowEnd = windowCoveredAt(i);
+	}
+	const last = fragments[fragments.length - 1];
+	return {
+		fragments,
+		start: fragments[0].start,
+		end: last.end,
+		reachesSegmentEnd: last.end >= mfraOffset,
+		reachesWindowEnd,
+		oversizeFragment
+	};
+}
 //#endregion
 //#region src/recorder/mfra-capture.ts
 /**
@@ -4440,6 +4514,34 @@ var SCRUB_GOP_BUDGET_MAX_BYTES = 15e5;
 function ticksToMs(ticks, timescale) {
 	return Math.round(ticks / timescale * 1e3);
 }
+/** ms → ticks on the video timescale — the inverse of {@link ticksToMs}. */
+function msToTicks(ms, timescale) {
+	return ms / 1e3 * timescale;
+}
+/**
+* Steps 1-2 shared by {@link readGopRange} and {@link readGopWindowRange}:
+* locate the `mfra` (seeded or from the tail), read the `ftyp`+`moov` head,
+* and pick the VIDEO track's sync table (never the audio one, which lists
+* every `moof` and would send a seek to bytes that do not open a GOP).
+* `null` on anything that does not look like a recorded segment.
+*/
+async function resolveSegmentIndex(file, seededIndex, read) {
+	const parsed = seededIndex === void 0 ? await parseTail(file, read) : null;
+	if (seededIndex === void 0 && parsed === null) return null;
+	const index = seededIndex ?? parsed.index;
+	const firstMoof = index.samples[0]?.moofOffset ?? 0;
+	if (firstMoof <= 0 || firstMoof >= file.size) return null;
+	const head = await read(0, firstMoof);
+	const init = parseInitInfo(head);
+	if (init === null) return null;
+	const videoIndex = index.trackId === init.videoTrackId ? index : parsed === null ? null : reparseTail(parsed.tail, file.size, init.videoTrackId);
+	if (videoIndex === null) return null;
+	return {
+		head,
+		init,
+		videoIndex
+	};
+}
 /**
 * Read the single GOP covering `epochMs` from `file`, by byte range.
 *
@@ -4455,17 +4557,10 @@ async function readGopRange(file, args) {
 		bytesRead += chunk.length;
 		return chunk;
 	};
-	const parsed = args.seededIndex === void 0 ? await parseTail(file, read) : null;
-	if (args.seededIndex === void 0 && parsed === null) return null;
-	const index = args.seededIndex ?? parsed.index;
-	const firstMoof = index.samples[0]?.moofOffset ?? 0;
-	if (firstMoof <= 0 || firstMoof >= file.size) return null;
-	const head = await read(0, firstMoof);
-	const init = parseInitInfo(head);
-	if (init === null) return null;
-	const videoIndex = index.trackId === init.videoTrackId ? index : parsed === null ? null : reparseTail(parsed.tail, file.size, init.videoTrackId);
-	if (videoIndex === null) return null;
-	const offsetTicks = Math.max(0, args.epochMs - args.segmentStartMs) / 1e3 * init.videoTimescale;
+	const resolved = await resolveSegmentIndex(file, args.seededIndex, read);
+	if (resolved === null) return null;
+	const { head, init, videoIndex } = resolved;
+	const offsetTicks = msToTicks(Math.max(0, args.epochMs - args.segmentStartMs), init.videoTimescale);
 	let start;
 	let end;
 	let firstSampleIndex;
@@ -4510,6 +4605,49 @@ async function readGopRange(file, args) {
 	};
 }
 /**
+* Read the fragments covering `[fromMs, toMs)` from `file`, by byte range —
+* the WINDOW twin of {@link readGopRange}'s single instant. Same shape, same
+* standalone-demuxable `ftyp`+`moov` head, same `null`-on-unparseable
+* contract; the only difference is the stop condition
+* ({@link fragmentsInWindow} instead of {@link fragmentRangeFor} /
+* {@link fragmentsWithinBudget}).
+*/
+async function readGopWindowRange(file, args) {
+	let bytesRead = 0;
+	const read = async (offset, length) => {
+		const chunk = await file.read(offset, length);
+		bytesRead += chunk.length;
+		return chunk;
+	};
+	const resolved = await resolveSegmentIndex(file, args.seededIndex, read);
+	if (resolved === null) return null;
+	const { head, init, videoIndex } = resolved;
+	const fromOffsetMs = Math.max(0, args.fromMs - args.segmentStartMs);
+	const toOffsetMs = Math.max(fromOffsetMs, args.toMs - args.segmentStartMs);
+	const plan = fragmentsInWindow(videoIndex, msToTicks(fromOffsetMs, init.videoTimescale), msToTicks(toOffsetMs, init.videoTimescale), args.maxBytes);
+	const { start, end } = plan;
+	if (start <= 0 || end <= start || end > file.size) return null;
+	const fragment = await read(start, end - start);
+	const firstSampleIndex = plan.fragments[0].sampleIndex;
+	const lastSampleIndex = plan.fragments[plan.fragments.length - 1].sampleIndex;
+	const startTicks = videoIndex.samples[firstSampleIndex]?.timeTicks ?? 0;
+	const nextTicks = videoIndex.samples[lastSampleIndex + 1]?.timeTicks;
+	const gopStartOffsetMs = ticksToMs(startTicks, init.videoTimescale);
+	const gopDurMs = nextTicks !== void 0 ? ticksToMs(nextTicks - startTicks, init.videoTimescale) : Math.max(1, args.segmentDurMs - gopStartOffsetMs);
+	const data = new Uint8Array(head.length + fragment.length);
+	data.set(head, 0);
+	data.set(fragment, head.length);
+	return {
+		data,
+		gopStartMs: args.segmentStartMs + gopStartOffsetMs,
+		gopDurMs,
+		bytesRead,
+		reachesSegmentEnd: plan.reachesSegmentEnd,
+		reachesWindowEnd: plan.reachesWindowEnd,
+		oversizeFragment: plan.oversizeFragment
+	};
+}
+/**
 * Fetch + parse the `mfra` tail, honouring `MfraParseError.needBytes` with ONE
 * widened retry. Null on anything else — bytes that are not a segment.
 */
@@ -4801,6 +4939,16 @@ var RANGE_MERGE_GAP_MS = 5e3;
 * hour but covers the requested epoch is hydrated too. Recorder segments are
 * currently much shorter; the margin keeps this boundary future-safe. */
 var LOCATE_HYDRATE_MARGIN_MS = 6e4;
+/**
+* Safety ceiling for one `readWindowBytes` answer — NOT the primary stop
+* condition (the requested `toMs` is; see `fragmentsInWindow` in
+* `mfra-index.ts`). Sized off `high`'s own bandwidth hint above
+* (`PROFILE_BANDWIDTH.high` = 4 Mbps = 500 000 B/s): a 30 s replay window at
+* that rate is ~15 MB, so 20 MB covers it with headroom while still bounding
+* a pathological request. A window this call actually truncates is reported
+* (`reachesRequestedEnd: false`) rather than silently shortened.
+*/
+var WINDOW_READ_MAX_BYTES = 2e7;
 /** Empty "no playback" manifest. */
 function noPlayback(deviceId) {
 	return {
@@ -5318,6 +5466,76 @@ function buildRecordingProvider(deps) {
 				gopDurMs: seg.durMs
 			};
 		},
+		readWindowBytes: async ({ deviceId, profile, startMs, fromMs, toMs }) => {
+			const { abs, seg } = resolveSegmentFile(deps, deviceId, profile, startMs);
+			const segmentEndMs = seg.startMs + seg.durMs;
+			if (toMs > segmentEndMs) {
+				deps.logger.warn("recording: readWindowBytes refused — window runs past this segment, not silently clipped", {
+					tags: { deviceId },
+					meta: {
+						profile,
+						startMs,
+						fromMs,
+						toMs,
+						segmentEndMs
+					}
+				});
+				return {
+					kind: "spans-multiple-segments",
+					segmentEndMs
+				};
+			}
+			const file = await (deps.openRangeReadable ?? openRangeFromDisk)(abs, seg.bytes);
+			try {
+				const gop = await readGopWindowRange(file, {
+					segmentStartMs: seg.startMs,
+					segmentDurMs: seg.durMs,
+					fromMs,
+					toMs,
+					seededIndex: deps.mfraFor?.(deviceId, profile, startMs),
+					maxBytes: WINDOW_READ_MAX_BYTES
+				});
+				if (gop !== null) {
+					if (gop.reachesWindowEnd !== true) deps.logger.warn("recording: readWindowBytes truncated by its safety byte cap before covering the requested window", {
+						tags: { deviceId },
+						meta: {
+							profile,
+							startMs,
+							fromMs,
+							toMs,
+							bytes: gop.data.length,
+							WINDOW_READ_MAX_BYTES
+						}
+					});
+					return {
+						kind: "ok",
+						data: gop.data,
+						gopStartMs: gop.gopStartMs,
+						gopDurMs: gop.gopDurMs,
+						reachesRequestedEnd: gop.reachesWindowEnd === true
+					};
+				}
+			} finally {
+				await file.close();
+			}
+			deps.logger.warn("recording: readWindowBytes fell back to the WHOLE segment (mfra/moov unparseable)", {
+				tags: { deviceId },
+				meta: {
+					profile,
+					startMs,
+					fromMs,
+					toMs
+				}
+			});
+			const data = await readFile(abs);
+			return {
+				kind: "ok",
+				data: Uint8Array.from(data),
+				gopStartMs: seg.startMs,
+				gopDurMs: seg.durMs,
+				reachesRequestedEnd: true
+			};
+		},
 		setDeviceConfig: async ({ deviceId, config }) => {
 			const saved = await saveDeviceConfig(deps.configStore, deviceId, config);
 			if (deps.onConfigChanged) try {
@@ -7522,7 +7740,46 @@ function resolveBandBufferMs(band) {
 */
 function eventsBandCanEverDemand(band) {
 	if (band.mode !== "events") return true;
-	return (band.triggers?.motion === true || band.triggers?.audioThresholdDbfs !== void 0) && resolveBandBufferMs(band).postMs > 0;
+	return bandTriggerSources(band).length > 0 && resolveBandBufferMs(band).postMs > 0;
+}
+/**
+* LE sorgenti che questa banda ascolta — l'unico posto dove i `triggers` di
+* una banda diventano `TriggerSource[]`. `eventsBandCanEverDemand` e
+* `RecordingController.reportUnrecordable` lo leggono invece di ripetere
+* l'if-ladder motion/audio a mano.
+*/
+function bandTriggerSources(band) {
+	const t = band.triggers;
+	if (t === void 0) return [];
+	const sources = [];
+	if (t.motion === true) sources.push("motion");
+	if (t.audioThresholdDbfs !== void 0) sources.push("audio");
+	return sources;
+}
+/**
+* Does this audio window's level clear the ACTIVE band's configured
+* threshold?
+*
+* `PipelineAudioInferenceResultPayload.frame.level.dbfs`
+* (`packages/types/src/types/detection.ts:448`) and
+* `RecordingTriggers.audioThresholdDbfs` are the SAME unit and the SAME
+* scale — dBFS, 0 = full scale, more negative = quieter — produced by
+* `audio-analyzer-provider.ts:77` (`20 * log10(rms)`). No conversion exists
+* between them because none is needed: the one other place in this repo that
+* compares the two values does the same bare `>=`
+* (`notification-center/audio-rule-matcher.ts:221`). Inventing a conversion
+* here would recreate the exact defect this track exists to close, only
+* harder to see because a wrong scale still fires occasionally.
+*
+* `band` must be the band ACTIVE AT the audio window's own timestamp — a
+* device can carry several bands with different thresholds (day/night), and
+* only one is ever "the" threshold at a given instant. The caller
+* (`RecordingController.onAudioLevel`) resolves it the same way
+* `postBufferMsFor` resolves the post-buffer.
+*/
+function audioLevelQualifies(band, dbfs) {
+	const threshold = band?.triggers?.audioThresholdDbfs;
+	return threshold !== void 0 && dbfs >= threshold;
 }
 /** No trigger has been seen for this device yet. */
 var EMPTY_TRIGGER_STATE = {
@@ -9385,6 +9642,43 @@ var RecordingController = class {
 		}
 	}
 	/**
+	* Feed one audio window's LEVEL into the trigger pipeline — the counterpart
+	* of `onTrigger('motion', …)` for the `audioThresholdDbfs` source, and the
+	* feed that source was missing until 2026-08-26 (D62: authorized by the UI,
+	* read by every pure function in `band-decision.ts`, alimented by nobody).
+	*
+	* Qualification happens HERE, not upstream like motion's `data.detected`,
+	* because it depends on a PER-BAND threshold: `audioThresholdDbfs` is
+	* authored per band, not once per device, so it needs the same config read
+	* {@link postBufferMsFor} already does to resolve which band is active at
+	* `atMs` before it can know which threshold applies.
+	*
+	* Fed from the event bus (telemetry, may be dropped — D8/D11), so a
+	* config-read failure here drops only THIS window's qualification test
+	* rather than guessing a threshold — logged, never silent, and never fatal:
+	* the device's recordability does not depend on any single audio sample,
+	* the next window (or motion) can still open the band.
+	*/
+	async onAudioLevel(deviceId, dbfs, atMs) {
+		if (this.stopped) return;
+		let band;
+		try {
+			band = activeBandAt({ bands: (await this.deps.loadConfig(deviceId)).bands ?? [] }, new Date(atMs));
+		} catch (err) {
+			this.deps.logger.warn("recorder: audio trigger qualification skipped — config read failed", {
+				tags: { deviceId },
+				meta: {
+					atMs,
+					dbfs,
+					error: require_dist.errMsg(err)
+				}
+			});
+			return;
+		}
+		if (!audioLevelQualifies(band, dbfs)) return;
+		await this.onTrigger(deviceId, "audio", atMs);
+	}
+	/**
 	* The post-buffer that governs this device's trigger history right now: it is
 	* both the MERGE GAP (a trigger landing inside the open live window belongs to
 	* the running episode) and the retention horizon. Falls back to the shipped
@@ -9499,7 +9793,7 @@ var RecordingController = class {
 			meta: {
 				postBufferSec: band.postBufferSec,
 				triggers: band.triggers,
-				reason: band.triggers?.motion === true || band.triggers?.audioThresholdDbfs !== void 0 ? "postBufferSec is 0" : "no trigger configured"
+				reason: bandTriggerSources(band).length > 0 ? "postBufferSec is 0" : "no trigger configured"
 			}
 		});
 	}
@@ -11553,6 +11847,14 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 	eventMap = new EventMap();
 	/** Unsubscribe handle for the EventCapture motion subscription. */
 	eventUnsub = null;
+	/**
+	* Unsubscribe handle for the `PipelineAudioInferenceResult` audio-level
+	* subscription — the feed `audioThresholdDbfs` was missing (D62, Traccia 0
+	* of `docs/design/plans/2026-08-26-trigger-detection-e-sensori.md`). Kept
+	* separate from `eventUnsub` (a distinct bus category) but guarded and torn
+	* down the same way, idempotent re-entry included.
+	*/
+	audioTriggerUnsub = null;
 	/** Resolved recordings locations (id + root). Refreshed on boot + rescan.
 	*  Already ALIAS-GUARDED: a writable same-type duplicate of another
 	*  location's physical root arrives here demoted to read-only. */
@@ -12024,6 +12326,8 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 	async onShutdown() {
 		this.eventUnsub?.();
 		this.eventUnsub = null;
+		this.audioTriggerUnsub?.();
+		this.audioTriggerUnsub = null;
 		await this.controller?.stop();
 		this.controller = null;
 		this.segmentStore = null;
@@ -12098,6 +12402,11 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 				this.controller?.onTrigger(deviceId, "motion", atMs);
 			}
 		});
+		if (this.audioTriggerUnsub === null) this.audioTriggerUnsub = this.ctx.eventBus.subscribe({ category: require_dist.EventCategory.PipelineAudioInferenceResult }, (event) => {
+			const dbfs = event.data.frame.level?.dbfs;
+			if (dbfs === void 0) return;
+			this.controller?.onAudioLevel(event.data.deviceId, dbfs, event.data.frame.timestamp);
+		});
 		try {
 			await this.segmentHours?.load();
 			this.segmentHours?.hydrateIndex(this.index);