@camstack/addon-post-analysis 1.2.167 → 1.2.169

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-dGS8z89L.js");
+const require_dist = require("../dist-DQVA7q-T.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -3139,7 +3139,8 @@ var LlmVisionJudge = class {
 			prompt: call.prompt,
 			images,
 			jsonSchema: call.jsonSchema,
-			temperature: 0
+			temperature: 0,
+			timeoutMs: call.timeoutMs
 		}).catch((err) => ({
 			ok: false,
 			message: String(err)
@@ -19705,8 +19706,37 @@ var TimelapseRenderError = class extends Error {
 		this.reason = reason;
 	}
 };
-/** The profile with the most footage over the window; ties broken by name so
-*  the same window always renders from the same source. */
+/**
+* Profiles from cheapest to dearest, so the source is chosen by COST.
+*
+* `CamProfileSchema` is declared dearest-first; this is that order reversed.
+* A name the enum does not know sorts after all of them, alphabetically, so the
+* choice stays deterministic for a fleet with a bespoke profile.
+*/
+var PROFILE_BY_COST = [...require_dist.CamProfileSchema.options].reverse();
+function profileCost(profile) {
+	const i = PROFILE_BY_COST.indexOf(profile);
+	return i === -1 ? PROFILE_BY_COST.length : i;
+}
+/**
+* The CHEAPEST profile that has footage over the window.
+*
+* It used to be the profile with the MOST coverage, ties broken by name — and
+* that is a rule which picks `high` almost every time, because the high band is
+* the one that records continuously. On 2026-09-03 it did: a test render of a
+* ten-hour window chose `profile=high` at 97% coverage, which on this hub means
+* 4K read from a USB spinning disk. Decoding it made the machine stop answering
+* SSH and its own web UI for half an hour, and it had to be power-cycled.
+*
+* A timelapse is watched accelerated. Resolution buys nothing at 12 fps over a
+* night, and the cost difference between the bands is one to two orders of
+* magnitude in both bytes read and frames decoded. So there is no trade to
+* weigh: take the cheapest band that has anything, every time.
+*
+* Coverage no longer decides WHICH — only whether a band qualifies at all. A
+* band with less footage is still the right source; the gaps show as a shorter
+* video, not as a reason to read twenty times the bytes.
+*/
 function pickProfile(ranges, window) {
 	const byProfile = /* @__PURE__ */ new Map();
 	for (const r of ranges) {
@@ -19714,15 +19744,15 @@ function pickProfile(ranges, window) {
 		if (list === void 0) byProfile.set(r.profile, [r]);
 		else list.push(r);
 	}
-	let best = null;
-	for (const [profile, rows] of [...byProfile].sort((a, b) => a[0].localeCompare(b[0]))) {
+	const ordered = [...byProfile].sort((a, b) => profileCost(a[0]) - profileCost(b[0]) || a[0].localeCompare(b[0]));
+	for (const [profile, rows] of ordered) {
 		const coverage = footageCoverage(rows, window.startMs, window.endMs);
-		if (best === null || coverage.coveredMs > best.coverage.coveredMs) best = {
+		if (coverage.coveredMs > 0) return {
 			profile,
 			coverage
 		};
 	}
-	return best;
+	return null;
 }
 /**
 * Is `record` the render this request is about to order?
@@ -27254,9 +27284,29 @@ async function renderTimelapseGif(ports, request) {
 }
 //#endregion
 //#region src/shared/frame/square-subject-crop.ts
-/** Expansion factor applied to the bbox long side to frame the subject with a
-*  little breathing room (operator choice: ×1.2). */
-var SQUARE_SUBJECT_CROP_EXPANSION = 1.2;
+/**
+* Expansion applied to the bbox long side to frame the subject with a little
+* breathing room.
+*
+* ×1.2 → ×1.05 (operator, 2026-09-03: "riduci e proviamo"). The complaint was
+* that a best shot carries too much surrounding scene, and the measurement says
+* where it goes. On 26 148 person samples from camera 617 the median bbox is
+* 1.44× taller than wide, so the square is driven by HEIGHT and half its width
+* is empty before the 16:9 extension adds any:
+*
+*   subject inside the square   48%   (waste 52%)  ← this factor
+*   square inside the 16:9      56%   (waste 44%)
+*   subject delivered           27%
+*
+* A prior analysis called the 16:9 extension the dominant waste. For a standing
+* person it is not: squaring costs more, because it pays for the height twice.
+* At ×1.05 the subject holds 63% of the square and ~35% of the canvas.
+*
+* The floor is 1.0, not lower: the square must CONTAIN the bbox, and detector
+* boxes hug the visible extent, so some margin is what keeps hair and feet in
+* shot when the box is a little tight.
+*/
+var SQUARE_SUBJECT_CROP_EXPANSION = 1.05;
 /**
 * Compute a SQUARE crop region in PIXEL space around the subject bbox.
 *
@@ -33180,6 +33230,9 @@ function isDecisiveImprovement(current, candidate) {
 	if (!isSquareContained(candidate) && isSquareContained(current)) return false;
 	if (!isSemantic(candidate) && isSemantic(current)) return false;
 	if (!candidate.edgeClear && current.edgeClear) return false;
+	const currentSize = current.sizeScore;
+	const candidateSize = candidate.sizeScore;
+	if (currentSize !== void 0 && candidateSize !== void 0 && currentSize > 0 && candidateSize >= currentSize * 1.25) return true;
 	return effectiveScore(candidate) >= effectiveScore(current) * DECISIVE_IMPROVEMENT_RATIO;
 }
 /**
@@ -36626,19 +36679,19 @@ var BEST_FACE_POLICY = {
 	semanticAware: false
 };
 /**
-* Best OBJECT (CLIP) embedding + its tight crop — confidence-only in-memory
+* Best OBJECT (CLIP) embedding + its tight crop — the in-memory
 * DECISION (which live frame the embedding row + crop derive from). The
 * durable, cross-restart "if better" gate stays DOWNSTREAM in
 * `ObjectEmbeddingStore.upsertIfBetter` (the documented seam: this selector
-* resets on addon restart, the store row does not). Same values as
-* {@link BEST_FACE_POLICY} today, but a SEPARATE named policy: the two paths
-* may drift apart deliberately without one masquerading as the other.
+* resets on addon restart, the store row does not). A SEPARATE named policy
+* from the face path: the two may drift apart deliberately without one
+* masquerading as the other.
 */
 var BEST_OBJECT_EMBED_POLICY = {
 	hysteresis: 0,
 	minGapMs: 0,
-	edgeAware: false,
-	sizeAware: false,
+	edgeAware: true,
+	sizeAware: true,
 	semanticAware: false
 };
 /**
@@ -39437,6 +39490,12 @@ var TrackStore = class {
 	upsert(params) {
 		const existing = this.active.get(params.trackId);
 		if (existing) {
+			if (params.matched === false) {
+				existing.state = params.state;
+				for (const z of params.zones) if (!existing.zonesVisited.includes(z)) existing.zonesVisited.push(z);
+				if (!existing.classes.includes(params.className)) existing.classes.push(params.className);
+				return existing;
+			}
 			const last = existing.positions[existing.positions.length - 1];
 			const dist = last ? Math.sqrt((params.position.x - last.x) ** 2 + (params.position.y - last.y) ** 2) : 0;
 			existing.lastSeen = params.timestamp;
@@ -43985,6 +44044,36 @@ var AnalyticsQueryFacade = class {
 //#region src/pipeline-analytics/audio-detection-settings.ts
 var AudioDetectionSettingsSchema = require_dist.object({
 	classificationMinScore: require_dist.number().min(0).max(1).default(.6),
+	/**
+	* Macro classes allowed to produce an audio EVENT on this camera. Empty =
+	* no policy, every class passes — so an upgrade changes nothing until an
+	* operator states a policy.
+	*
+	* This belongs to the event generator, NOT to the classifier: the analyzer
+	* keeps classifying everything it hears, `audioLabels` on the track keeps
+	* carrying the full picture, and only the decision to MATERIALIZE an event
+	* is narrowed. Raising a threshold inside the classifier would instead make
+	* the sound invisible to every consumer at once.
+	*/
+	audioAllowedClasses: require_dist.array(require_dist.string()).default([]),
+	/**
+	* Corroboration window on the EVENT, per class: this many occurrences of
+	* the same sound must land inside `audioConfirmWindowSec` before it becomes
+	* an event. `1` = no window.
+	*
+	* Default 2-in-10s, set by the operator on 2026-09-03 after measuring 26
+	* audio tracks in 24 h: the single-frame classification is the dominant
+	* false positive, and a sound that is real is heard again within ten
+	* seconds. A camera that wants every occurrence sets `1`.
+	*
+	* The Notification Center already has this exact brake for audio RULES
+	* (`confirmHits` / `confirmWindowSec`). This is the same idea one level
+	* earlier, so a camera can stop MAKING the single-frame events instead of
+	* only declining to notify about them.
+	*/
+	audioConfirmHits: require_dist.number().int().min(1).default(2),
+	/** Width of the corroboration window. Ignored when `audioConfirmHits` is 1. */
+	audioConfirmWindowSec: require_dist.number().positive().default(10),
 	levelDeviationDb: require_dist.number().positive().default(10),
 	levelWindowSec: require_dist.number().positive().default(10),
 	levelMaxWaitSec: require_dist.number().positive().default(20),
@@ -44025,8 +44114,17 @@ var AudioDetectionSettingsSchema = require_dist.object({
 	audioEpisodeOpenHoldSec: require_dist.number().nonnegative().default(1.5),
 	/** Class must be absent this long before the episode closes. */
 	audioEpisodeCloseGapSec: require_dist.number().positive().default(12),
-	/** After close, the same class cannot reopen until this elapses. */
-	audioEpisodeCooldownSec: require_dist.number().nonnegative().default(30)
+	/** After close, the same class cannot reopen until this elapses.
+	*
+	*  This is the minimum spacing between two SYNTHETIC EVENTS (the episode's
+	*  event + timeline track) of the same sound on one camera — NOT a
+	*  notification floor. Notification spacing is the rule's own
+	*  `throttle.cooldownSec`, which already defaults to 60 s and is keyed
+	*  per-device; the two are independent brakes on different objects.
+	*
+	*  Raised 30 → 60 s on 2026-09-03 by the operator, alongside the 2-in-10s
+	*  corroboration window above. */
+	audioEpisodeCooldownSec: require_dist.number().nonnegative().default(60)
 });
 var AUDIO_DETECTION_DEFAULTS = AudioDetectionSettingsSchema.parse({});
 /**
@@ -44203,14 +44301,45 @@ function observeAudioEpisode(state, sample, knobs) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/audio-confirm-window.ts
+function emptyAudioConfirmState() {
+	return { hitsByClass: /* @__PURE__ */ new Map() };
+}
+function observeAudioConfirm(state, input, cfg) {
+	if (cfg.confirmHits <= 1) return {
+		confirmed: true,
+		nextState: state
+	};
+	const cutoff = input.timestampMs - cfg.confirmWindowSec * 1e3;
+	const kept = [...(state.hitsByClass.get(input.className) ?? []).filter((at) => at > cutoff), input.timestampMs];
+	const next = new Map(state.hitsByClass);
+	if (kept.length < cfg.confirmHits) {
+		next.set(input.className, kept);
+		return {
+			confirmed: false,
+			nextState: { hitsByClass: next }
+		};
+	}
+	next.delete(input.className);
+	return {
+		confirmed: true,
+		nextState: { hitsByClass: next }
+	};
+}
+//#endregion
 //#region src/pipeline-analytics/audio-event-router.ts
 /**
 * Decide whether an audio frame is a (meaningful) classification event or a
 * level event. `silence` is never a classification — it falls to the level
 * path so only a genuine loudness peak/heartbeat can surface it.
+*
+* A class the operator did not allow takes the SAME route as a class that
+* failed the score: the level path. Both mean "not a classification event on
+* this camera", and giving the allowlist its own harder outcome (a silent
+* drop) would be a second arithmetic for one question.
 */
 function classifyAudioFrame(top, cfg) {
-	if (top && top.className !== "silence" && top.score >= cfg.classificationMinScore) return {
+	if ((cfg.allowedClasses.length === 0 || cfg.allowedClasses.includes(top?.className ?? "")) && top && top.className !== "silence" && top.score >= cfg.classificationMinScore) return {
 		kind: "classification",
 		className: top.className,
 		score: top.score
@@ -59357,6 +59486,81 @@ function hasWrappedDetection(entries) {
 	return entries.some((e) => e.capName === "detection-pipeline" && e.kind === "wrapped");
 }
 //#endregion
+//#region src/pipeline-analytics/runtime/native-crop-dedupe.ts
+var NativeCropDedupe = class {
+	config;
+	entries = /* @__PURE__ */ new Map();
+	fetched = 0;
+	coalesced = 0;
+	reused = 0;
+	/**
+	* What this actually saved, since the last read.
+	*
+	* Shipped WITH the optimisation, not after it: without a counter the only
+	* evidence available is the process's RSS, which is allocator residue that
+	* ratchets within a boot and cannot answer "did the dedupe fire". An
+	* optimisation nobody can measure is a claim, not a fix.
+	*/
+	drainCounts() {
+		const counts = {
+			fetched: this.fetched,
+			coalesced: this.coalesced,
+			reused: this.reused
+		};
+		this.fetched = 0;
+		this.coalesced = 0;
+		this.reused = 0;
+		return counts;
+	}
+	constructor(config) {
+		this.config = config;
+	}
+	/** Retained entries — for the bound's own test, and for metrics. */
+	size() {
+		return this.entries.size;
+	}
+	async run(handle, region, maxWidth, fetch) {
+		const key = `${handle.shmId}#${handle.slot}#${handle.seq}|${region.x},${region.y},${region.w},${region.h}|${maxWidth ?? "full"}`;
+		const existing = this.entries.get(key);
+		if (existing !== void 0) if (existing.value !== void 0 && existing.at !== void 0) {
+			if (this.config.now() - existing.at < this.config.ttlMs) {
+				this.reused += 1;
+				return existing.value;
+			}
+			this.entries.delete(key);
+		} else {
+			this.coalesced += 1;
+			return existing.pending;
+		}
+		this.fetched += 1;
+		const pending = fetch();
+		const entry = { pending };
+		this.entries.set(key, entry);
+		try {
+			const result = await pending;
+			if (result === null) {
+				this.entries.delete(key);
+				return null;
+			}
+			entry.value = result;
+			entry.at = this.config.now();
+			this.evictOverflow();
+			return result;
+		} catch (err) {
+			this.entries.delete(key);
+			throw err;
+		}
+	}
+	/** Oldest-first, and only ever over the ceiling. */
+	evictOverflow() {
+		while (this.entries.size > this.config.maxEntries) {
+			const oldest = this.entries.keys().next();
+			if (oldest.done === true) return;
+			this.entries.delete(oldest.value);
+		}
+	}
+};
+//#endregion
 //#region src/pipeline-analytics/pipeline/capture-crop.ts
 function createCaptureCrop(deps) {
 	return async (frameHandle, bbox, frameWidth, frameHeight, padding, maxWidth, deviceId) => {
@@ -59537,9 +59741,13 @@ function createNativeFrameTransport(deps) {
 		const now = Date.now();
 		if (now - lastCropMetricAt < NATIVE_CROP_METRIC_INTERVAL_MS) return;
 		lastCropMetricAt = now;
+		const dedupe = cropDedupe.drainCounts();
 		cropMetricLogger.info("native-crop window", { meta: {
 			nativeHits,
-			detectionFrameFallbacks: nativeFallbacks
+			detectionFrameFallbacks: nativeFallbacks,
+			wireFetches: dedupe.fetched,
+			coalesced: dedupe.coalesced,
+			reusedInWindow: dedupe.reused
 		} });
 	};
 	const requestNativeCrop = async (frameHandle, bbox, maxWidth, normalize) => {
@@ -59553,6 +59761,16 @@ function createNativeFrameTransport(deps) {
 		if (!native || native.width <= 0 || native.height <= 0) return null;
 		return await normalize(native);
 	};
+	/**
+	* Bounded and brief on purpose. Coalescing costs nothing; the 1.5 s window
+	* holds at most 12 crops in THIS process to keep far more than that off
+	* hub-main. It must never grow into the memory it was written to save.
+	*/
+	const cropDedupe = new NativeCropDedupe({
+		now: () => Date.now(),
+		ttlMs: 1500,
+		maxEntries: 12
+	});
 	const tryRequestNativeCrop = async (frameHandle, bbox, maxWidth, normalize) => {
 		try {
 			return await requestNativeCrop(frameHandle, bbox, maxWidth, normalize);
@@ -59561,7 +59779,7 @@ function createNativeFrameTransport(deps) {
 			return null;
 		}
 	};
-	const fetchNativeCropJpeg = async (frameHandle, paddedNorm, maxWidth) => tryRequestNativeCrop(frameHandle, paddedNorm, maxWidth, cropReplyToJpeg);
+	const fetchNativeCropJpeg = async (frameHandle, paddedNorm, maxWidth) => cropDedupe.run(frameHandle, paddedNorm, maxWidth, () => tryRequestNativeCrop(frameHandle, paddedNorm, maxWidth, cropReplyToJpeg));
 	const tryNativeCrop = async (frameHandle, paddedNorm, maxWidth) => {
 		return (await fetchNativeCropJpeg(frameHandle, paddedNorm, maxWidth))?.jpeg ?? null;
 	};
@@ -61241,8 +61459,15 @@ var EventMediaDispatcher = class {
 	* OWN box burned onto the NATIVE full frame downscaled to
 	* {@link SNAPSHOT_MAX_WIDTH}. On a native miss it falls back to the ≤640
 	* detection frame (`frameData`) downscaled to the same cap with a `logger.warn`
-	* — an honest LOWER-res frame, NEVER an upscale. Returns the JPEG, or `null`
-	* only if the sharp encode itself throws.
+	* — an honest LOWER-res frame, NEVER an upscale.
+	*
+	* Returns BOTH renderings of the same surface: the boxed tile the timeline
+	* wants, and its CLEAN twin (`drawBoxedFrame(…, [])` — encode only, the same
+	* call `keyFrame` uses). One extra encode, no second fetch and no second
+	* decode, because the notification ladder needs a densely-written whole-scene
+	* frame WITHOUT the rectangle and there was none: 19 of 38 measured
+	* `frame:'full'` deliveries carried the box. `null` only if a sharp encode
+	* throws.
 	*/
 	async boxedTimelineFrame(deviceId, frameHandle, frameData, fw, fh, ownerId, bbox, label) {
 		let nf = null;
@@ -63076,6 +63301,36 @@ function buildGlobalSettingsSchema(cap) {
 					step: .05,
 					default: AUDIO_DETECTION_DEFAULTS.classificationMinScore
 				},
+				{
+					type: "multiselect",
+					key: "audioAllowedClasses",
+					label: "Event classes",
+					description: "Which sounds may become an event on this camera. Leave empty to allow every class. The classifier is untouched — it keeps hearing and labelling everything; this only narrows what is worth an event and a notification here.",
+					options: require_dist.AUDIO_MACRO_LABELS.filter((l) => l.id !== "silence").map((l) => ({
+						value: l.id,
+						label: l.name
+					})),
+					default: AUDIO_DETECTION_DEFAULTS.audioAllowedClasses
+				},
+				{
+					type: "number",
+					key: "audioConfirmHits",
+					label: "Occurrences to confirm",
+					description: "How many times the same sound must be heard inside the window below before it becomes an event. 1 disables the window — every occurrence is an event.",
+					min: 1,
+					step: 1,
+					default: AUDIO_DETECTION_DEFAULTS.audioConfirmHits
+				},
+				{
+					type: "number",
+					key: "audioConfirmWindowSec",
+					label: "Confirmation window",
+					description: "Width of the corroboration window. Occurrences are counted per class, so two different sounds never confirm each other. Ignored when occurrences is 1.",
+					min: 1,
+					step: 1,
+					default: AUDIO_DETECTION_DEFAULTS.audioConfirmWindowSec,
+					unit: "s"
+				},
 				{
 					type: "number",
 					key: "levelDeviationDb",
@@ -65922,6 +66177,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	lastAudioInsertByDevice = /* @__PURE__ */ new Map();
 	lastMotionInsertByDevice = /* @__PURE__ */ new Map();
 	levelStateByDevice = /* @__PURE__ */ new Map();
+	/** Per-device corroboration window for classified audio (see
+	*  `audio-confirm-window.ts`). Torn down wherever `levelStateByDevice` is —
+	*  a stale window on a removed device would confirm on its first frame back. */
+	audioConfirmByDevice = /* @__PURE__ */ new Map();
 	/**
 	* Last ms a spatial track was alive on a device, any plane. Written on the
 	* frame path (one `Map.set` per processed frame), read O(1) by the audio-
@@ -67436,7 +67695,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 						mimeType: i.mimeType
 					})),
 					jsonSchema: request.jsonSchema,
-					temperature: request.temperature
+					temperature: request.temperature,
+					...request.timeoutMs !== void 0 ? { timeoutMs: request.timeoutMs } : {}
 				});
 				return result.ok ? {
 					ok: true,
@@ -68342,6 +68602,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			this.overlaySynthesisWarnAt.delete(data.deviceId);
 			this.forgetDeviceProcessors(data.deviceId);
 			this.levelStateByDevice.delete(data.deviceId);
+			this.audioConfirmByDevice.delete(data.deviceId);
 			this.settingsCaches.clearDevice(data.deviceId);
 			this.rawDeviceBlobMirror.invalidate(data.deviceId);
 		}
@@ -68360,6 +68621,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		this.overlaySynthesisWarnAt.delete(deviceId);
 		this.forgetDeviceProcessors(deviceId);
 		this.levelStateByDevice.delete(deviceId);
+		this.audioConfirmByDevice.delete(deviceId);
 		this.lastTrackActivityMs.delete(deviceId);
 		this.motionEventSnapshots?.forgetDevice(deviceId);
 		this.audioEpisodeByDevice.delete(deviceId);
@@ -68576,7 +68838,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 						mimeType: image.mimeType
 					})),
 					jsonSchema: i.jsonSchema,
-					temperature: i.temperature
+					temperature: i.temperature,
+					...i.timeoutMs !== void 0 ? { timeoutMs: i.timeoutMs } : {}
 				}),
 				cancelVision: async (requestId) => {
 					await api.llm.cancel.mutate({ requestId });
@@ -68871,6 +69134,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		this.nodeLiveness.clear();
 		this.gatedNodeByDevice.clear();
 		this.levelStateByDevice.clear();
+		this.audioConfirmByDevice.clear();
 		this.settingsCaches.clearAll();
 		this.rawDeviceBlobMirror.invalidateAll();
 		this.rawGlobalStoreMirror.invalidate();
@@ -69038,6 +69302,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				trackId: t.trackId,
 				deviceId,
 				className: t.className,
+				matched: t.matchedThisFrame !== false,
 				...t.labelPatch !== void 0 ? { labelPatch: t.labelPatch } : {},
 				timestamp: result.timestamp,
 				position: {
@@ -70885,12 +71150,15 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		this.notificationCenter?.observeAudio(deviceId, {
 			timestampMs: timestamp,
 			...level?.dbfs !== void 0 ? { dbfs: level.dbfs } : {},
-			labels: (frame.detections ?? []).filter((d) => d.score >= settings.classificationMinScore).map((d) => d.macroClass)
+			labels: (frame.detections ?? []).filter((d) => d.score >= settings.classificationMinScore).map((d) => d.macroClass).filter((macroClass) => settings.audioAllowedClasses.length === 0 || settings.audioAllowedClasses.includes(macroClass))
 		});
 		const route = classifyAudioFrame(topClassification ? {
 			className: topClassification.macroClass,
 			score: topClassification.score
-		} : void 0, { classificationMinScore: settings.classificationMinScore });
+		} : void 0, {
+			classificationMinScore: settings.classificationMinScore,
+			allowedClasses: settings.audioAllowedClasses
+		});
 		if (route.kind === "classification") {
 			if (!topClassification) {
 				this.ctx.logger.warn("classifyAudioFrame returned classification but topClassification is null", {
@@ -70899,6 +71167,26 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				});
 				return;
 			}
+			const confirm = observeAudioConfirm(this.audioConfirmByDevice.get(deviceId) ?? emptyAudioConfirmState(), {
+				className: route.className,
+				timestampMs: timestamp
+			}, {
+				confirmHits: settings.audioConfirmHits,
+				confirmWindowSec: settings.audioConfirmWindowSec
+			});
+			this.audioConfirmByDevice.set(deviceId, confirm.nextState);
+			if (!confirm.confirmed) {
+				this.ctx.logger.debug("audio event held for corroboration", {
+					tags: { deviceId },
+					meta: {
+						deviceId,
+						className: route.className,
+						confirmHits: settings.audioConfirmHits,
+						confirmWindowSec: settings.audioConfirmWindowSec
+					}
+				});
+				return;
+			}
 			const classified = {
 				deviceId,
 				timestamp,