@camstack/addon-post-analysis 1.2.167 → 1.2.169

package/dist/pipeline-analytics/index.mjs

@@ -1,4 +1,4 @@
-import { $ as buildEventKindDescriptor, A as NcSnoozeSuppressedSchema, At as DeviceType, B as SCENE_DIVERGED, Bt as literal, C as NcRuleInputSchema, Ct as subKindsOf, D as NcScheduleSchema, Dt as zoneAnalyticsCapability, E as NcRuleTargetSchema, Et as videoclipsCapability, F as RECORDING_EXPORT_MAX_READ_BYTES, Ft as sleep$1, G as TimelapseRuleSchema, Gt as string, H as TIMELAPSE_DENSE_FLOOR_SEC, Ht as object, I as RetrainStatusSchema, It as _enum, J as addonWidgetsSourceCapability, K as TrackSourceSchema, Kt as unknown, Lt as array, M as NcTaxonomySchema, Mt as hydrateSchema, N as OpsLogEntrySchema, Nt as isDeviceScopedCap, O as NcSnoozeInputSchema, Ot as errMsg, Pt as nodePin, Q as audioModeOf, R as SCENE_DEFAULT_ANCHOR_THRESHOLD, Rt as boolean, S as NcConditionDescriptorSchema, St as sceneMonitorCapability, T as NcRuleSchema, Tt as vectorDimFromBase64, U as TimelapseRuleInputSchema, Ut as partialRecord, V as SceneMonitorSchema, Vt as number, W as TimelapseRulePatchSchema, Wt as record, X as assertTimelapseCadences, Y as alarmPanelCapability, Z as audioMetricsCapability, _ as NC_ALARM_SYSTEM_EVENT_KINDS, _t as pipelineAnalyticsCapability, at as encodeVectorBase64, bt as readTimelapseGeneratedAt, ct as failureContributionCapability, d as EVENT_PAD_MS, dt as isScheduleActive, et as cosineSimilarity$1, f as FULL_IMAGE_BBOX, ft as isSourceCap, g as MediaFileKindEnum, gt as pickClusterStepModels, h as MACRO_LABELS, i as DEFAULT_EVENT_COLOR, j as NcSystemEventKindSchema, jt as createEvent, k as NcSnoozeSchema, kt as BaseAddon, l as DeclaredDevices, m as LabelAttributionSchema, mt as notificationRulesCapability, n as CLUSTER_MODEL_SCOPED_STEPS, nt as defineCustomActions, ot as evaluateSensorEdge, p as FailureCounters, pt as kebabToCamel, q as VISIT_MERGE_GAP_MS, qt as EventCategory, r as COCO_TO_MACRO, rt as deriveRecordingMode, s as DETECTION_MACRO_CLASSES, st as faceGalleryCapability, t as BaseDevice, tt as customAction, u as EVENT_KIND_BY_CAP, ut as isDetectionMacroClass, v as NC_CONDITION_CATALOG, vt as plateGalleryCapability, w as NcRulePatchSchema, wt as systemEventFilterApplies, x as NC_TAXONOMY, y as NC_DEFAULT_SNOOZE_MINUTES, yt as readDeviceStateFrom, z as SCENE_DEFAULT_UNCOVERED_POLICY, zt as discriminatedUnion } from "../dist-DgOc1kH7.mjs";
+import { $ as audioModeOf, A as NcSnoozeSchema, At as BaseAddon, B as SCENE_DEFAULT_UNCOVERED_POLICY, Bt as boolean, C as NcConditionDescriptorSchema, Ct as sceneMonitorCapability, D as NcRuleTargetSchema, Dt as videoclipsCapability, E as NcRuleSchema, Et as vectorDimFromBase64, Ft as isDeviceScopedCap, G as TimelapseRulePatchSchema, Gt as partialRecord, H as SceneMonitorSchema, Ht as literal, I as RECORDING_EXPORT_MAX_READ_BYTES, It as nodePin, J as VISIT_MERGE_GAP_MS, Jt as unknown, K as TimelapseRuleSchema, Kt as record, L as RetrainStatusSchema, Lt as sleep$1, M as NcSystemEventKindSchema, Mt as DeviceType, N as NcTaxonomySchema, Nt as createEvent, O as NcScheduleSchema, Ot as zoneAnalyticsCapability, P as OpsLogEntrySchema, Pt as hydrateSchema, Q as audioMetricsCapability, Rt as _enum, S as NC_TAXONOMY, T as NcRulePatchSchema, Tt as systemEventFilterApplies, U as TIMELAPSE_DENSE_FLOOR_SEC, Ut as number, V as SCENE_DIVERGED, Vt as discriminatedUnion, W as TimelapseRuleInputSchema, Wt as object, X as alarmPanelCapability, Y as addonWidgetsSourceCapability, Yt as EventCategory, Z as assertTimelapseCadences, _ as MediaFileKindEnum, _t as pickClusterStepModels, a as DEFAULT_EVENT_COLOR, b as NC_DEFAULT_SNOOZE_MINUTES, bt as readDeviceStateFrom, c as DETECTION_MACRO_CLASSES, ct as faceGalleryCapability, d as EVENT_KIND_BY_CAP, dt as isDetectionMacroClass, et as buildEventKindDescriptor, f as EVENT_PAD_MS, ft as isScheduleActive, g as MACRO_LABELS, h as LabelAttributionSchema, ht as notificationRulesCapability, i as COCO_TO_MACRO, it as deriveRecordingMode, j as NcSnoozeSuppressedSchema, jt as CamProfileSchema, k as NcSnoozeInputSchema, kt as errMsg, lt as failureContributionCapability, m as FailureCounters, mt as kebabToCamel, n as BaseDevice, nt as customAction, ot as encodeVectorBase64, p as FULL_IMAGE_BBOX, pt as isSourceCap, q as TrackSourceSchema, qt as string, r as CLUSTER_MODEL_SCOPED_STEPS, rt as defineCustomActions, st as evaluateSensorEdge, t as AUDIO_MACRO_LABELS, tt as cosineSimilarity$1, u as DeclaredDevices, v as NC_ALARM_SYSTEM_EVENT_KINDS, vt as pipelineAnalyticsCapability, w as NcRuleInputSchema, wt as subKindsOf, xt as readTimelapseGeneratedAt, y as NC_CONDITION_CATALOG, yt as plateGalleryCapability, z as SCENE_DEFAULT_ANCHOR_THRESHOLD, zt as array } from "../dist-Cubb8Avj.mjs";
 import { t as __exportAll } from "../embedding-encoder/index.mjs";
 import * as fs from "node:fs";
 import { promises } from "node:fs";
@@ -3132,7 +3132,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)
@@ -19683,8 +19684,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 = [...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) {
@@ -19692,15 +19722,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?
@@ -27232,9 +27262,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.
 *
@@ -33155,6 +33205,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;
 }
 /**
@@ -36601,19 +36654,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
 };
 /**
@@ -39412,6 +39465,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;
@@ -43911,6 +43970,36 @@ var AnalyticsQueryFacade = class {
 //#region src/pipeline-analytics/audio-detection-settings.ts
 var AudioDetectionSettingsSchema = object({
 	classificationMinScore: 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: array(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: number().int().min(1).default(2),
+	/** Width of the corroboration window. Ignored when `audioConfirmHits` is 1. */
+	audioConfirmWindowSec: number().positive().default(10),
 	levelDeviationDb: number().positive().default(10),
 	levelWindowSec: number().positive().default(10),
 	levelMaxWaitSec: number().positive().default(20),
@@ -43951,8 +44040,17 @@ var AudioDetectionSettingsSchema = object({
 	audioEpisodeOpenHoldSec: number().nonnegative().default(1.5),
 	/** Class must be absent this long before the episode closes. */
 	audioEpisodeCloseGapSec: number().positive().default(12),
-	/** After close, the same class cannot reopen until this elapses. */
-	audioEpisodeCooldownSec: 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: number().nonnegative().default(60)
 });
 var AUDIO_DETECTION_DEFAULTS = AudioDetectionSettingsSchema.parse({});
 /**
@@ -44129,14 +44227,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
@@ -59283,6 +59412,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) => {
@@ -59463,9 +59667,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) => {
@@ -59479,6 +59687,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);
@@ -59487,7 +59705,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;
 	};
@@ -61167,8 +61385,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;
@@ -63002,6 +63227,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: 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",
@@ -65848,6 +66103,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	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-
@@ -67362,7 +67621,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 						mimeType: i.mimeType
 					})),
 					jsonSchema: request.jsonSchema,
-					temperature: request.temperature
+					temperature: request.temperature,
+					...request.timeoutMs !== void 0 ? { timeoutMs: request.timeoutMs } : {}
 				});
 				return result.ok ? {
 					ok: true,
@@ -68268,6 +68528,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 			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);
 		}
@@ -68286,6 +68547,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 		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);
@@ -68502,7 +68764,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 						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 });
@@ -68797,6 +69060,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 		this.nodeLiveness.clear();
 		this.gatedNodeByDevice.clear();
 		this.levelStateByDevice.clear();
+		this.audioConfirmByDevice.clear();
 		this.settingsCaches.clearAll();
 		this.rawDeviceBlobMirror.invalidateAll();
 		this.rawGlobalStoreMirror.invalidate();
@@ -68964,6 +69228,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 				trackId: t.trackId,
 				deviceId,
 				className: t.className,
+				matched: t.matchedThisFrame !== false,
 				...t.labelPatch !== void 0 ? { labelPatch: t.labelPatch } : {},
 				timestamp: result.timestamp,
 				position: {
@@ -70811,12 +71076,15 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 		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", {
@@ -70825,6 +71093,26 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 				});
 				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,

package/dist/pipeline-analytics/remoteEntry.js

@@ -30,7 +30,7 @@ async function d(e) {
 	}
 }
 async function f() {
-	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-CUasEI3s.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-D74iweVp.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-post-analysis",
-  "version": "1.2.167",
+  "version": "1.2.169",
   "description": "Post-Analysis bundle — enrichment, embedding-encoder, pipeline-analytics. Multi-entry npm package shipping addons that consume pipeline output.",
   "keywords": [
     "camstack",